@onekeyfe/hd-core 0.2.7 → 0.2.9

package/src/api/BaseMethod.ts

@@ -1,4 +1,8 @@
-import { supportInputPinOnSoftware, getDeviceType } from '../utils/deviceFeaturesUtils';
+import {
+  supportInputPinOnSoftware,
+  supportModifyHomescreen,
+  getDeviceType,
+} from '../utils/deviceFeaturesUtils';
 import { createDeviceMessage } from '../events/device';
 import { UI_REQUEST } from '../constants/ui-request';
 import { Device } from '../device/Device';
@@ -124,9 +128,11 @@ export abstract class BaseMethod<Params = undefined> {
   checkDeviceSupportFeature() {
     if (!this.device || !this.device.features) return;
     const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+    const modifyHomescreen = supportModifyHomescreen(this.device.features);
     this.postMessage(
       createDeviceMessage(DEVICE.SUPPORT_FEATURES, {
         inputPinOnSoftware,
+        modifyHomescreen,
         device: this.device.toMessageObject(),
       })
     );

package/src/api/btc/helpers/signtxLegacy.ts

@@ -159,7 +159,7 @@ const saveTxSignatures = (
     if (!signature) {
       throw ERRORS.TypedError(
         HardwareErrorCode.RuntimeError,
-        'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.'
+        'saveTxSignatures: Unexpected null in oneKey:TxRequestSerialized signature.'
       );
     }
     signatures[signature_index] = signature;

package/src/api/cardano/CardanoGetAddress.ts

@@ -0,0 +1,87 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams } from '../helpers/paramsValidator';
+import {
+  validateAddressParameters,
+  addressParametersToProto,
+  addressParametersFromProto,
+} from './helper/addressParameters';
+import { serializedPath } from '../helpers/pathUtils';
+import { CardanoGetAddressParams, CardanoAddress } from '../../types/api/cardanoGetAddress';
+
+export default class CardanoGetAddress extends BaseMethod<CardanoGetAddressParams[]> {
+  hasBundle?: boolean;
+
+  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] };
+
+    this.params = payload.bundle.map((batch: any) => {
+      // validate incoming parameters for each batch
+      validateParams(batch, [
+        { name: 'addressParameters', type: 'object', required: true },
+        { name: 'networkId', type: 'number', required: true },
+        { name: 'protocolMagic', type: 'number', required: true },
+        { name: 'derivationType', type: 'number' },
+        { name: 'address', type: 'string' },
+        { name: 'showOnTrezor', type: 'boolean' },
+      ]);
+
+      validateAddressParameters(batch.addressParameters);
+
+      return {
+        address_parameters: addressParametersToProto(batch.addressParameters),
+        address: batch.address,
+        protocol_magic: batch.protocolMagic,
+        network_id: batch.networkId,
+        derivation_type:
+          typeof batch.derivationType !== 'undefined'
+            ? batch.derivationType
+            : PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        show_display: typeof batch.showOnOneKey === 'boolean' ? !!batch.showOneKey : true,
+      };
+    });
+  }
+
+  async run() {
+    const responses: CardanoAddress[] = [];
+
+    for (const batch of this.params) {
+      const { address_parameters, protocol_magic, network_id, derivation_type, show_display } =
+        batch;
+      const response = await this.device.commands.typedCall('CardanoGetAddress', 'CardanoAddress', {
+        address_parameters,
+        protocol_magic,
+        network_id,
+        derivation_type,
+        show_display,
+      });
+
+      const publicKeyRes = await this.device.commands.typedCall(
+        'CardanoGetPublicKey',
+        'CardanoPublicKey',
+        {
+          address_n: address_parameters.address_n.slice(0, 3),
+          derivation_type,
+          show_display,
+        }
+      );
+
+      responses.push({
+        addressParameters: addressParametersFromProto(batch.address_parameters),
+        protocolMagic: batch.protocol_magic,
+        networkId: batch.network_id,
+        serializedPath: serializedPath(batch.address_parameters.address_n),
+        serializedStakingPath: serializedPath(batch.address_parameters.address_n_staking),
+        address: response.message.address,
+        xpub: publicKeyRes.message.xpub,
+      });
+    }
+
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/src/api/cardano/CardanoGetPublicKey.ts

@@ -0,0 +1,55 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams } from '../helpers/paramsValidator';
+import { serializedPath, validatePath } from '../helpers/pathUtils';
+import { CardanoPublicKeyParams, CardanoPublicKey } from '../../types/api/cardanoGetPublicKey';
+
+export default class CardanoGetPublicKey extends BaseMethod<CardanoPublicKeyParams[]> {
+  hasBundle?: boolean;
+
+  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] };
+
+    validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+
+    this.params = payload.bundle.map((batch: any) => {
+      // validate incoming parameters for each batch
+      validateParams(batch, [
+        { name: 'path', required: true },
+        { name: 'derivationType', type: 'number' },
+        { name: 'showOnTrezor', type: 'boolean' },
+      ]);
+
+      const path = validatePath(batch.path, 3);
+      return {
+        address_n: path,
+        derivation_type:
+          typeof batch.derivationType !== 'undefined'
+            ? batch.derivationType
+            : PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        show_display: typeof batch.showOnOneKey === 'boolean' ? batch.showOnOneKey : false,
+      };
+    });
+  }
+
+  async run() {
+    const responses: CardanoPublicKey[] = [];
+    const cmd = this.device.getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const batch = this.params[i];
+      const { message } = await cmd.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', batch);
+      responses.push({
+        path: batch.address_n,
+        serializedPath: serializedPath(batch.address_n),
+        publicKey: message.xpub,
+        node: message.node,
+      });
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

package/src/api/cardano/CardanoSignTransaction.ts

@@ -0,0 +1,309 @@
+import { BaseMethod } from '../BaseMethod';
+import { PROTO } from '../../constants';
+import { UI_REQUEST } from '../../constants/ui-request';
+import { validateParams } from '../helpers/paramsValidator';
+import {
+  transformInput,
+  Path,
+  CollateralInputWithPath,
+  transformCollateralInput,
+  transformReferenceInput,
+} from './helper/cardanoInputs';
+import { transformOutput, sendOutput } from './helper/cardanoOutputs';
+import { transformCertificate } from './helper/certificate';
+import { tokenBundleToProto } from './helper/token';
+import {
+  transformAuxiliaryData,
+  modifyAuxiliaryDataForBackwardsCompatibility,
+} from './helper/auxiliaryData';
+import { gatherWitnessPaths } from './helper/witnesses';
+import { validatePath } from '../helpers/pathUtils';
+import type {
+  CertificateWithPoolOwnersAndRelays,
+  AssetGroupWithTokens,
+  CardanoSignedTxData,
+  CardanoSignedTxWitness,
+  CardanoAuxiliaryDataSupplement,
+} from '../../types/api/cardano';
+
+export default class CardanoSignTransaction extends BaseMethod<any> {
+  hasBundle?: boolean;
+
+  init() {
+    this.checkDeviceId = true;
+    this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+
+    this.hasBundle = !!this.payload?.bundle;
+
+    const { payload } = this;
+
+    // validate incoming parameters
+    validateParams(payload, [
+      { name: 'signingMode', type: 'number', required: true },
+      { name: 'inputs', type: 'array', required: true },
+      { name: 'outputs', type: 'array', required: true, allowEmpty: true },
+      { name: 'fee', type: 'uint', required: true },
+      { name: 'ttl', type: 'uint' },
+      { name: 'certificates', type: 'array', allowEmpty: true },
+      { name: 'withdrawals', type: 'array', allowEmpty: true },
+      { name: 'mint', type: 'array', allowEmpty: true },
+      { name: 'validityIntervalStart', type: 'uint' },
+      { name: 'scriptDataHash', type: 'string' },
+      { name: 'collateralInputs', type: 'array', allowEmpty: true },
+      { name: 'requiredSigners', type: 'array', allowEmpty: true },
+      { name: 'totalCollateral', type: 'uint' },
+      { name: 'referenceInputs', type: 'array', allowEmpty: true },
+      { name: 'protocolMagic', type: 'number', required: true },
+      { name: 'networkId', type: 'number', required: true },
+      { name: 'additionalWitnessRequests', type: 'array', allowEmpty: true },
+      { name: 'derivationType', type: 'number' },
+      { name: 'includeNetworkId', type: 'boolean' },
+    ]);
+
+    const inputsWithPath = payload.inputs.map(transformInput);
+    const outputsWithData = payload.outputs.map(transformOutput);
+
+    let certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[] = [];
+    if (payload.certificates) {
+      certificatesWithPoolOwnersAndRelays = payload.certificates.map(transformCertificate);
+    }
+
+    let withdrawals: PROTO.CardanoTxWithdrawal[] = [];
+    if (payload.withdrawals) {
+      withdrawals = payload.withdrawals.map((withdrawal: any) => {
+        validateParams(withdrawal, [
+          { name: 'amount', type: 'uint', required: true },
+          { name: 'scriptHash', type: 'string' },
+          { name: 'keyHash', type: 'string' },
+        ]);
+        return {
+          path: withdrawal.path ? validatePath(withdrawal.path, 5) : undefined,
+          amount: withdrawal.amount,
+          script_hash: withdrawal.scriptHash,
+          key_hash: withdrawal.keyHash,
+        };
+      });
+    }
+
+    let mint: AssetGroupWithTokens[] = [];
+    if (payload.mint) {
+      mint = tokenBundleToProto(payload.mint);
+    }
+
+    let auxiliaryData;
+    if (payload.auxiliaryData) {
+      auxiliaryData = transformAuxiliaryData(payload.auxiliaryData);
+    }
+
+    let additionalWitnessRequests: Path[] = [];
+    if (payload.additionalWitnessRequests) {
+      additionalWitnessRequests = payload.additionalWitnessRequests.map((witnessRequest: any) =>
+        validatePath(witnessRequest, 3)
+      );
+    }
+
+    let collateralInputsWithPath: CollateralInputWithPath[] = [];
+    if (payload.collateralInputs) {
+      collateralInputsWithPath = payload.collateralInputs.map(transformCollateralInput);
+    }
+
+    // @ts-expect-error
+    let requiredSigners: PROTO.CardanoTxRequiredSigner[] = [];
+    if (payload.requiredSigners) {
+      requiredSigners = payload.requiredSigners.map((requiredSigner: any) => {
+        validateParams(requiredSigner, [{ name: 'keyHash', type: 'string' }]);
+        return {
+          key_path: requiredSigner.keyPath ? validatePath(requiredSigner.keyPath, 3) : undefined,
+          key_hash: requiredSigner.keyHash,
+          // @ts-expect-error
+        } as PROTO.CardanoTxRequiredSigner;
+      });
+    }
+
+    const collateralReturnWithData = payload.collateralReturn
+      ? transformOutput(payload.collateralReturn)
+      : undefined;
+
+    // @ts-expect-error
+    let referenceInputs: PROTO.CardanoTxReferenceInput[] = [];
+    if (payload.referenceInputs) {
+      referenceInputs = payload.referenceInputs.map(transformReferenceInput);
+    }
+
+    this.params = {
+      signingMode: payload.signingMode,
+      inputsWithPath,
+      outputsWithData,
+      fee: payload.fee,
+      ttl: payload.ttl,
+      certificatesWithPoolOwnersAndRelays,
+      withdrawals,
+      mint,
+      auxiliaryData,
+      validityIntervalStart: payload.validityIntervalStart,
+      scriptDataHash: payload.scriptDataHash,
+      collateralInputsWithPath,
+      requiredSigners,
+      collateralReturnWithData,
+      totalCollateral: payload.totalCollateral,
+      referenceInputs,
+      protocolMagic: payload.protocolMagic,
+      networkId: payload.networkId,
+      witnessPaths: gatherWitnessPaths(
+        inputsWithPath,
+        certificatesWithPoolOwnersAndRelays,
+        withdrawals,
+        collateralInputsWithPath,
+        requiredSigners,
+        additionalWitnessRequests,
+        payload.signingMode
+      ),
+      additionalWitnessRequests,
+      derivationType:
+        typeof payload.derivationType !== 'undefined'
+          ? payload.derivationType
+          : PROTO.CardanoDerivationType.ICARUS_TREZOR,
+      includeNetworkId: payload.includeNetworkId,
+    };
+  }
+
+  async signTx(): Promise<CardanoSignedTxData> {
+    const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+
+    const hasAuxiliaryData = !!this.params.auxiliaryData;
+
+    const signTxInitMessage = {
+      signing_mode: this.params.signingMode,
+      protocol_magic: this.params.protocolMagic,
+      network_id: this.params.networkId,
+      inputs_count: this.params.inputsWithPath.length,
+      outputs_count: this.params.outputsWithData.length,
+      fee: this.params.fee,
+      ttl: this.params.ttl,
+      certificates_count: this.params.certificatesWithPoolOwnersAndRelays.length,
+      withdrawals_count: this.params.withdrawals.length,
+      has_auxiliary_data: hasAuxiliaryData,
+      validity_interval_start: this.params.validityIntervalStart,
+      witness_requests_count: this.params.witnessPaths.length,
+      minting_asset_groups_count: this.params.mint.length,
+      script_data_hash: this.params.scriptDataHash,
+      collateral_inputs_count: this.params.collateralInputsWithPath.length,
+      required_signers_count: this.params.requiredSigners.length,
+      has_collateral_return: this.params.collateralReturnWithData != null,
+      total_collateral: this.params.totalCollateral,
+      reference_inputs_count: this.params.referenceInputs.length,
+      derivation_type: this.params.derivationType,
+      include_network_id: this.params.includeNetworkId,
+    };
+
+    // init
+    await typedCall('CardanoSignTxInit', 'CardanoTxItemAck', signTxInitMessage);
+    // inputs
+    for (const { input } of this.params.inputsWithPath) {
+      await typedCall('CardanoTxInput', 'CardanoTxItemAck', input);
+    }
+    // outputs and tokens
+    for (const outputWithData of this.params.outputsWithData) {
+      await sendOutput(typedCall, outputWithData);
+    }
+    // certificates, owners and relays
+    for (const { certificate, poolOwners, poolRelays } of this.params
+      .certificatesWithPoolOwnersAndRelays) {
+      await typedCall('CardanoTxCertificate', 'CardanoTxItemAck', certificate);
+      for (const poolOwner of poolOwners) {
+        await typedCall('CardanoPoolOwner', 'CardanoTxItemAck', poolOwner);
+      }
+      for (const poolRelay of poolRelays) {
+        await typedCall('CardanoPoolRelayParameters', 'CardanoTxItemAck', poolRelay);
+      }
+    }
+    // withdrawals
+    for (const withdrawal of this.params.withdrawals) {
+      await typedCall('CardanoTxWithdrawal', 'CardanoTxItemAck', withdrawal);
+    }
+    // auxiliary data
+    let auxiliaryDataSupplement: CardanoAuxiliaryDataSupplement | undefined;
+    if (this.params.auxiliaryData) {
+      const { catalyst_registration_parameters } = this.params.auxiliaryData;
+      if (catalyst_registration_parameters) {
+        this.params.auxiliaryData = modifyAuxiliaryDataForBackwardsCompatibility(
+          this.params.auxiliaryData
+        );
+      }
+
+      const { message } = await typedCall(
+        'CardanoTxAuxiliaryData',
+        'CardanoTxAuxiliaryDataSupplement',
+        this.params.auxiliaryData
+      );
+
+      const auxiliaryDataType: any = PROTO.CardanoTxAuxiliaryDataSupplementType[message.type];
+      if (auxiliaryDataType !== PROTO.CardanoTxAuxiliaryDataSupplementType.NONE) {
+        auxiliaryDataSupplement = {
+          type: auxiliaryDataType,
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          auxiliaryDataHash: message.auxiliary_data_hash!,
+          catalystSignature: message.catalyst_signature,
+        };
+      }
+      await typedCall('CardanoTxHostAck', 'CardanoTxItemAck');
+    }
+    // mint
+    if (this.params.mint.length > 0) {
+      await typedCall('CardanoTxMint', 'CardanoTxItemAck', {
+        asset_groups_count: this.params.mint.length,
+      });
+      for (const assetGroup of this.params.mint) {
+        await typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+          policy_id: assetGroup.policyId,
+          tokens_count: assetGroup.tokens.length,
+        });
+        for (const token of assetGroup.tokens) {
+          await typedCall('CardanoToken', 'CardanoTxItemAck', token);
+        }
+      }
+    }
+    // collateral inputs
+    for (const { collateralInput } of this.params.collateralInputsWithPath) {
+      // @ts-expect-error
+      await typedCall('CardanoTxCollateralInput', 'CardanoTxItemAck', collateralInput);
+    }
+    // required signers
+    for (const requiredSigner of this.params.requiredSigners) {
+      // @ts-expect-error
+      await typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
+    }
+    // collateral return
+    if (this.params.collateralReturnWithData) {
+      await sendOutput(typedCall, this.params.collateralReturnWithData);
+    }
+    // reference inputs
+    for (const referenceInput of this.params.referenceInputs) {
+      // @ts-expect-error
+      await typedCall('CardanoTxReferenceInput', 'CardanoTxItemAck', referenceInput);
+    }
+    // witnesses
+    const witnesses: CardanoSignedTxWitness[] = [];
+    for (const path of this.params.witnessPaths) {
+      const { message } = await typedCall('CardanoTxWitnessRequest', 'CardanoTxWitnessResponse', {
+        path,
+      });
+      witnesses.push({
+        type: PROTO.CardanoTxWitnessType[message.type] as any,
+        pubKey: message.pub_key,
+        signature: message.signature,
+        chainCode: message.chain_code,
+      });
+    }
+    // tx hash
+    const { message: txBodyHashMessage } = await typedCall('CardanoTxHostAck', 'CardanoTxBodyHash');
+    // finish
+    await typedCall('CardanoTxHostAck', 'CardanoSignTxFinished');
+
+    return { hash: txBodyHashMessage.tx_hash, witnesses, auxiliaryDataSupplement };
+  }
+
+  run() {
+    return this.signTx();
+  }
+}

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

@@ -0,0 +1,118 @@
+import { ERRORS, HardwareErrorCode } from '@onekeyfe/hd-shared';
+import { validatePath } from '../../helpers/pathUtils';
+import { validateParams } from '../../helpers/paramsValidator';
+import { PROTO } from '../../../constants';
+import type { CardanoAddressParameters } from '../../../types/api/cardano';
+
+export const validateAddressParameters = (addressParameters: CardanoAddressParameters) => {
+  validateParams(addressParameters, [
+    { name: 'addressType', type: 'number', required: true },
+    { name: 'stakingKeyHash', type: 'string' },
+    { name: 'paymentScriptHash', type: 'string' },
+    { name: 'stakingScriptHash', type: 'string' },
+  ]);
+
+  if (addressParameters.path) {
+    validatePath(addressParameters.path);
+  }
+  if (addressParameters.stakingPath) {
+    validatePath(addressParameters.stakingPath);
+  }
+
+  if (addressParameters.certificatePointer) {
+    validateParams(addressParameters.certificatePointer, [
+      { name: 'blockIndex', type: 'number', required: true },
+      { name: 'txIndex', type: 'number', required: true },
+      { name: 'certificateIndex', type: 'number', required: true },
+    ]);
+  }
+};
+
+export const addressParametersToProto = (
+  addressParameters: CardanoAddressParameters
+): PROTO.CardanoAddressParametersType => {
+  let path: number[] = [];
+  if (addressParameters.path) {
+    path = validatePath(addressParameters.path, 3);
+  }
+
+  let stakingPath: number[] = [];
+  if (addressParameters.stakingPath) {
+    stakingPath = validatePath(addressParameters.stakingPath, 3);
+  }
+
+  let certificatePointer;
+  if (addressParameters.certificatePointer) {
+    certificatePointer = {
+      block_index: addressParameters.certificatePointer.blockIndex,
+      tx_index: addressParameters.certificatePointer.txIndex,
+      certificate_index: addressParameters.certificatePointer.certificateIndex,
+    };
+  }
+
+  return {
+    address_type: addressParameters.addressType,
+    address_n: path,
+    address_n_staking: stakingPath,
+    staking_key_hash: addressParameters.stakingKeyHash,
+    certificate_pointer: certificatePointer,
+    script_payment_hash: addressParameters.paymentScriptHash,
+    script_staking_hash: addressParameters.stakingScriptHash,
+  };
+};
+
+export const addressParametersFromProto = (
+  addressParameters: PROTO.CardanoAddressParametersType
+): CardanoAddressParameters => {
+  let certificatePointer;
+  if (addressParameters.certificate_pointer) {
+    certificatePointer = {
+      blockIndex: addressParameters.certificate_pointer.block_index,
+      txIndex: addressParameters.certificate_pointer.tx_index,
+      certificateIndex: addressParameters.certificate_pointer.certificate_index,
+    };
+  }
+
+  return {
+    addressType: addressParameters.address_type,
+    path: addressParameters.address_n,
+    stakingPath: addressParameters.address_n_staking,
+    stakingKeyHash: addressParameters.staking_key_hash,
+    certificatePointer,
+  };
+};
+
+export const modifyAddressParametersForBackwardsCompatibility = (
+  address_parameters: PROTO.CardanoAddressParametersType
+): PROTO.CardanoAddressParametersType => {
+  if (address_parameters.address_type === PROTO.CardanoAddressType.REWARD) {
+    // older firmware expects reward address path in path field instead of staking path
+    let { address_n, address_n_staking } = address_parameters;
+
+    if (address_n.length > 0 && address_n_staking.length > 0) {
+      throw ERRORS.TypedError(
+        HardwareErrorCode.CallMethodInvalidParameter,
+        `Only stakingPath is allowed for CardanoAddressType.REWARD`
+      );
+    }
+
+    if (address_n.length > 0) {
+      address_n_staking = address_n;
+      address_n = [];
+    }
+    // TODO: version check
+    // if (device.atLeast(['0', '2.4.3'])) {
+    // } else if (address_n_staking.length > 0) {
+    //   address_n = address_n_staking;
+    //   address_n_staking = [];
+    // }
+
+    return {
+      ...address_parameters,
+      address_n,
+      address_n_staking,
+    };
+  }
+
+  return address_parameters;
+};

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

@@ -0,0 +1,74 @@
+import {
+  validateAddressParameters,
+  addressParametersToProto,
+  modifyAddressParametersForBackwardsCompatibility,
+} from './addressParameters';
+import { validateParams } from '../../helpers/paramsValidator';
+import { validatePath } from '../../helpers/pathUtils';
+import type {
+  CardanoAuxiliaryData,
+  CardanoCatalystRegistrationParameters,
+} from '../../../types/api/cardano';
+import { PROTO } from '../../../constants';
+
+const transformCatalystRegistrationParameters = (
+  catalystRegistrationParameters: CardanoCatalystRegistrationParameters
+): PROTO.CardanoCatalystRegistrationParametersType => {
+  validateParams(catalystRegistrationParameters, [
+    { name: 'votingPublicKey', type: 'string', required: true },
+    { name: 'stakingPath', required: true },
+    { name: 'nonce', type: 'uint', required: true },
+  ]);
+  validateAddressParameters(catalystRegistrationParameters.rewardAddressParameters);
+
+  return {
+    voting_public_key: catalystRegistrationParameters.votingPublicKey,
+    staking_path: validatePath(catalystRegistrationParameters.stakingPath, 3),
+    reward_address_parameters: addressParametersToProto(
+      catalystRegistrationParameters.rewardAddressParameters
+    ),
+    nonce: catalystRegistrationParameters.nonce,
+  };
+};
+
+export const transformAuxiliaryData = (
+  auxiliaryData: CardanoAuxiliaryData
+): PROTO.CardanoTxAuxiliaryData => {
+  validateParams(auxiliaryData, [
+    {
+      name: 'hash',
+      type: 'string',
+    },
+  ]);
+
+  let catalystRegistrationParameters;
+  if (auxiliaryData.catalystRegistrationParameters) {
+    catalystRegistrationParameters = transformCatalystRegistrationParameters(
+      auxiliaryData.catalystRegistrationParameters
+    );
+  }
+
+  return {
+    hash: auxiliaryData.hash,
+    catalyst_registration_parameters: catalystRegistrationParameters,
+  };
+};
+
+export const modifyAuxiliaryDataForBackwardsCompatibility = (
+  auxiliary_data: PROTO.CardanoTxAuxiliaryData
+): PROTO.CardanoTxAuxiliaryData => {
+  const { catalyst_registration_parameters } = auxiliary_data;
+  if (catalyst_registration_parameters) {
+    catalyst_registration_parameters.reward_address_parameters =
+      modifyAddressParametersForBackwardsCompatibility(
+        catalyst_registration_parameters.reward_address_parameters
+      );
+
+    return {
+      ...auxiliary_data,
+      catalyst_registration_parameters,
+    };
+  }
+
+  return auxiliary_data;
+};