@trezor/connect 9.7.3 → 10.0.0-beta.1

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

@@ -1,241 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CardanoSignedMessage = exports.CardanoMessageHeaders = exports.CardanoMessageUnprotectedHeaders = exports.CardanoMessageProtectedHeaders = exports.CardanoSignMessage = exports.CardanoSignedTxData = exports.CardanoAuxiliaryDataSupplement = exports.CardanoSignedTxWitness = exports.CardanoSignTransactionExtended = exports.CardanoSignTransaction = exports.CardanoAuxiliaryData = exports.CardanoCVoteRegistrationParameters = exports.CardanoCVoteRegistrationDelegation = exports.CardanoReferenceInput = exports.CardanoRequiredSigner = exports.CardanoCollateralInput = exports.CardanoMint = exports.CardanoWithdrawal = exports.CardanoCertificate = exports.CardanoDRep = exports.CardanoPoolParameters = exports.CardanoPoolMargin = exports.CardanoPoolMetadata = exports.CardanoPoolRelay = exports.CardanoPoolOwner = exports.CardanoOutput = exports.CardanoAssetGroup = exports.CardanoToken = exports.CardanoInput = exports.CardanoGetPublicKey = exports.CardanoNativeScriptHash = exports.CardanoGetNativeScriptHash = exports.CardanoNativeScript = exports.CardanoGetAddress = exports.CardanoAddressParameters = exports.CardanoCertificatePointer = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../../constants");
-const params_1 = require("../../params");
-exports.CardanoCertificatePointer = schema_utils_1.Type.Object({
-  blockIndex: schema_utils_1.Type.Number(),
-  txIndex: schema_utils_1.Type.Number(),
-  certificateIndex: schema_utils_1.Type.Number()
-});
-exports.CardanoAddressParameters = schema_utils_1.Type.Object({
-  addressType: constants_1.PROTO.EnumCardanoAddressType,
-  path: schema_utils_1.Type.Optional(params_1.DerivationPath),
-  stakingPath: schema_utils_1.Type.Optional(params_1.DerivationPath),
-  stakingKeyHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  certificatePointer: schema_utils_1.Type.Optional(exports.CardanoCertificatePointer),
-  paymentScriptHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  stakingScriptHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoGetAddress = schema_utils_1.Type.Object({
-  addressParameters: exports.CardanoAddressParameters,
-  protocolMagic: schema_utils_1.Type.Number(),
-  networkId: schema_utils_1.Type.Number(),
-  address: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  showOnTrezor: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
-  derivationType: schema_utils_1.Type.Optional(constants_1.PROTO.EnumCardanoDerivationType),
-  chunkify: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean())
-});
-exports.CardanoNativeScript = schema_utils_1.Type.Recursive(This => schema_utils_1.Type.Object({
-  type: constants_1.PROTO.EnumCardanoNativeScriptType,
-  scripts: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(This)),
-  keyHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  keyPath: schema_utils_1.Type.Optional(params_1.DerivationPath),
-  requiredSignaturesCount: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
-  invalidBefore: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  invalidHereafter: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-}));
-exports.CardanoGetNativeScriptHash = schema_utils_1.Type.Object({
-  script: exports.CardanoNativeScript,
-  displayFormat: constants_1.PROTO.EnumCardanoNativeScriptHashDisplayFormat,
-  derivationType: schema_utils_1.Type.Optional(constants_1.PROTO.EnumCardanoDerivationType)
-});
-exports.CardanoNativeScriptHash = schema_utils_1.Type.Object({
-  scriptHash: schema_utils_1.Type.String()
-});
-exports.CardanoGetPublicKey = schema_utils_1.Type.Intersect([params_1.GetPublicKey, schema_utils_1.Type.Object({
-  derivationType: schema_utils_1.Type.Optional(constants_1.PROTO.EnumCardanoDerivationType)
-})]);
-exports.CardanoInput = schema_utils_1.Type.Object({
-  path: schema_utils_1.Type.Optional(params_1.DerivationPath),
-  prev_hash: schema_utils_1.Type.String(),
-  prev_index: schema_utils_1.Type.Number()
-});
-exports.CardanoToken = schema_utils_1.Type.Object({
-  assetNameBytes: schema_utils_1.Type.String(),
-  amount: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  mintAmount: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoAssetGroup = schema_utils_1.Type.Object({
-  policyId: schema_utils_1.Type.String(),
-  tokenAmounts: schema_utils_1.Type.Array(exports.CardanoToken)
-});
-exports.CardanoOutput = schema_utils_1.Type.Intersect([schema_utils_1.Type.Union([schema_utils_1.Type.Object({
-  addressParameters: exports.CardanoAddressParameters
-}), schema_utils_1.Type.Object({
-  address: schema_utils_1.Type.String()
-})]), schema_utils_1.Type.Object({
-  amount: schema_utils_1.Type.String(),
-  tokenBundle: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.CardanoAssetGroup)),
-  datumHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  format: schema_utils_1.Type.Optional(constants_1.PROTO.EnumCardanoTxOutputSerializationFormat),
-  inlineDatum: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  referenceScript: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-})]);
-exports.CardanoPoolOwner = schema_utils_1.Type.Object({
-  stakingKeyPath: schema_utils_1.Type.Optional(params_1.DerivationPath),
-  stakingKeyHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoPoolRelay = schema_utils_1.Type.Object({
-  type: constants_1.PROTO.EnumCardanoPoolRelayType,
-  ipv4Address: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  ipv6Address: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  port: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
-  hostName: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoPoolMetadata = schema_utils_1.Type.Object({
-  url: schema_utils_1.Type.String(),
-  hash: schema_utils_1.Type.String()
-});
-exports.CardanoPoolMargin = schema_utils_1.Type.Object({
-  numerator: schema_utils_1.Type.String(),
-  denominator: schema_utils_1.Type.String()
-});
-exports.CardanoPoolParameters = schema_utils_1.Type.Object({
-  poolId: schema_utils_1.Type.String(),
-  vrfKeyHash: schema_utils_1.Type.String(),
-  pledge: schema_utils_1.Type.String(),
-  cost: schema_utils_1.Type.String(),
-  margin: exports.CardanoPoolMargin,
-  rewardAccount: schema_utils_1.Type.String(),
-  owners: schema_utils_1.Type.Array(exports.CardanoPoolOwner, {
-    minItems: 1
-  }),
-  relays: schema_utils_1.Type.Array(exports.CardanoPoolRelay),
-  metadata: schema_utils_1.Type.Optional(exports.CardanoPoolMetadata)
-});
-exports.CardanoDRep = schema_utils_1.Type.Object({
-  type: constants_1.PROTO.EnumCardanoDRepType,
-  keyHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  scriptHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoCertificate = schema_utils_1.Type.Object({
-  type: constants_1.PROTO.EnumCardanoCertificateType,
-  path: schema_utils_1.Type.Optional(params_1.DerivationPath),
-  pool: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  poolParameters: schema_utils_1.Type.Optional(exports.CardanoPoolParameters),
-  scriptHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  keyHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  deposit: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  dRep: schema_utils_1.Type.Optional(exports.CardanoDRep)
-});
-exports.CardanoWithdrawal = schema_utils_1.Type.Object({
-  path: schema_utils_1.Type.Optional(params_1.DerivationPath),
-  amount: schema_utils_1.Type.String(),
-  scriptHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  keyHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoMint = schema_utils_1.Type.Array(exports.CardanoAssetGroup);
-exports.CardanoCollateralInput = schema_utils_1.Type.Object({
-  path: schema_utils_1.Type.Optional(params_1.DerivationPath),
-  prev_hash: schema_utils_1.Type.String(),
-  prev_index: schema_utils_1.Type.Number()
-});
-exports.CardanoRequiredSigner = schema_utils_1.Type.Object({
-  keyPath: schema_utils_1.Type.Optional(params_1.DerivationPath),
-  keyHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoReferenceInput = schema_utils_1.Type.Object({
-  prev_hash: schema_utils_1.Type.String(),
-  prev_index: schema_utils_1.Type.Number()
-});
-exports.CardanoCVoteRegistrationDelegation = schema_utils_1.Type.Object({
-  votePublicKey: schema_utils_1.Type.String(),
-  weight: schema_utils_1.Type.Number()
-});
-exports.CardanoCVoteRegistrationParameters = schema_utils_1.Type.Object({
-  votePublicKey: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  stakingPath: params_1.DerivationPath,
-  paymentAddressParameters: schema_utils_1.Type.Optional(exports.CardanoAddressParameters),
-  nonce: schema_utils_1.Type.String(),
-  format: schema_utils_1.Type.Optional(constants_1.PROTO.EnumCardanoCVoteRegistrationFormat),
-  delegations: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.CardanoCVoteRegistrationDelegation)),
-  votingPurpose: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
-  paymentAddress: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoAuxiliaryData = schema_utils_1.Type.Object({
-  hash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  cVoteRegistrationParameters: schema_utils_1.Type.Optional(exports.CardanoCVoteRegistrationParameters)
-});
-exports.CardanoSignTransaction = schema_utils_1.Type.Object({
-  inputs: schema_utils_1.Type.Array(exports.CardanoInput),
-  outputs: schema_utils_1.Type.Array(exports.CardanoOutput),
-  fee: schema_utils_1.Type.Uint(),
-  ttl: schema_utils_1.Type.Optional(schema_utils_1.Type.Uint()),
-  certificates: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.CardanoCertificate)),
-  withdrawals: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.CardanoWithdrawal)),
-  validityIntervalStart: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  auxiliaryData: schema_utils_1.Type.Optional(exports.CardanoAuxiliaryData),
-  mint: schema_utils_1.Type.Optional(exports.CardanoMint),
-  scriptDataHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  collateralInputs: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.CardanoCollateralInput)),
-  requiredSigners: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.CardanoRequiredSigner)),
-  collateralReturn: schema_utils_1.Type.Optional(exports.CardanoOutput),
-  totalCollateral: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  referenceInputs: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(exports.CardanoReferenceInput)),
-  additionalWitnessRequests: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(params_1.DerivationPath)),
-  protocolMagic: schema_utils_1.Type.Number(),
-  networkId: schema_utils_1.Type.Number(),
-  signingMode: constants_1.PROTO.EnumCardanoTxSigningMode,
-  derivationType: schema_utils_1.Type.Optional(constants_1.PROTO.EnumCardanoDerivationType),
-  includeNetworkId: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
-  chunkify: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
-  tagCborSets: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean())
-});
-exports.CardanoSignTransactionExtended = schema_utils_1.Type.Intersect([exports.CardanoSignTransaction, schema_utils_1.Type.Object({
-  unsignedTx: schema_utils_1.Type.Object({
-    body: schema_utils_1.Type.String(),
-    hash: schema_utils_1.Type.String()
-  }),
-  testnet: schema_utils_1.Type.Boolean()
-})]);
-exports.CardanoSignedTxWitness = schema_utils_1.Type.Object({
-  type: constants_1.PROTO.EnumCardanoTxWitnessType,
-  pubKey: schema_utils_1.Type.String(),
-  signature: schema_utils_1.Type.String(),
-  chainCode: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoAuxiliaryDataSupplement = schema_utils_1.Type.Object({
-  type: constants_1.PROTO.EnumCardanoTxAuxiliaryDataSupplementType,
-  auxiliaryDataHash: schema_utils_1.Type.String(),
-  cVoteRegistrationSignature: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-});
-exports.CardanoSignedTxData = schema_utils_1.Type.Object({
-  hash: schema_utils_1.Type.String(),
-  witnesses: schema_utils_1.Type.Array(exports.CardanoSignedTxWitness),
-  auxiliaryDataSupplement: schema_utils_1.Type.Optional(exports.CardanoAuxiliaryDataSupplement)
-});
-exports.CardanoSignMessage = schema_utils_1.Type.Object({
-  path: params_1.DerivationPath,
-  payload: schema_utils_1.Type.String(),
-  preferHexDisplay: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
-  networkId: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
-  protocolMagic: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
-  addressParameters: schema_utils_1.Type.Optional(exports.CardanoAddressParameters),
-  derivationType: schema_utils_1.Type.Optional(constants_1.PROTO.EnumCardanoDerivationType)
-});
-exports.CardanoMessageProtectedHeaders = schema_utils_1.Type.Object({
-  1: schema_utils_1.Type.Literal(constants_1.CARDANO.ALGORITHM_IDS.EdDSA),
-  address: schema_utils_1.Type.String()
-});
-exports.CardanoMessageUnprotectedHeaders = schema_utils_1.Type.Object({
-  hashed: schema_utils_1.Type.Boolean(),
-  version: schema_utils_1.Type.Number()
-});
-exports.CardanoMessageHeaders = schema_utils_1.Type.Object({
-  protected: exports.CardanoMessageProtectedHeaders,
-  unprotected: exports.CardanoMessageUnprotectedHeaders
-});
-exports.CardanoSignedMessage = schema_utils_1.Type.Object({
-  headers: exports.CardanoMessageHeaders,
-  payload: schema_utils_1.Type.String(),
-  signature: schema_utils_1.Type.String(),
-  pubKey: schema_utils_1.Type.String(),
-  coseSignature: schema_utils_1.Type.String(),
-  coseKey: schema_utils_1.Type.String()
-});
-//# sourceMappingURL=index.js.map

package/lib/types/api/cardanoComposeTransaction.d.ts

@@ -1,150 +0,0 @@
-import type { trezorUtils, types } from '@fivebinaries/coin-selection';
-import type { Utxo as AccountUtxo } from '@trezor/blockchain-link-types';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { Static } from '@trezor/schema-utils';
-import { type Params, type Response } from '../params';
-import { CardanoCertificate } from './cardano';
-import type { CardanoInput, CardanoOutput } from './cardano';
-import type { PrecomposeResultError, PrecomposeResultFinal, PrecomposeResultNonFinal } from './composeTransaction';
-export type PrecomposedTransactionFinalCardano = Omit<PrecomposeResultFinal, 'inputs' | 'outputs' | 'outputsPermutation'> & {
-    deposit?: string;
-    ttl?: number;
-    inputs: CardanoInput[];
-    outputs: CardanoOutput[];
-    unsignedTx: {
-        body: string;
-        hash: string;
-    };
-};
-export type PrecomposedTransactionNonFinalCardano = Omit<PrecomposeResultNonFinal, 'inputs'> & {
-    deposit?: string;
-};
-export type PrecomposedTransactionErrorCardano = PrecomposeResultError | {
-    type: 'error';
-    error: 'UTXO_BALANCE_INSUFFICIENT' | 'UTXO_VALUE_TOO_SMALL';
-};
-export type PrecomposedTransactionCardano = PrecomposedTransactionFinalCardano | PrecomposedTransactionNonFinalCardano | PrecomposedTransactionErrorCardano;
-export declare const AccountAddress: import("@trezor/schema-utils").TObject<{
-    address: import("@trezor/schema-utils").TString;
-    path: import("@trezor/schema-utils").TString;
-    transfers: import("@trezor/schema-utils").TNumber;
-    balance: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-    sent: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-    received: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-}>;
-export type CardanoComposeTransactionParams = {
-    account: {
-        descriptor: string;
-        utxo: AccountUtxo[];
-    };
-    feeLevels?: {
-        feePerUnit?: string;
-    }[];
-    outputs?: types.UserOutput[];
-    certificates?: CardanoCertificate[];
-    withdrawals?: types.Withdrawal[];
-    changeAddress: {
-        address: string;
-        path: string;
-    };
-    addressParameters: Parameters<(typeof trezorUtils)['transformToTrezorOutputs']>[1];
-    testnet?: boolean;
-};
-export type CardanoComposeTransactionParamsSchema = Static<typeof CardanoComposeTransactionParamsSchema>;
-export declare const CardanoComposeTransactionParamsSchema: import("@trezor/schema-utils").TObject<{
-    account: import("@trezor/schema-utils").TObject<{
-        descriptor: import("@trezor/schema-utils").TString;
-        utxo: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-            txid: import("@trezor/schema-utils").TString;
-            vout: import("@trezor/schema-utils").TNumber;
-            amount: import("@trezor/schema-utils").TString;
-            blockHeight: import("@trezor/schema-utils").TNumber;
-            address: import("@trezor/schema-utils").TString;
-            path: import("@trezor/schema-utils").TString;
-            confirmations: import("@trezor/schema-utils").TNumber;
-            coinbase: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
-            cardanoSpecific: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
-                unit: import("@trezor/schema-utils").TString;
-            }>>;
-        }>>;
-    }>;
-    feeLevels: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-        feePerUnit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-    }>>>;
-    outputs: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TIntersect<[import("@trezor/schema-utils").TObject<{
-        isChange: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
-        assets: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-            unit: import("@trezor/schema-utils").TString;
-            quantity: import("@trezor/schema-utils").TString;
-        }>>;
-    }>, import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TObject<{
-        address: import("@trezor/schema-utils").TString;
-        amount: import("@trezor/schema-utils").TString;
-        setMax: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TLiteral<false>>;
-    }>, import("@trezor/schema-utils").TObject<{
-        address: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        amount: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        setMax: import("@trezor/schema-utils").TBoolean;
-    }>]>]>>>;
-    certificates: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-        type: import("@trezor/schema-utils").TEnum<typeof PROTO.CardanoCertificateType>;
-        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>]>>;
-        pool: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        poolParameters: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
-            poolId: import("@trezor/schema-utils").TString;
-            vrfKeyHash: import("@trezor/schema-utils").TString;
-            pledge: import("@trezor/schema-utils").TString;
-            cost: import("@trezor/schema-utils").TString;
-            margin: import("@trezor/schema-utils").TObject<{
-                numerator: import("@trezor/schema-utils").TString;
-                denominator: import("@trezor/schema-utils").TString;
-            }>;
-            rewardAccount: import("@trezor/schema-utils").TString;
-            owners: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-                stakingKeyPath: 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>;
-            }>>;
-            relays: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-                type: import("@trezor/schema-utils").TEnum<typeof PROTO.CardanoPoolRelayType>;
-                ipv4Address: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-                ipv6Address: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-                port: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TNumber>;
-                hostName: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-            }>>;
-            metadata: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
-                url: import("@trezor/schema-utils").TString;
-                hash: import("@trezor/schema-utils").TString;
-            }>>;
-        }>>;
-        scriptHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        keyHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        deposit: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        dRep: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TObject<{
-            type: import("@trezor/schema-utils").TEnum<typeof PROTO.CardanoDRepType>;
-            keyHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-            scriptHash: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-        }>>;
-    }>>>;
-    withdrawals: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TObject<{
-        stakeAddress: import("@trezor/schema-utils").TString;
-        amount: import("@trezor/schema-utils").TString;
-    }>>>;
-    changeAddress: import("@trezor/schema-utils").TObject<{
-        address: import("@trezor/schema-utils").TString;
-        path: import("@trezor/schema-utils").TString;
-    }>;
-    addressParameters: import("@trezor/schema-utils").TObject<{
-        addressType: import("@trezor/schema-utils").TEnum<typeof PROTO.CardanoAddressType>;
-        path: 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;
-        }>>;
-    }>;
-    testnet: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
-}>;
-export declare function cardanoComposeTransaction(params: Params<CardanoComposeTransactionParams>): Response<PrecomposedTransactionCardano[]>;
-//# sourceMappingURL=cardanoComposeTransaction.d.ts.map

package/lib/types/api/cardanoComposeTransaction.js

@@ -1,91 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CardanoComposeTransactionParamsSchema = exports.AccountAddress = void 0;
-const protobuf_1 = require("@trezor/protobuf");
-const schema_utils_1 = require("@trezor/schema-utils");
-const params_1 = require("../params");
-const cardano_1 = require("./cardano");
-exports.AccountAddress = schema_utils_1.Type.Object({
-  address: schema_utils_1.Type.String(),
-  path: schema_utils_1.Type.String(),
-  transfers: schema_utils_1.Type.Number(),
-  balance: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  sent: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-  received: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-}, {
-  $id: 'AccountAddress'
-});
-exports.CardanoComposeTransactionParamsSchema = schema_utils_1.Type.Object({
-  account: schema_utils_1.Type.Object({
-    descriptor: schema_utils_1.Type.String(),
-    utxo: schema_utils_1.Type.Array(schema_utils_1.Type.Object({
-      txid: schema_utils_1.Type.String(),
-      vout: schema_utils_1.Type.Number(),
-      amount: schema_utils_1.Type.String(),
-      blockHeight: schema_utils_1.Type.Number(),
-      address: schema_utils_1.Type.String(),
-      path: schema_utils_1.Type.String(),
-      confirmations: schema_utils_1.Type.Number(),
-      coinbase: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
-      cardanoSpecific: schema_utils_1.Type.Optional(schema_utils_1.Type.Object({
-        unit: schema_utils_1.Type.String()
-      }))
-    }, {
-      $id: 'AccountUtxo'
-    }))
-  }),
-  feeLevels: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.Object({
-    feePerUnit: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-  }))),
-  outputs: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.Intersect([schema_utils_1.Type.Object({
-    isChange: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean()),
-    assets: schema_utils_1.Type.Array(schema_utils_1.Type.Object({
-      unit: schema_utils_1.Type.String(),
-      quantity: schema_utils_1.Type.String()
-    }))
-  }, {
-    $id: 'BaseOutput'
-  }), schema_utils_1.Type.Union([schema_utils_1.Type.Object({
-    address: schema_utils_1.Type.String(),
-    amount: schema_utils_1.Type.String(),
-    setMax: schema_utils_1.Type.Optional(schema_utils_1.Type.Literal(false))
-  }, {
-    $id: 'ExternalOutput'
-  }), schema_utils_1.Type.Object({
-    address: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-    amount: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-    setMax: schema_utils_1.Type.Boolean()
-  }, {
-    $id: 'ExternalOutputIncomplete'
-  })])], {
-    $id: 'UserOutput'
-  }))),
-  certificates: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(cardano_1.CardanoCertificate)),
-  withdrawals: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(schema_utils_1.Type.Object({
-    stakeAddress: schema_utils_1.Type.String(),
-    amount: schema_utils_1.Type.String()
-  }, {
-    $id: 'Withdrawal'
-  }))),
-  changeAddress: schema_utils_1.Type.Object({
-    address: schema_utils_1.Type.String(),
-    path: schema_utils_1.Type.String()
-  }),
-  addressParameters: schema_utils_1.Type.Object({
-    addressType: protobuf_1.MessagesSchema.EnumCardanoAddressType,
-    path: params_1.DerivationPath,
-    stakingPath: schema_utils_1.Type.Optional(params_1.DerivationPath),
-    stakingKeyHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
-    certificatePointer: schema_utils_1.Type.Optional(cardano_1.CardanoCertificatePointer)
-  }, {
-    $id: 'CardanoAddressParameters'
-  }),
-  testnet: schema_utils_1.Type.Optional(schema_utils_1.Type.Boolean())
-});
-const _params = {};
-const _paramsOld = {};
-[_params, _paramsOld];
-//# sourceMappingURL=cardanoComposeTransaction.js.map

package/lib/types/api/cardanoGetAddress.d.ts

@@ -1,5 +0,0 @@
-import type { BundledParams, Params, Response } from '../params';
-import type { CardanoAddress, CardanoGetAddress } from './cardano';
-export declare function cardanoGetAddress(params: Params<CardanoGetAddress>): Response<CardanoAddress>;
-export declare function cardanoGetAddress(params: BundledParams<CardanoGetAddress>): Response<CardanoAddress[]>;
-//# sourceMappingURL=cardanoGetAddress.d.ts.map

package/lib/types/api/cardanoGetAddress.js

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=cardanoGetAddress.js.map

package/lib/types/api/cardanoGetNativeScriptHash.d.ts

@@ -1,4 +0,0 @@
-import type { Params, Response } from '../params';
-import type { CardanoGetNativeScriptHash, CardanoNativeScriptHash } from './cardano';
-export declare function cardanoGetNativeScriptHash(params: Params<CardanoGetNativeScriptHash>): Response<CardanoNativeScriptHash>;
-//# sourceMappingURL=cardanoGetNativeScriptHash.d.ts.map

package/lib/types/api/cardanoGetNativeScriptHash.js

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=cardanoGetNativeScriptHash.js.map

package/lib/types/api/cardanoGetPublicKey.d.ts

@@ -1,5 +0,0 @@
-import type { BundledParams, Params, Response } from '../params';
-import type { CardanoGetPublicKey, CardanoPublicKey } from './cardano';
-export declare function cardanoGetPublicKey(params: Params<CardanoGetPublicKey>): Response<CardanoPublicKey>;
-export declare function cardanoGetPublicKey(params: BundledParams<CardanoGetPublicKey>): Response<CardanoPublicKey[]>;
-//# sourceMappingURL=cardanoGetPublicKey.d.ts.map

package/lib/types/api/cardanoGetPublicKey.js

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=cardanoGetPublicKey.js.map

package/lib/types/api/cardanoSignMessage.d.ts

@@ -1,4 +0,0 @@
-import type { Params, Response } from '../params';
-import type { CardanoSignMessage, CardanoSignedMessage } from './cardano';
-export declare function cardanoSignMessage(params: Params<CardanoSignMessage>): Response<CardanoSignedMessage>;
-//# sourceMappingURL=cardanoSignMessage.d.ts.map

package/lib/types/api/cardanoSignMessage.js

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=cardanoSignMessage.js.map

package/lib/types/api/cardanoSignTransaction.d.ts

@@ -1,10 +0,0 @@
-import type { Params, Response } from '../params';
-import type { CardanoSignTransaction, CardanoSignTransactionExtended, CardanoSignedTxData } from './cardano';
-export declare function cardanoSignTransaction(params: Params<CardanoSignTransaction & {
-    unsignedTx?: undefined;
-    testnet?: undefined;
-}>): Response<CardanoSignedTxData>;
-export declare function cardanoSignTransaction(params: Params<CardanoSignTransactionExtended>): Response<CardanoSignedTxData & {
-    serializedTx: string;
-}>;
-//# sourceMappingURL=cardanoSignTransaction.d.ts.map

package/lib/types/api/cardanoSignTransaction.js

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=cardanoSignTransaction.js.map

package/lib/types/api/changeLanguage.d.ts

@@ -1,15 +0,0 @@
-import { Static } from '@trezor/schema-utils';
-import { PROTO } from '../../constants';
-import type { Params, Response } from '../params';
-export type ChangeLanguage = Static<typeof ChangeLanguage>;
-export declare const ChangeLanguage: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TObject<{
-    binary: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
-    language: import("@trezor/schema-utils").TString;
-    baseUrl: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TString>;
-}>, import("@trezor/schema-utils").TObject<{
-    binary: import("@trezor/schema-utils/lib/custom-types/array-buffer").TArrayBuffer;
-    language: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
-    baseUrl: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUndefined>;
-}>]>;
-export declare function changeLanguage(params: Params<ChangeLanguage>): Response<PROTO.Success>;
-//# sourceMappingURL=changeLanguage.d.ts.map

package/lib/types/api/changeLanguage.js

@@ -1,17 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ChangeLanguage = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-exports.ChangeLanguage = schema_utils_1.Type.Union([schema_utils_1.Type.Object({
-  binary: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined()),
-  language: schema_utils_1.Type.String(),
-  baseUrl: schema_utils_1.Type.Optional(schema_utils_1.Type.String())
-}), schema_utils_1.Type.Object({
-  binary: schema_utils_1.Type.ArrayBuffer(),
-  language: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined()),
-  baseUrl: schema_utils_1.Type.Optional(schema_utils_1.Type.Undefined())
-})]);
-//# sourceMappingURL=changeLanguage.js.map

package/lib/types/api/changePin.d.ts

@@ -1,4 +0,0 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { Params, Response } from '../params';
-export declare function changePin(params: Params<PROTO.ChangePin>): Response<PROTO.Success>;
-//# sourceMappingURL=changePin.d.ts.map

package/lib/types/api/changePin.js

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=changePin.js.map

package/lib/types/api/changeWipeCode.d.ts

@@ -1,4 +0,0 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { Params, Response } from '../params';
-export declare function changeWipeCode(params: Params<PROTO.ChangeWipeCode>): Response<PROTO.Success>;
-//# sourceMappingURL=changeWipeCode.d.ts.map

package/lib/types/api/changeWipeCode.js

@@ -1,6 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-//# sourceMappingURL=changeWipeCode.js.map

package/lib/types/api/cipherKeyValue.d.ts

@@ -1,18 +0,0 @@
-import { Static } from '@trezor/schema-utils';
-import { BundledParams, Params, Response } from '../params';
-export type CipherKeyValue = Static<typeof CipherKeyValue>;
-export declare const CipherKeyValue: import("@trezor/schema-utils").TObject<{
-    path: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>]>;
-    key: import("@trezor/schema-utils").TString;
-    value: import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils/lib/custom-types/buffer").TBuffer]>;
-    encrypt: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
-    askOnEncrypt: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
-    askOnDecrypt: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TBoolean>;
-    iv: import("@trezor/schema-utils").TOptional<import("@trezor/schema-utils").TUnion<[import("@trezor/schema-utils").TString, import("@trezor/schema-utils/lib/custom-types/buffer").TBuffer]>>;
-}>;
-export interface CipheredValue {
-    value: string;
-}
-export declare function cipherKeyValue(params: Params<CipherKeyValue>): Response<CipheredValue>;
-export declare function cipherKeyValue(params: BundledParams<CipherKeyValue>): Response<CipheredValue[]>;
-//# sourceMappingURL=cipherKeyValue.d.ts.map