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

package/libESM/api/cardano/cardanoAddressParameters.d.mts

@@ -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/libESM/api/cardano/cardanoAddressParameters.mjs

@@ -1,79 +0,0 @@
-import { CardanoAddressParameters } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { validatePath } from "../../utils/pathUtils.mjs";
-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/libESM/api/cardano/cardanoAuxiliaryData.d.mts

@@ -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/libESM/api/cardano/cardanoAuxiliaryData.mjs

@@ -1,74 +0,0 @@
-import { CardanoAuxiliaryData, CardanoCVoteRegistrationDelegation, CardanoCVoteRegistrationParameters } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { addressParametersToProto, modifyAddressParametersForBackwardsCompatibility, validateAddressParameters } from "./cardanoAddressParameters.mjs";
-import { validatePath } from "../../utils/pathUtils.mjs";
-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/libESM/api/cardano/cardanoCertificate.d.mts

@@ -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/libESM/api/cardano/cardanoCertificate.mjs

@@ -1,142 +0,0 @@
-import { CardanoCertificate, CardanoDRep, CardanoPoolParameters, CardanoPoolRelay } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { validatePath } from "../../utils/pathUtils.mjs";
-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/libESM/api/cardano/cardanoInputs.d.mts

@@ -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;

package/libESM/api/cardano/cardanoInputs.mjs

@@ -1,39 +0,0 @@
-import { DerivationPath } from "@trezor/connect-common";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert, Type } from "@trezor/schema-utils";
-import { validatePath } from "../../utils/pathUtils.mjs";
-export const Path = Type.Array(Type.Number());
-export const InputWithPath = Type.Object({
-  input: PROTO.CardanoTxInput,
-  path: Type.Optional(Path)
-});
-export const InputWithPathParam = Type.Composite([PROTO.CardanoTxInput, Type.Object({
-  path: Type.Optional(DerivationPath)
-})]);
-export const transformInput = input => {
-  Assert(InputWithPathParam, input);
-  return {
-    input: {
-      prev_hash: input.prev_hash,
-      prev_index: input.prev_index
-    },
-    path: input.path ? validatePath(input.path, 5) : undefined
-  };
-};
-export const transformCollateralInput = collateralInput => {
-  Assert(InputWithPathParam, collateralInput);
-  return {
-    collateralInput: {
-      prev_hash: collateralInput.prev_hash,
-      prev_index: collateralInput.prev_index
-    },
-    path: collateralInput.path ? validatePath(collateralInput.path, 5) : undefined
-  };
-};
-export const transformReferenceInput = referenceInput => {
-  Assert(PROTO.CardanoTxInput, referenceInput);
-  return {
-    prev_hash: referenceInput.prev_hash,
-    prev_index: referenceInput.prev_index
-  };
-};

package/libESM/api/cardano/cardanoOutputs.d.mts

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

package/libESM/api/cardano/cardanoOutputs.mjs

@@ -1,70 +0,0 @@
-import { CardanoAddressParameters, CardanoAssetGroup } from "@trezor/connect-common";
-import { Assert, Type } from "@trezor/schema-utils";
-import { addressParametersToProto, validateAddressParameters } from "./cardanoAddressParameters.mjs";
-import { tokenBundleToProto } from "./cardanoTokenBundle.mjs";
-import { hexStringByteLength, sendChunkedHexString } from "./cardanoUtils.mjs";
-export const OutputValidation = Type.Object({
-  address: Type.Optional(Type.String()),
-  amount: Type.Uint(),
-  tokenBundle: Type.Optional(Type.Array(CardanoAssetGroup)),
-  datumHash: Type.Optional(Type.String()),
-  format: Type.Optional(Type.Number()),
-  inlineDatum: Type.Optional(Type.String()),
-  referenceScript: Type.Optional(Type.String()),
-  addressParameters: Type.Optional(CardanoAddressParameters)
-});
-export const transformOutput = output => {
-  Assert(OutputValidation, output);
-  const result = {
-    output: {
-      amount: output.amount,
-      asset_groups_count: 0,
-      datum_hash: output.datumHash,
-      format: output.format,
-      inline_datum_size: output.inlineDatum ? hexStringByteLength(output.inlineDatum) : undefined,
-      reference_script_size: output.referenceScript ? hexStringByteLength(output.referenceScript) : undefined
-    },
-    inlineDatum: output.inlineDatum,
-    referenceScript: output.referenceScript
-  };
-  if (output.addressParameters) {
-    validateAddressParameters(output.addressParameters);
-    result.output.address_parameters = addressParametersToProto(output.addressParameters);
-  } else {
-    result.output.address = output.address;
-  }
-  if (output.tokenBundle) {
-    result.tokenBundle = tokenBundleToProto(output.tokenBundle);
-    result.output.asset_groups_count = result.tokenBundle.length;
-  } else {
-    result.output.asset_groups_count = 0;
-  }
-  return result;
-};
-export const sendOutput = async (typedCall, 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 sendChunkedHexString(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
-  }
-  if (referenceScript) {
-    await sendChunkedHexString(typedCall, referenceScript, MAX_CHUNK_SIZE, 'CardanoTxReferenceScriptChunk');
-  }
-};

package/libESM/api/cardano/cardanoTokenBundle.d.mts

@@ -1,12 +0,0 @@
-import { CardanoAssetGroup } from '@trezor/connect-common';
-import type { Static } from '@trezor/schema-utils';
-export type AssetGroupWithTokens = Static<typeof AssetGroupWithTokens>;
-export declare const AssetGroupWithTokens: import("@sinclair/typebox").TObject<{
-    policyId: import("@sinclair/typebox").TString;
-    tokens: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
-        asset_name_bytes: import("@sinclair/typebox").TString;
-        amount: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/libESM/custom-types/uint").TUint>;
-        mint_amount: import("@sinclair/typebox").TOptional<import("@trezor/schema-utils/libESM/custom-types/uint").TUint>;
-    }>>;
-}>;
-export declare const tokenBundleToProto: (tokenBundle: CardanoAssetGroup[]) => AssetGroupWithTokens[];

package/libESM/api/cardano/cardanoTokenBundle.mjs

@@ -1,21 +0,0 @@
-import { CardanoAssetGroup } from "@trezor/connect-common";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert, Type } from "@trezor/schema-utils";
-export const AssetGroupWithTokens = Type.Object({
-  policyId: Type.String(),
-  tokens: Type.Array(PROTO.CardanoToken, {
-    minItems: 1
-  })
-});
-const tokenAmountsToProto = tokenAmounts => tokenAmounts.map(tokenAmount => ({
-  asset_name_bytes: tokenAmount.assetNameBytes,
-  amount: tokenAmount.amount,
-  mint_amount: tokenAmount.mintAmount
-}));
-export const tokenBundleToProto = tokenBundle => {
-  Assert(Type.Array(CardanoAssetGroup), tokenBundle);
-  return tokenBundle.map(tokenGroup => ({
-    policyId: tokenGroup.policyId,
-    tokens: tokenAmountsToProto(tokenGroup.tokenAmounts)
-  }));
-};

package/libESM/api/cardano/cardanoUtils.d.mts

@@ -1,9 +0,0 @@
-import type { types } from '@fivebinaries/coin-selection';
-import type { AccountUtxo, CardanoCertificate } from '@trezor/connect-common';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-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: PROTO.TypedCall, data: string, chunkSize: number, messageType: PROTO.MessageKey, responseType?: PROTO.MessageKey) => Promise<void>;

package/libESM/api/cardano/cardanoUtils.mjs

@@ -1,101 +0,0 @@
-import { coinSelection } from "@fivebinaries/coin-selection";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-const CARDANO_DEFAULT_TTL_OFFSET = 7200;
-export 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;
-};
-export const prepareCertificates = certs => {
-  const convertedCerts = [];
-  certs.forEach(cert => {
-    switch (cert.type) {
-      case PROTO.CardanoCertificateType.STAKE_DELEGATION:
-        convertedCerts.push({
-          type: cert.type,
-          pool: cert.pool
-        });
-        break;
-      case PROTO.CardanoCertificateType.STAKE_REGISTRATION:
-      case PROTO.CardanoCertificateType.STAKE_DEREGISTRATION:
-        convertedCerts.push({
-          type: cert.type
-        });
-        break;
-      case PROTO.CardanoCertificateType.VOTE_DELEGATION:
-        if (cert.dRep?.type === PROTO.CardanoDRepType.ABSTAIN || cert.dRep?.type === PROTO.CardanoDRepType.NO_CONFIDENCE) {
-          convertedCerts.push({
-            type: cert.type,
-            dRep: {
-              type: cert.dRep.type
-            }
-          });
-        } else if (cert.dRep?.type === PROTO.CardanoDRepType.KEY_HASH) {
-          convertedCerts.push({
-            type: cert.type,
-            dRep: {
-              type: cert.dRep.type,
-              keyHash: cert.dRep.keyHash
-            }
-          });
-        } else if (cert.dRep?.type === PROTO.CardanoDRepType.SCRIPT_HASH) {
-          convertedCerts.push({
-            type: cert.type,
-            dRep: {
-              type: cert.dRep.type,
-              scriptHash: cert.dRep.scriptHash
-            }
-          });
-        }
-        break;
-    }
-  });
-  return convertedCerts;
-};
-export 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;
-};
-export const composeTxPlan = (descriptor, utxo, outputs, certificates, withdrawals, changeAddress, isTestnet, options) => coinSelection({
-  utxos: transformUtxos(utxo),
-  outputs,
-  changeAddress,
-  certificates: prepareCertificates(certificates),
-  withdrawals,
-  accountPubKey: descriptor,
-  ttl: getTtl(isTestnet)
-}, options);
-export const hexStringByteLength = s => s.length / 2;
-export 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;
-  }
-};

package/libESM/api/cardano/cardanoWitnesses.d.mts

@@ -1,4 +0,0 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { CertificateWithPoolOwnersAndRelays } from './cardanoCertificate';
-import type { CollateralInputWithPath, InputWithPath, Path } from './cardanoInputs';
-export declare const gatherWitnessPaths: (inputsWithPath: InputWithPath[], certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[], withdrawals: PROTO.CardanoTxWithdrawal[], collateralInputsWithPath: CollateralInputWithPath[], requiredSigners: PROTO.CardanoTxRequiredSigner[], additionalWitnessRequests: Path[], signingMode: PROTO.CardanoTxSigningMode) => Path[];