@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/lib/api/cardano/cardanoCertificate.js

@@ -1,149 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformCertificate = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../constants");
-const cardano_1 = require("../../types/api/cardano");
-const pathUtils_1 = require("../../utils/pathUtils");
-const ipv4AddressToHex = ipv4Address => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
-const ipv6AddressToHex = ipv6Address => ipv6Address.split(':').join('');
-const validatePoolRelay = relay => {
-  (0, schema_utils_1.Assert)(cardano_1.CardanoPoolRelay, relay);
-  if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_IP) {
-    if (!relay.ipv4Address && !relay.ipv6Address) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either ipv4Address or ipv6Address must be supplied');
-    }
-  } else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
-    if (!relay.hostName) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
-    }
-    if (!relay.port) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'port must be supplied');
-    }
-  } else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
-    if (!relay.hostName) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
-    }
-  }
-};
-const validatePoolOwners = owners => {
-  owners.forEach(owner => {
-    if (owner.stakingKeyPath) {
-      (0, pathUtils_1.validatePath)(owner.stakingKeyPath, 5);
-    }
-    if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either stakingKeyHash or stakingKeyPath must be supplied');
-    }
-  });
-  const ownersAsPathCount = owners.filter(owner => !!owner.stakingKeyPath).length;
-  if (ownersAsPathCount !== 1) {
-    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Exactly one pool owner must be given as a path');
-  }
-};
-const validatePoolParameters = poolParameters => {
-  (0, schema_utils_1.Assert)(cardano_1.CardanoPoolParameters, poolParameters);
-  validatePoolOwners(poolParameters.owners);
-  poolParameters.relays.forEach(validatePoolRelay);
-};
-const validateDRep = dRep => {
-  (0, schema_utils_1.Assert)(cardano_1.CardanoDRep, dRep);
-  if (dRep.type === constants_1.PROTO.CardanoDRepType.KEY_HASH && !dRep.keyHash) {
-    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'keyHash must be supplied for KEY_HASH dRep type');
-  } else if (dRep.type === constants_1.PROTO.CardanoDRepType.SCRIPT_HASH && !dRep.scriptHash) {
-    throw constants_1.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 ? (0, pathUtils_1.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
-  };
-};
-const transformCertificate = certificate => {
-  (0, schema_utils_1.Assert)(cardano_1.CardanoCertificate, certificate);
-  if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION) {
-    if (!certificate.pool) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'pool must be supplied for STAKE_DELEGATION');
-    }
-  }
-  if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
-    if (!certificate.poolParameters) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'poolParameters must be supplied for STAKE_POOL_REGISTRATION');
-    }
-  }
-  if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY) {
-    if (!certificate.deposit) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'deposit must be supplied for STAKE_REGISTRATION_CONWAY or STAKE_DEREGISTRATION_CONWAY');
-    }
-  }
-  if (certificate.type === constants_1.PROTO.CardanoCertificateType.VOTE_DELEGATION) {
-    if (!certificate.dRep) {
-      throw constants_1.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 ? (0, pathUtils_1.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
-  };
-};
-exports.transformCertificate = transformCertificate;
-//# sourceMappingURL=cardanoCertificate.js.map

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

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

package/lib/api/cardano/cardanoInputs.js

@@ -1,49 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.transformReferenceInput = exports.transformCollateralInput = exports.transformInput = exports.InputWithPathParam = exports.InputWithPath = exports.Path = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../constants");
-const types_1 = require("../../types");
-const pathUtils_1 = require("../../utils/pathUtils");
-exports.Path = schema_utils_1.Type.Array(schema_utils_1.Type.Number());
-exports.InputWithPath = schema_utils_1.Type.Object({
-  input: constants_1.PROTO.CardanoTxInput,
-  path: schema_utils_1.Type.Optional(exports.Path)
-});
-exports.InputWithPathParam = schema_utils_1.Type.Composite([constants_1.PROTO.CardanoTxInput, schema_utils_1.Type.Object({
-  path: schema_utils_1.Type.Optional(types_1.DerivationPath)
-})]);
-const transformInput = input => {
-  (0, schema_utils_1.Assert)(exports.InputWithPathParam, input);
-  return {
-    input: {
-      prev_hash: input.prev_hash,
-      prev_index: input.prev_index
-    },
-    path: input.path ? (0, pathUtils_1.validatePath)(input.path, 5) : undefined
-  };
-};
-exports.transformInput = transformInput;
-const transformCollateralInput = collateralInput => {
-  (0, schema_utils_1.Assert)(exports.InputWithPathParam, collateralInput);
-  return {
-    collateralInput: {
-      prev_hash: collateralInput.prev_hash,
-      prev_index: collateralInput.prev_index
-    },
-    path: collateralInput.path ? (0, pathUtils_1.validatePath)(collateralInput.path, 5) : undefined
-  };
-};
-exports.transformCollateralInput = transformCollateralInput;
-const transformReferenceInput = referenceInput => {
-  (0, schema_utils_1.Assert)(constants_1.PROTO.CardanoTxInput, referenceInput);
-  return {
-    prev_hash: referenceInput.prev_hash,
-    prev_index: referenceInput.prev_index
-  };
-};
-exports.transformReferenceInput = transformReferenceInput;
-//# sourceMappingURL=cardanoInputs.js.map

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

@@ -1,40 +0,0 @@
-import { AssetGroupWithTokens } from './cardanoTokenBundle';
-import { PROTO } from '../../constants';
-export type OutputWithData = {
-    output: PROTO.CardanoTxOutput;
-    tokenBundle?: AssetGroupWithTokens[];
-    inlineDatum?: string;
-    referenceScript?: string;
-};
-export declare const OutputValidation: import("@trezor/schema-utils").TObject<{
-    address: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-    amount: import("@trezor/schema-utils/lib/custom-types/uint").TUint;
-    tokenBundle: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-        policyId: import("@trezor/schema-utils").TString;
-        tokenAmounts: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-            assetNameBytes: import("@trezor/schema-utils").TString;
-            amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-            mintAmount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        }>>;
-    }>>>;
-    datumHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-    format: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
-    inlineDatum: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-    referenceScript: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-    addressParameters: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
-        addressType: import("@trezor/schema-utils").TEnum<typeof PROTO.CardanoAddressType>;
-        path: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>>;
-        stakingPath: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>>;
-        stakingKeyHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        certificatePointer: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
-            blockIndex: import("@trezor/schema-utils").TNumber;
-            txIndex: import("@trezor/schema-utils").TNumber;
-            certificateIndex: import("@trezor/schema-utils").TNumber;
-        }>>;
-        paymentScriptHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        stakingScriptHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-    }>>;
-}>;
-export declare const transformOutput: (output: unknown) => OutputWithData;
-export declare const sendOutput: (typedCall: any, outputWithData: OutputWithData) => Promise<void>;
-//# sourceMappingURL=cardanoOutputs.d.ts.map

package/lib/api/cardano/cardanoOutputs.js

@@ -1,79 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sendOutput = exports.transformOutput = exports.OutputValidation = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
-const cardanoTokenBundle_1 = require("./cardanoTokenBundle");
-const cardanoUtils_1 = require("./cardanoUtils");
-const cardano_1 = require("../../types/api/cardano");
-exports.OutputValidation = schema_utils_1.Type.Object({
-  address: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  amount: schema_utils_1.Type.Uint(),
-  tokenBundle: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(cardano_1.CardanoAssetGroup)),
-  datumHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  format: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
-  inlineDatum: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  referenceScript: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  addressParameters: schema_utils_1.Type.Optional(cardano_1.CardanoAddressParameters)
-});
-const transformOutput = output => {
-  (0, schema_utils_1.Assert)(exports.OutputValidation, output);
-  const result = {
-    output: {
-      amount: output.amount,
-      asset_groups_count: 0,
-      datum_hash: output.datumHash,
-      format: output.format,
-      inline_datum_size: output.inlineDatum ? (0, cardanoUtils_1.hexStringByteLength)(output.inlineDatum) : undefined,
-      reference_script_size: output.referenceScript ? (0, cardanoUtils_1.hexStringByteLength)(output.referenceScript) : undefined
-    },
-    inlineDatum: output.inlineDatum,
-    referenceScript: output.referenceScript
-  };
-  if (output.addressParameters) {
-    (0, cardanoAddressParameters_1.validateAddressParameters)(output.addressParameters);
-    result.output.address_parameters = (0, cardanoAddressParameters_1.addressParametersToProto)(output.addressParameters);
-  } else {
-    result.output.address = output.address;
-  }
-  if (output.tokenBundle) {
-    result.tokenBundle = (0, cardanoTokenBundle_1.tokenBundleToProto)(output.tokenBundle);
-    result.output.asset_groups_count = result.tokenBundle.length;
-  } else {
-    result.output.asset_groups_count = 0;
-  }
-  return result;
-};
-exports.transformOutput = transformOutput;
-const sendOutput = async (typedCall, outputWithData) => {
-  const MAX_CHUNK_SIZE = 1024 * 2;
-  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 (0, cardanoUtils_1.sendChunkedHexString)(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
-  }
-  if (referenceScript) {
-    await (0, cardanoUtils_1.sendChunkedHexString)(typedCall, referenceScript, MAX_CHUNK_SIZE, 'CardanoTxReferenceScriptChunk');
-  }
-};
-exports.sendOutput = sendOutput;
-//# sourceMappingURL=cardanoOutputs.js.map

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

@@ -1,13 +0,0 @@
-import { Static } from '@trezor/schema-utils';
-import { CardanoAssetGroup } from '../../types/api/cardano';
-export type AssetGroupWithTokens = Static<typeof AssetGroupWithTokens>;
-export declare const AssetGroupWithTokens: import("@trezor/schema-utils").TObject<{
-    policyId: import("@trezor/schema-utils").TString;
-    tokens: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-        asset_name_bytes: import("@trezor/schema-utils").TString;
-        amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
-        mint_amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils/lib/custom-types/uint").TUint>;
-    }>>;
-}>;
-export declare const tokenBundleToProto: (tokenBundle: CardanoAssetGroup[]) => AssetGroupWithTokens[];
-//# sourceMappingURL=cardanoTokenBundle.d.ts.map

package/lib/api/cardano/cardanoTokenBundle.js

@@ -1,29 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.tokenBundleToProto = exports.AssetGroupWithTokens = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../constants");
-const cardano_1 = require("../../types/api/cardano");
-exports.AssetGroupWithTokens = schema_utils_1.Type.Object({
-  policyId: schema_utils_1.Type.String(),
-  tokens: schema_utils_1.Type.Array(constants_1.PROTO.CardanoToken, {
-    minItems: 1
-  })
-});
-const tokenAmountsToProto = tokenAmounts => tokenAmounts.map(tokenAmount => ({
-  asset_name_bytes: tokenAmount.assetNameBytes,
-  amount: tokenAmount.amount,
-  mint_amount: tokenAmount.mintAmount
-}));
-const tokenBundleToProto = tokenBundle => {
-  (0, schema_utils_1.Assert)(schema_utils_1.Type.Array(cardano_1.CardanoAssetGroup), tokenBundle);
-  return tokenBundle.map(tokenGroup => ({
-    policyId: tokenGroup.policyId,
-    tokens: tokenAmountsToProto(tokenGroup.tokenAmounts)
-  }));
-};
-exports.tokenBundleToProto = tokenBundleToProto;
-//# sourceMappingURL=cardanoTokenBundle.js.map

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

@@ -1,9 +0,0 @@
-import { types } from '@fivebinaries/coin-selection';
-import { AccountUtxo, CardanoCertificate } from '../../types';
-export declare const transformUtxos: (utxos: AccountUtxo[]) => types.Utxo[];
-export declare const prepareCertificates: (certs: CardanoCertificate[]) => types.Certificate[];
-export declare const getTtl: (testnet: boolean) => number;
-export declare const composeTxPlan: (descriptor: string, utxo: AccountUtxo[], outputs: types.UserOutput[], certificates: CardanoCertificate[], withdrawals: types.Withdrawal[], changeAddress: string, isTestnet: boolean, options?: types.Options) => types.PrecomposedTransaction;
-export declare const hexStringByteLength: (s: string) => number;
-export declare const sendChunkedHexString: (typedCall: any, data: string, chunkSize: number, messageType: string, responseType?: string) => Promise<void>;
-//# sourceMappingURL=cardanoUtils.d.ts.map

package/lib/api/cardano/cardanoUtils.js

@@ -1,114 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.sendChunkedHexString = exports.hexStringByteLength = exports.composeTxPlan = exports.getTtl = exports.prepareCertificates = exports.transformUtxos = void 0;
-const coin_selection_1 = require("@fivebinaries/coin-selection");
-const constants_1 = require("../../constants");
-const CARDANO_DEFAULT_TTL_OFFSET = 7200;
-const transformUtxos = utxos => {
-  const result = [];
-  utxos?.forEach(utxo => {
-    const foundItem = result.find(res => res.txHash === utxo.txid && res.outputIndex === utxo.vout);
-    if (utxo.cardanoSpecific) {
-      if (!foundItem) {
-        result.push({
-          address: utxo.address,
-          txHash: utxo.txid,
-          outputIndex: utxo.vout,
-          amount: [{
-            quantity: utxo.amount,
-            unit: utxo.cardanoSpecific.unit
-          }]
-        });
-      } else {
-        foundItem.amount.push({
-          quantity: utxo.amount,
-          unit: utxo.cardanoSpecific.unit
-        });
-      }
-    }
-  });
-  return result;
-};
-exports.transformUtxos = transformUtxos;
-const prepareCertificates = certs => {
-  const convertedCerts = [];
-  certs.forEach(cert => {
-    switch (cert.type) {
-      case constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION:
-        convertedCerts.push({
-          type: cert.type,
-          pool: cert.pool
-        });
-        break;
-      case constants_1.PROTO.CardanoCertificateType.STAKE_REGISTRATION:
-      case constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION:
-        convertedCerts.push({
-          type: cert.type
-        });
-        break;
-      case constants_1.PROTO.CardanoCertificateType.VOTE_DELEGATION:
-        if (cert.dRep?.type === constants_1.PROTO.CardanoDRepType.ABSTAIN || cert.dRep?.type === constants_1.PROTO.CardanoDRepType.NO_CONFIDENCE) {
-          convertedCerts.push({
-            type: cert.type,
-            dRep: {
-              type: cert.dRep.type
-            }
-          });
-        } else if (cert.dRep?.type === constants_1.PROTO.CardanoDRepType.KEY_HASH) {
-          convertedCerts.push({
-            type: cert.type,
-            dRep: {
-              type: cert.dRep.type,
-              keyHash: cert.dRep.keyHash
-            }
-          });
-        } else if (cert.dRep?.type === constants_1.PROTO.CardanoDRepType.SCRIPT_HASH) {
-          convertedCerts.push({
-            type: cert.type,
-            dRep: {
-              type: cert.dRep.type,
-              scriptHash: cert.dRep.scriptHash
-            }
-          });
-        }
-        break;
-    }
-  });
-  return convertedCerts;
-};
-exports.prepareCertificates = prepareCertificates;
-const getTtl = testnet => {
-  const shelleySlot = testnet ? 6192449 : 4924800;
-  const shelleyTimestamp = testnet ? 1672848449 : 1596491091;
-  const currentTimestamp = Math.floor(new Date().getTime() / 1000);
-  const currentSlot = shelleySlot + currentTimestamp - shelleyTimestamp;
-  return currentSlot + CARDANO_DEFAULT_TTL_OFFSET;
-};
-exports.getTtl = getTtl;
-const composeTxPlan = (descriptor, utxo, outputs, certificates, withdrawals, changeAddress, isTestnet, options) => (0, coin_selection_1.coinSelection)({
-  utxos: (0, exports.transformUtxos)(utxo),
-  outputs,
-  changeAddress,
-  certificates: (0, exports.prepareCertificates)(certificates),
-  withdrawals,
-  accountPubKey: descriptor,
-  ttl: (0, exports.getTtl)(isTestnet)
-}, options);
-exports.composeTxPlan = composeTxPlan;
-const hexStringByteLength = s => s.length / 2;
-exports.hexStringByteLength = hexStringByteLength;
-const sendChunkedHexString = async (typedCall, data, chunkSize, messageType, responseType = 'CardanoTxItemAck') => {
-  let processedSize = 0;
-  while (processedSize < data.length) {
-    const chunk = data.slice(processedSize, processedSize + chunkSize);
-    await typedCall(messageType, responseType, {
-      data: chunk
-    });
-    processedSize += chunkSize;
-  }
-};
-exports.sendChunkedHexString = sendChunkedHexString;
-//# sourceMappingURL=cardanoUtils.js.map

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

@@ -1,5 +0,0 @@
-import type { CertificateWithPoolOwnersAndRelays } from './cardanoCertificate';
-import type { CollateralInputWithPath, InputWithPath, Path } from './cardanoInputs';
-import { PROTO } from '../../constants';
-export declare const gatherWitnessPaths: (inputsWithPath: InputWithPath[], certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[], withdrawals: PROTO.CardanoTxWithdrawal[], collateralInputsWithPath: CollateralInputWithPath[], requiredSigners: PROTO.CardanoTxRequiredSigner[], additionalWitnessRequests: Path[], signingMode: PROTO.CardanoTxSigningMode) => Path[];
-//# sourceMappingURL=cardanoWitnesses.d.ts.map

package/lib/api/cardano/cardanoWitnesses.js

@@ -1,55 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.gatherWitnessPaths = void 0;
-const constants_1 = require("../../constants");
-const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, signingMode) => {
-  const witnessPaths = new Map();
-  function _insert(path) {
-    const pathKey = JSON.stringify(path);
-    witnessPaths.set(pathKey, path);
-  }
-  if (signingMode !== constants_1.PROTO.CardanoTxSigningMode.MULTISIG_TRANSACTION) {
-    inputsWithPath.forEach(({
-      path
-    }) => {
-      if (path) _insert(path);
-    });
-    certificatesWithPoolOwnersAndRelays.forEach(({
-      certificate,
-      poolOwners
-    }) => {
-      if (certificate.path && (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION || certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION || certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION_CONWAY || certificate.type === constants_1.PROTO.CardanoCertificateType.VOTE_DELEGATION)) {
-        _insert(certificate.path);
-      }
-      poolOwners.forEach(poolOwner => {
-        if (poolOwner.staking_key_path) _insert(poolOwner.staking_key_path);
-      });
-    });
-    withdrawals.forEach(({
-      path
-    }) => {
-      if (path) _insert(path);
-    });
-  }
-  if (signingMode === constants_1.PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
-    collateralInputsWithPath.forEach(({
-      path
-    }) => {
-      if (path) _insert(path);
-    });
-  }
-  requiredSigners.forEach(({
-    key_path
-  }) => {
-    if (key_path) _insert(key_path);
-  });
-  additionalWitnessRequests.forEach(path => {
-    _insert(path);
-  });
-  return Array.from(witnessPaths.values());
-};
-exports.gatherWitnessPaths = gatherWitnessPaths;
-//# sourceMappingURL=cardanoWitnesses.js.map

package/lib/api/changeLanguage.d.ts

@@ -1,17 +0,0 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { ChangeLanguage as ChangeLanguageSchema } from '../types/api/changeLanguage';
-export default class ChangeLanguage extends AbstractMethod<'changeLanguage', ChangeLanguageSchema> {
-    init(): void;
-    get confirmation(): {
-        view: "device-management";
-        customConfirmButton: {
-            className: string;
-            label: string;
-        };
-        label: string;
-    };
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=changeLanguage.d.ts.map

package/lib/api/changeLanguage.js

@@ -1,50 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const events_1 = require("../events");
-const changeLanguage_1 = require("../types/api/changeLanguage");
-class ChangeLanguage extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
-    this.useEmptyPassphrase = true;
-    this.requiredPermissions = ['management'];
-    this.skipFinalReload = false;
-    this.useDeviceState = false;
-    const {
-      payload
-    } = this;
-    (0, schema_utils_1.Assert)(changeLanguage_1.ChangeLanguage, payload);
-    this.params = payload;
-  }
-  get confirmation() {
-    return {
-      view: 'device-management',
-      customConfirmButton: {
-        className: 'confirm',
-        label: 'Proceed'
-      },
-      label: 'Do you want to change language?'
-    };
-  }
-  run() {
-    const {
-      language,
-      binary
-    } = this.params;
-    if (binary) {
-      return this.device.changeLanguage({
-        binary
-      });
-    } else {
-      return this.device.changeLanguage({
-        language
-      });
-    }
-  }
-}
-exports.default = ChangeLanguage;
-//# sourceMappingURL=changeLanguage.js.map

package/lib/api/changePin.d.ts

@@ -1,9 +0,0 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class ChangePin extends AbstractMethod<'changePin', PROTO.ChangePin> {
-    init(): void;
-    run(): Promise<{
-        message: string;
-    }>;
-}
-//# sourceMappingURL=changePin.d.ts.map