@trezor/connect 10.0.0-beta.1 → 10.0.0-beta.2

package/lib/api/cardano/api/cardanoSignTransaction.js

@@ -1,301 +0,0 @@
-import { CardanoSignTransactionExtended, CardanoSignTransaction as CardanoSignTransactionSchema } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import cardano from "@trezor/network-cardano/runtime";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert, Type } from "@trezor/schema-utils";
-import { AbstractMethod } from "../../../core/AbstractMethod.js";
-import { getMiscNetwork } from "../../../data/coinInfo.js";
-import { validatePath } from "../../../utils/pathUtils.js";
-import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.js";
-import { modifyAuxiliaryDataForBackwardsCompatibility, transformAuxiliaryData } from "../cardanoAuxiliaryData.js";
-import { transformCertificate } from "../cardanoCertificate.js";
-import { transformCollateralInput, transformInput, transformReferenceInput } from "../cardanoInputs.js";
-import { sendOutput, transformOutput } from "../cardanoOutputs.js";
-import { tokenBundleToProto } from "../cardanoTokenBundle.js";
-import { gatherWitnessPaths } from "../cardanoWitnesses.js";
-const CardanoSignTransactionFeatures = Object.freeze({
-  Conway: ['0', '2.7.1']
-});
-export default class CardanoSignTransaction extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    if (payload.metadata) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'Metadata field has been replaced by auxiliaryData.');
-    }
-    if (payload.auxiliaryData?.blob) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'Auxiliary data can now only be sent as a hash.');
-    }
-    if (payload.auxiliaryData?.catalystRegistrationParameters) {
-      console.warn('Please use cVoteRegistrationParameters instead of catalystRegistrationParameters.');
-      payload.auxiliaryData.cVoteRegistrationParameters = payload.auxiliaryData.catalystRegistrationParameters;
-    }
-    if (payload.auxiliaryData?.governanceRegistrationParameters) {
-      console.warn('Please use cVoteRegistrationParameters instead of governanceRegistrationParameters.');
-      payload.auxiliaryData.cVoteRegistrationParameters = payload.auxiliaryData.governanceRegistrationParameters;
-    }
-    Assert(Type.Union([CardanoSignTransactionSchema, CardanoSignTransactionExtended]), payload);
-    const inputsWithPath = payload.inputs.map(transformInput);
-    const outputsWithData = payload.outputs.map(transformOutput);
-    let certificatesWithPoolOwnersAndRelays = [];
-    if (payload.certificates) {
-      certificatesWithPoolOwnersAndRelays = payload.certificates.map(transformCertificate);
-    }
-    let withdrawals = [];
-    if (payload.withdrawals) {
-      withdrawals = payload.withdrawals.map(withdrawal => ({
-        path: withdrawal.path ? validatePath(withdrawal.path, 5) : undefined,
-        amount: withdrawal.amount,
-        script_hash: withdrawal.scriptHash,
-        key_hash: withdrawal.keyHash
-      }));
-    }
-    let mint = [];
-    if (payload.mint) {
-      mint = tokenBundleToProto(payload.mint);
-    }
-    let auxiliaryData;
-    if (payload.auxiliaryData) {
-      auxiliaryData = transformAuxiliaryData(payload.auxiliaryData);
-    }
-    let additionalWitnessRequests = [];
-    if (payload.additionalWitnessRequests) {
-      additionalWitnessRequests = payload.additionalWitnessRequests.map(witnessRequest => validatePath(witnessRequest, 3));
-    }
-    let collateralInputsWithPath = [];
-    if (payload.collateralInputs) {
-      collateralInputsWithPath = payload.collateralInputs.map(transformCollateralInput);
-    }
-    let requiredSigners = [];
-    if (payload.requiredSigners) {
-      requiredSigners = payload.requiredSigners.map(requiredSigner => ({
-        key_path: requiredSigner.keyPath ? validatePath(requiredSigner.keyPath, 3) : undefined,
-        key_hash: requiredSigner.keyHash
-      }));
-    }
-    const collateralReturnWithData = payload.collateralReturn ? transformOutput(payload.collateralReturn) : undefined;
-    let referenceInputs = [];
-    if (payload.referenceInputs) {
-      referenceInputs = payload.referenceInputs.map(transformReferenceInput);
-    }
-    const 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,
-      tagCborSets: payload.tagCborSets,
-      unsignedTx: 'unsignedTx' in payload ? payload.unsignedTx : undefined,
-      testnet: 'testnet' in payload ? payload.testnet : undefined,
-      chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false,
-      payment_req: payload.payment_req ? encodePaymentRequestAmount(payload.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined
-    };
-    super(message, params);
-    this.requiredDeviceCapabilities = ['Capability_Cardano'];
-    this.requiredFirmwareCoins = [getMiscNetwork('ada')];
-  }
-  get requiredPermissions() {
-    return this.coinPerms('sign', this.requiredFirmwareCoins);
-  }
-  get info() {
-    return 'Sign Cardano transaction';
-  }
-  _isFeatureSupported(feature) {
-    return this.getDevice().atLeast(CardanoSignTransactionFeatures[feature]);
-  }
-  _ensureFeatureIsSupported(feature) {
-    if (!this._isFeatureSupported(feature)) {
-      throw ERRORS.TypedError('Method_InvalidParameter', `Feature ${feature} not supported by device firmware`);
-    }
-  }
-  _ensureFirmwareSupportsParams() {
-    const {
-      params
-    } = this;
-    params.certificatesWithPoolOwnersAndRelays.forEach(({
-      certificate
-    }) => {
-      if (certificate.type === PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.VOTE_DELEGATION) {
-        this._ensureFeatureIsSupported('Conway');
-      }
-    });
-    if (params.tagCborSets) {
-      this._ensureFeatureIsSupported('Conway');
-    }
-  }
-  async _sign_tx() {
-    const {
-      typedCall
-    } = this.getDevice().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,
-      chunkify: this.params.chunkify,
-      tag_cbor_sets: this.params.tagCborSets,
-      payment_req: this.params.payment_req
-    };
-    await typedCall('CardanoSignTxInit', 'CardanoTxItemAck', signTxInitMessage);
-    for (const {
-      input
-    } of this.params.inputsWithPath) {
-      await typedCall('CardanoTxInput', 'CardanoTxItemAck', input);
-    }
-    for (const outputWithData of this.params.outputsWithData) {
-      await sendOutput(typedCall, outputWithData);
-    }
-    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);
-      }
-    }
-    for (const withdrawal of this.params.withdrawals) {
-      await typedCall('CardanoTxWithdrawal', 'CardanoTxItemAck', withdrawal);
-    }
-    let auxiliaryDataSupplement;
-    if (this.params.auxiliaryData) {
-      const {
-        cvote_registration_parameters
-      } = this.params.auxiliaryData;
-      if (cvote_registration_parameters) {
-        this.params.auxiliaryData = modifyAuxiliaryDataForBackwardsCompatibility(this.params.auxiliaryData);
-      }
-      const {
-        message
-      } = await typedCall('CardanoTxAuxiliaryData', 'CardanoTxAuxiliaryDataSupplement', this.params.auxiliaryData);
-      const auxiliaryDataType = PROTO.CardanoTxAuxiliaryDataSupplementType[message.type];
-      if (auxiliaryDataType !== PROTO.CardanoTxAuxiliaryDataSupplementType.NONE) {
-        auxiliaryDataSupplement = {
-          type: auxiliaryDataType,
-          auxiliaryDataHash: message.auxiliary_data_hash,
-          cVoteRegistrationSignature: message.cvote_registration_signature,
-          catalystSignature: message.cvote_registration_signature,
-          governanceSignature: message.cvote_registration_signature
-        };
-      }
-      await typedCall('CardanoTxHostAck', 'CardanoTxItemAck');
-    }
-    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);
-        }
-      }
-    }
-    for (const {
-      collateralInput
-    } of this.params.collateralInputsWithPath) {
-      await typedCall('CardanoTxCollateralInput', 'CardanoTxItemAck', collateralInput);
-    }
-    for (const requiredSigner of this.params.requiredSigners) {
-      await typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
-    }
-    if (this.params.collateralReturnWithData) {
-      await sendOutput(typedCall, this.params.collateralReturnWithData);
-    }
-    for (const referenceInput of this.params.referenceInputs) {
-      await typedCall('CardanoTxReferenceInput', 'CardanoTxItemAck', referenceInput);
-    }
-    const witnesses = [];
-    for (const path of this.params.witnessPaths) {
-      const {
-        message
-      } = await typedCall('CardanoTxWitnessRequest', 'CardanoTxWitnessResponse', {
-        path
-      });
-      witnesses.push({
-        type: PROTO.CardanoTxWitnessType[message.type],
-        pubKey: message.pub_key,
-        signature: message.signature,
-        chainCode: message.chain_code
-      });
-    }
-    const {
-      message: txBodyHashMessage
-    } = await typedCall('CardanoTxHostAck', 'CardanoTxBodyHash');
-    await typedCall('CardanoTxHostAck', 'CardanoSignTxFinished');
-    return {
-      hash: txBodyHashMessage.tx_hash,
-      witnesses,
-      auxiliaryDataSupplement
-    };
-  }
-  async run() {
-    this._ensureFirmwareSupportsParams();
-    const result = await this._sign_tx();
-    if (!this.params.unsignedTx) return result;
-    const {
-      unsignedTx,
-      testnet
-    } = this.params;
-    const {
-      hash,
-      witnesses
-    } = result;
-    if (hash !== unsignedTx.hash) {
-      throw ERRORS.TypedError('Runtime', "Constructed transaction doesn't match the hash returned by the device.");
-    }
-    const {
-      trezorUtils
-    } = await cardano();
-    const serializedTx = trezorUtils.signTransaction(unsignedTx.body, witnesses, {
-      testnet
-    });
-    return {
-      ...result,
-      serializedTx
-    };
-  }
-}

package/lib/api/cardano/api/index.d.ts

@@ -1,6 +0,0 @@
-export { default as cardanoGetAddress } from "./cardanoGetAddress.js";
-export { default as cardanoGetNativeScriptHash } from "./cardanoGetNativeScriptHash.js";
-export { default as cardanoGetPublicKey } from "./cardanoGetPublicKey.js";
-export { default as cardanoSignTransaction } from "./cardanoSignTransaction.js";
-export { default as cardanoComposeTransaction } from "./cardanoComposeTransaction.js";
-export { default as cardanoSignMessage } from "./cardanoSignMessage.js";

package/lib/api/cardano/api/index.js

@@ -1,6 +0,0 @@
-export { default as cardanoGetAddress } from "./cardanoGetAddress.js";
-export { default as cardanoGetNativeScriptHash } from "./cardanoGetNativeScriptHash.js";
-export { default as cardanoGetPublicKey } from "./cardanoGetPublicKey.js";
-export { default as cardanoSignTransaction } from "./cardanoSignTransaction.js";
-export { default as cardanoComposeTransaction } from "./cardanoComposeTransaction.js";
-export { default as cardanoSignMessage } from "./cardanoSignMessage.js";

package/lib/api/cardano/cardanoAddressParameters.d.ts

@@ -1,6 +0,0 @@
-import { CardanoAddressParameters } from '@trezor/connect-common';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-export declare const validateAddressParameters: (addressParameters: CardanoAddressParameters) => void;
-export declare const modifyAddressParametersForBackwardsCompatibility: (address_parameters: PROTO.CardanoAddressParametersType) => PROTO.CardanoAddressParametersType;
-export declare const addressParametersToProto: (addressParameters: CardanoAddressParameters) => PROTO.CardanoAddressParametersType;
-export declare const addressParametersFromProto: (addressParameters: PROTO.CardanoAddressParametersType) => CardanoAddressParameters;

package/lib/api/cardano/cardanoAddressParameters.js

@@ -1,79 +0,0 @@
-import { CardanoAddressParameters } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { validatePath } from "../../utils/pathUtils.js";
-export const validateAddressParameters = addressParameters => {
-  Assert(CardanoAddressParameters, addressParameters);
-  if (addressParameters.path) {
-    validatePath(addressParameters.path);
-  }
-  if (addressParameters.stakingPath) {
-    validatePath(addressParameters.stakingPath);
-  }
-};
-export const modifyAddressParametersForBackwardsCompatibility = address_parameters => {
-  if (address_parameters.address_type === PROTO.CardanoAddressType.REWARD) {
-    let {
-      address_n,
-      address_n_staking
-    } = address_parameters;
-    if (address_n.length > 0 && address_n_staking.length > 0) {
-      throw ERRORS.TypedError('Method_InvalidParameter', `Only stakingPath is allowed for CardanoAddressType.REWARD`);
-    }
-    if (address_n.length > 0) {
-      address_n_staking = address_n;
-      address_n = [];
-    }
-    return {
-      ...address_parameters,
-      address_n,
-      address_n_staking
-    };
-  }
-  return address_parameters;
-};
-export const addressParametersToProto = addressParameters => {
-  let path = [];
-  if (addressParameters.path) {
-    path = validatePath(addressParameters.path, 3);
-  }
-  let stakingPath = [];
-  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 => {
-  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
-  };
-};

package/lib/api/cardano/cardanoAuxiliaryData.d.ts

@@ -1,4 +0,0 @@
-import { CardanoAuxiliaryData } from '@trezor/connect-common';
-import type { PROTO } from '@trezor/connect-common';
-export declare const transformAuxiliaryData: (auxiliaryData: CardanoAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;
-export declare const modifyAuxiliaryDataForBackwardsCompatibility: (auxiliary_data: PROTO.CardanoTxAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;

package/lib/api/cardano/cardanoAuxiliaryData.js

@@ -1,74 +0,0 @@
-import { CardanoAuxiliaryData, CardanoCVoteRegistrationDelegation, CardanoCVoteRegistrationParameters } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { Assert } from "@trezor/schema-utils";
-import { addressParametersToProto, modifyAddressParametersForBackwardsCompatibility, validateAddressParameters } from "./cardanoAddressParameters.js";
-import { validatePath } from "../../utils/pathUtils.js";
-const MAX_DELEGATION_COUNT = 32;
-const transformDelegation = delegation => {
-  if (delegation.votingPublicKey) {
-    console.warn('Please use votePublicKey instead of votingPublicKey.');
-    delegation.votePublicKey = delegation.votingPublicKey;
-  }
-  Assert(CardanoCVoteRegistrationDelegation, delegation);
-  return {
-    vote_public_key: delegation.votePublicKey,
-    weight: delegation.weight
-  };
-};
-const transformCvoteRegistrationParameters = cVoteRegistrationParameters => {
-  if (cVoteRegistrationParameters.votingPublicKey) {
-    console.warn('Please use votePublicKey instead of votingPublicKey.');
-    cVoteRegistrationParameters.votePublicKey = cVoteRegistrationParameters.votingPublicKey;
-  }
-  if (cVoteRegistrationParameters.rewardAddressParameters) {
-    console.warn('Please use paymentAddressParameters instead of rewardAddressParameters.');
-    cVoteRegistrationParameters.paymentAddressParameters = cVoteRegistrationParameters.rewardAddressParameters;
-  }
-  Assert(CardanoCVoteRegistrationParameters, cVoteRegistrationParameters);
-  const {
-    paymentAddressParameters
-  } = cVoteRegistrationParameters;
-  if (paymentAddressParameters) {
-    validateAddressParameters(paymentAddressParameters);
-  }
-  const {
-    delegations
-  } = cVoteRegistrationParameters;
-  if (delegations && delegations.length > MAX_DELEGATION_COUNT) {
-    throw ERRORS.TypedError('Method_InvalidParameter', `At most ${MAX_DELEGATION_COUNT} delegations are allowed in a CIP-36 registration`);
-  }
-  return {
-    vote_public_key: cVoteRegistrationParameters.votePublicKey,
-    staking_path: validatePath(cVoteRegistrationParameters.stakingPath, 3),
-    payment_address_parameters: paymentAddressParameters ? addressParametersToProto(paymentAddressParameters) : undefined,
-    nonce: cVoteRegistrationParameters.nonce,
-    format: cVoteRegistrationParameters.format,
-    delegations: delegations?.map(transformDelegation),
-    voting_purpose: cVoteRegistrationParameters.votingPurpose,
-    payment_address: cVoteRegistrationParameters.paymentAddress
-  };
-};
-export const transformAuxiliaryData = auxiliaryData => {
-  Assert(CardanoAuxiliaryData, auxiliaryData);
-  let cVoteRegistrationParameters;
-  if (auxiliaryData.cVoteRegistrationParameters) {
-    cVoteRegistrationParameters = transformCvoteRegistrationParameters(auxiliaryData.cVoteRegistrationParameters);
-  }
-  return {
-    hash: auxiliaryData.hash,
-    cvote_registration_parameters: cVoteRegistrationParameters
-  };
-};
-export const modifyAuxiliaryDataForBackwardsCompatibility = auxiliary_data => {
-  const {
-    cvote_registration_parameters
-  } = auxiliary_data;
-  if (cvote_registration_parameters?.payment_address_parameters) {
-    cvote_registration_parameters.payment_address_parameters = modifyAddressParametersForBackwardsCompatibility(cvote_registration_parameters.payment_address_parameters);
-    return {
-      ...auxiliary_data,
-      cvote_registration_parameters
-    };
-  }
-  return auxiliary_data;
-};

package/lib/api/cardano/cardanoCertificate.d.ts

@@ -1,13 +0,0 @@
-import { CardanoCertificate } from '@trezor/connect-common';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-export type CertificateWithPoolOwnersAndRelays = {
-  certificate: PROTO.CardanoTxCertificate;
-  poolOwners: PROTO.CardanoPoolOwner[];
-  poolRelays: PROTO.CardanoPoolRelayParameters[];
-};
-export type PoolParametersWithOwnersAndRelays = {
-  poolParameters?: PROTO.CardanoPoolParametersType;
-  poolOwners: PROTO.CardanoPoolOwner[];
-  poolRelays: PROTO.CardanoPoolRelayParameters[];
-};
-export declare const transformCertificate: (certificate: CardanoCertificate) => CertificateWithPoolOwnersAndRelays;

package/lib/api/cardano/cardanoCertificate.js

@@ -1,142 +0,0 @@
-import { CardanoCertificate, CardanoDRep, CardanoPoolParameters, CardanoPoolRelay } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { validatePath } from "../../utils/pathUtils.js";
-const ipv4AddressToHex = ipv4Address => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
-const ipv6AddressToHex = ipv6Address => ipv6Address.split(':').join('');
-const validatePoolRelay = relay => {
-  Assert(CardanoPoolRelay, relay);
-  if (relay.type === PROTO.CardanoPoolRelayType.SINGLE_HOST_IP) {
-    if (!relay.ipv4Address && !relay.ipv6Address) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'Either ipv4Address or ipv6Address must be supplied');
-    }
-  } else if (relay.type === PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
-    if (!relay.hostName) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
-    }
-    if (!relay.port) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'port must be supplied');
-    }
-  } else if (relay.type === PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
-    if (!relay.hostName) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
-    }
-  }
-};
-const validatePoolOwners = owners => {
-  owners.forEach(owner => {
-    if (owner.stakingKeyPath) {
-      validatePath(owner.stakingKeyPath, 5);
-    }
-    if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'Either stakingKeyHash or stakingKeyPath must be supplied');
-    }
-  });
-  const ownersAsPathCount = owners.filter(owner => !!owner.stakingKeyPath).length;
-  if (ownersAsPathCount !== 1) {
-    throw ERRORS.TypedError('Method_InvalidParameter', 'Exactly one pool owner must be given as a path');
-  }
-};
-const validatePoolParameters = poolParameters => {
-  Assert(CardanoPoolParameters, poolParameters);
-  validatePoolOwners(poolParameters.owners);
-  poolParameters.relays.forEach(validatePoolRelay);
-};
-const validateDRep = dRep => {
-  Assert(CardanoDRep, dRep);
-  if (dRep.type === PROTO.CardanoDRepType.KEY_HASH && !dRep.keyHash) {
-    throw ERRORS.TypedError('Method_InvalidParameter', 'keyHash must be supplied for KEY_HASH dRep type');
-  } else if (dRep.type === PROTO.CardanoDRepType.SCRIPT_HASH && !dRep.scriptHash) {
-    throw ERRORS.TypedError('Method_InvalidParameter', 'scriptHash must be supplied for SCRIPT_HASH dRep type');
-  }
-};
-const transformPoolParameters = poolParameters => {
-  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 => {
-  if (!dRep) {
-    return undefined;
-  }
-  validateDRep(dRep);
-  return {
-    type: dRep.type,
-    key_hash: dRep.keyHash,
-    script_hash: dRep.scriptHash
-  };
-};
-export const transformCertificate = certificate => {
-  Assert(CardanoCertificate, certificate);
-  if (certificate.type === PROTO.CardanoCertificateType.STAKE_DELEGATION) {
-    if (!certificate.pool) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'pool must be supplied for STAKE_DELEGATION');
-    }
-  }
-  if (certificate.type === PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
-    if (!certificate.poolParameters) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'poolParameters must be supplied for STAKE_POOL_REGISTRATION');
-    }
-  }
-  if (certificate.type === PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY) {
-    if (!certificate.deposit) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'deposit must be supplied for STAKE_REGISTRATION_CONWAY or STAKE_DEREGISTRATION_CONWAY');
-    }
-  }
-  if (certificate.type === PROTO.CardanoCertificateType.VOTE_DELEGATION) {
-    if (!certificate.dRep) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'dRep must be supplied for VOTE_DELEGATION');
-    }
-  }
-  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/lib/api/cardano/cardanoInputs.d.ts

@@ -1,25 +0,0 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { Static } from '@trezor/schema-utils';
-export type Path = number[];
-export declare const Path: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
-export type CollateralInputWithPath = {
-  collateralInput: PROTO.CardanoTxCollateralInput;
-  path?: Path;
-};
-export type InputWithPath = Static<typeof InputWithPath>;
-export declare const InputWithPath: import("@sinclair/typebox").TObject<{
-  input: import("@sinclair/typebox").TObject<{
-    prev_hash: import("@sinclair/typebox").TString;
-    prev_index: import("@sinclair/typebox").TNumber;
-  }>;
-  path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>>;
-}>;
-export type InputWithPathParam = Static<typeof InputWithPath>;
-export declare const InputWithPathParam: import("@sinclair/typebox").TObject<{
-  prev_hash: import("@sinclair/typebox").TString;
-  prev_index: import("@sinclair/typebox").TNumber;
-  path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>>;
-}>;
-export declare const transformInput: (input: unknown) => InputWithPath;
-export declare const transformCollateralInput: (collateralInput: unknown) => CollateralInputWithPath;
-export declare const transformReferenceInput: (referenceInput: unknown) => PROTO.CardanoTxReferenceInput;