@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/cardano/cardanoAddressParameters.js

@@ -1,31 +1,25 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.addressParametersFromProto = exports.addressParametersToProto = exports.modifyAddressParametersForBackwardsCompatibility = exports.validateAddressParameters = 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 validateAddressParameters = addressParameters => {
-  (0, schema_utils_1.Assert)(cardano_1.CardanoAddressParameters, addressParameters);
+import { CardanoAddressParameters } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { validatePath } from "../../utils/pathUtils.js";
+export const validateAddressParameters = addressParameters => {
+  Assert(CardanoAddressParameters, addressParameters);
   if (addressParameters.path) {
-    (0, pathUtils_1.validatePath)(addressParameters.path);
+    validatePath(addressParameters.path);
   }
   if (addressParameters.stakingPath) {
-    (0, pathUtils_1.validatePath)(addressParameters.stakingPath);
+    validatePath(addressParameters.stakingPath);
   }
 };
-exports.validateAddressParameters = validateAddressParameters;
-const modifyAddressParametersForBackwardsCompatibility = address_parameters => {
-  if (address_parameters.address_type === constants_1.PROTO.CardanoAddressType.REWARD) {
+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 constants_1.ERRORS.TypedError('Method_InvalidParameter', `Only stakingPath is allowed for CardanoAddressType.REWARD`);
+      throw ERRORS.TypedError('Method_InvalidParameter', `Only stakingPath is allowed for CardanoAddressType.REWARD`);
     }
     if (address_n.length > 0) {
       address_n_staking = address_n;
@@ -39,15 +33,14 @@ const modifyAddressParametersForBackwardsCompatibility = address_parameters => {
   }
   return address_parameters;
 };
-exports.modifyAddressParametersForBackwardsCompatibility = modifyAddressParametersForBackwardsCompatibility;
-const addressParametersToProto = addressParameters => {
+export const addressParametersToProto = addressParameters => {
   let path = [];
   if (addressParameters.path) {
-    path = (0, pathUtils_1.validatePath)(addressParameters.path, 3);
+    path = validatePath(addressParameters.path, 3);
   }
   let stakingPath = [];
   if (addressParameters.stakingPath) {
-    stakingPath = (0, pathUtils_1.validatePath)(addressParameters.stakingPath, 3);
+    stakingPath = validatePath(addressParameters.stakingPath, 3);
   }
   let certificatePointer;
   if (addressParameters.certificatePointer) {
@@ -67,8 +60,7 @@ const addressParametersToProto = addressParameters => {
     script_staking_hash: addressParameters.stakingScriptHash
   };
 };
-exports.addressParametersToProto = addressParametersToProto;
-const addressParametersFromProto = addressParameters => {
+export const addressParametersFromProto = addressParameters => {
   let certificatePointer;
   if (addressParameters.certificate_pointer) {
     certificatePointer = {
@@ -84,6 +76,4 @@ const addressParametersFromProto = addressParameters => {
     stakingKeyHash: addressParameters.staking_key_hash,
     certificatePointer
   };
-};
-exports.addressParametersFromProto = addressParametersFromProto;
-//# sourceMappingURL=cardanoAddressParameters.js.map
+};

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

@@ -1,5 +1,4 @@
-import { PROTO } from '../../constants';
-import { CardanoAuxiliaryData } from '../../types/api/cardano';
+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;
-//# sourceMappingURL=cardanoAuxiliaryData.d.ts.map
+export declare const modifyAuxiliaryDataForBackwardsCompatibility: (auxiliary_data: PROTO.CardanoTxAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;

package/lib/api/cardano/cardanoAuxiliaryData.js

@@ -1,21 +1,15 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.modifyAuxiliaryDataForBackwardsCompatibility = exports.transformAuxiliaryData = void 0;
-const schema_utils_1 = require("@trezor/schema-utils");
-const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
-const constants_1 = require("../../constants");
-const cardano_1 = require("../../types/api/cardano");
-const pathUtils_1 = require("../../utils/pathUtils");
+import { CardanoAuxiliaryData, CardanoCVoteRegistrationDelegation, CardanoCVoteRegistrationParameters } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { Assert } from "@trezor/schema-utils";
+import { addressParametersToProto, modifyAddressParametersForBackwardsCompatibility, validateAddressParameters } from "./cardanoAddressParameters.js";
+import { validatePath } from "../../utils/pathUtils.js";
 const MAX_DELEGATION_COUNT = 32;
 const transformDelegation = delegation => {
   if (delegation.votingPublicKey) {
     console.warn('Please use votePublicKey instead of votingPublicKey.');
     delegation.votePublicKey = delegation.votingPublicKey;
   }
-  (0, schema_utils_1.Assert)(cardano_1.CardanoCVoteRegistrationDelegation, delegation);
+  Assert(CardanoCVoteRegistrationDelegation, delegation);
   return {
     vote_public_key: delegation.votePublicKey,
     weight: delegation.weight
@@ -30,23 +24,23 @@ const transformCvoteRegistrationParameters = cVoteRegistrationParameters => {
     console.warn('Please use paymentAddressParameters instead of rewardAddressParameters.');
     cVoteRegistrationParameters.paymentAddressParameters = cVoteRegistrationParameters.rewardAddressParameters;
   }
-  (0, schema_utils_1.Assert)(cardano_1.CardanoCVoteRegistrationParameters, cVoteRegistrationParameters);
+  Assert(CardanoCVoteRegistrationParameters, cVoteRegistrationParameters);
   const {
     paymentAddressParameters
   } = cVoteRegistrationParameters;
   if (paymentAddressParameters) {
-    (0, cardanoAddressParameters_1.validateAddressParameters)(paymentAddressParameters);
+    validateAddressParameters(paymentAddressParameters);
   }
   const {
     delegations
   } = cVoteRegistrationParameters;
   if (delegations && delegations.length > MAX_DELEGATION_COUNT) {
-    throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `At most ${MAX_DELEGATION_COUNT} delegations are allowed in a CIP-36 registration`);
+    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: (0, pathUtils_1.validatePath)(cVoteRegistrationParameters.stakingPath, 3),
-    payment_address_parameters: paymentAddressParameters ? (0, cardanoAddressParameters_1.addressParametersToProto)(paymentAddressParameters) : undefined,
+    staking_path: validatePath(cVoteRegistrationParameters.stakingPath, 3),
+    payment_address_parameters: paymentAddressParameters ? addressParametersToProto(paymentAddressParameters) : undefined,
     nonce: cVoteRegistrationParameters.nonce,
     format: cVoteRegistrationParameters.format,
     delegations: delegations?.map(transformDelegation),
@@ -54,8 +48,8 @@ const transformCvoteRegistrationParameters = cVoteRegistrationParameters => {
     payment_address: cVoteRegistrationParameters.paymentAddress
   };
 };
-const transformAuxiliaryData = auxiliaryData => {
-  (0, schema_utils_1.Assert)(cardano_1.CardanoAuxiliaryData, auxiliaryData);
+export const transformAuxiliaryData = auxiliaryData => {
+  Assert(CardanoAuxiliaryData, auxiliaryData);
   let cVoteRegistrationParameters;
   if (auxiliaryData.cVoteRegistrationParameters) {
     cVoteRegistrationParameters = transformCvoteRegistrationParameters(auxiliaryData.cVoteRegistrationParameters);
@@ -65,19 +59,16 @@ const transformAuxiliaryData = auxiliaryData => {
     cvote_registration_parameters: cVoteRegistrationParameters
   };
 };
-exports.transformAuxiliaryData = transformAuxiliaryData;
-const modifyAuxiliaryDataForBackwardsCompatibility = auxiliary_data => {
+export const modifyAuxiliaryDataForBackwardsCompatibility = auxiliary_data => {
   const {
     cvote_registration_parameters
   } = auxiliary_data;
   if (cvote_registration_parameters?.payment_address_parameters) {
-    cvote_registration_parameters.payment_address_parameters = (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(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;
-};
-exports.modifyAuxiliaryDataForBackwardsCompatibility = modifyAuxiliaryDataForBackwardsCompatibility;
-//# sourceMappingURL=cardanoAuxiliaryData.js.map
+};

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

@@ -1,14 +1,13 @@
-import { PROTO } from '../../constants';
-import { CardanoCertificate } from '../../types/api/cardano';
+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[];
+  certificate: PROTO.CardanoTxCertificate;
+  poolOwners: PROTO.CardanoPoolOwner[];
+  poolRelays: PROTO.CardanoPoolRelayParameters[];
 };
 export type PoolParametersWithOwnersAndRelays = {
-    poolParameters?: PROTO.CardanoPoolParametersType;
-    poolOwners: PROTO.CardanoPoolOwner[];
-    poolRelays: PROTO.CardanoPoolRelayParameters[];
+  poolParameters?: PROTO.CardanoPoolParametersType;
+  poolOwners: PROTO.CardanoPoolOwner[];
+  poolRelays: PROTO.CardanoPoolRelayParameters[];
 };
-export declare const transformCertificate: (certificate: CardanoCertificate) => CertificateWithPoolOwnersAndRelays;
-//# sourceMappingURL=cardanoCertificate.d.ts.map
+export declare const transformCertificate: (certificate: CardanoCertificate) => CertificateWithPoolOwnersAndRelays;

package/lib/api/cardano/cardanoCertificate.js

@@ -1,59 +1,54 @@
-"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");
+import { CardanoCertificate, CardanoDRep, CardanoPoolParameters, CardanoPoolRelay } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { MessagesSchema as PROTO } from "@trezor/protobuf";
+import { Assert } from "@trezor/schema-utils";
+import { validatePath } from "../../utils/pathUtils.js";
 const ipv4AddressToHex = ipv4Address => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
 const ipv6AddressToHex = ipv6Address => ipv6Address.split(':').join('');
 const validatePoolRelay = relay => {
-  (0, schema_utils_1.Assert)(cardano_1.CardanoPoolRelay, relay);
-  if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_IP) {
+  Assert(CardanoPoolRelay, relay);
+  if (relay.type === PROTO.CardanoPoolRelayType.SINGLE_HOST_IP) {
     if (!relay.ipv4Address && !relay.ipv6Address) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either ipv4Address or ipv6Address must be supplied');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Either ipv4Address or ipv6Address must be supplied');
     }
-  } else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
+  } else if (relay.type === PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
     if (!relay.hostName) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
     }
     if (!relay.port) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'port must be supplied');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'port must be supplied');
     }
-  } else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
+  } else if (relay.type === PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
     if (!relay.hostName) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
     }
   }
 };
 const validatePoolOwners = owners => {
   owners.forEach(owner => {
     if (owner.stakingKeyPath) {
-      (0, pathUtils_1.validatePath)(owner.stakingKeyPath, 5);
+      validatePath(owner.stakingKeyPath, 5);
     }
     if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either stakingKeyHash or stakingKeyPath must be supplied');
+      throw 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');
+    throw 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);
+  Assert(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');
+  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 => {
@@ -80,7 +75,7 @@ const transformPoolParameters = poolParameters => {
     },
     poolOwners: poolParameters.owners.map(owner => ({
       staking_key_hash: owner.stakingKeyHash,
-      staking_key_path: owner.stakingKeyPath ? (0, pathUtils_1.validatePath)(owner.stakingKeyPath, 5) : undefined
+      staking_key_path: owner.stakingKeyPath ? validatePath(owner.stakingKeyPath, 5) : undefined
     })),
     poolRelays: poolParameters.relays.map(relay => ({
       type: relay.type,
@@ -102,26 +97,26 @@ const transformDRep = dRep => {
     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) {
+export const transformCertificate = certificate => {
+  Assert(CardanoCertificate, certificate);
+  if (certificate.type === PROTO.CardanoCertificateType.STAKE_DELEGATION) {
     if (!certificate.pool) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'pool must be supplied for STAKE_DELEGATION');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'pool must be supplied for STAKE_DELEGATION');
     }
   }
-  if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+  if (certificate.type === PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
     if (!certificate.poolParameters) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'poolParameters must be supplied for STAKE_POOL_REGISTRATION');
+      throw 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.type === PROTO.CardanoCertificateType.STAKE_REGISTRATION_CONWAY || certificate.type === 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');
+      throw 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.type === PROTO.CardanoCertificateType.VOTE_DELEGATION) {
     if (!certificate.dRep) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'dRep must be supplied for VOTE_DELEGATION');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'dRep must be supplied for VOTE_DELEGATION');
     }
   }
   const {
@@ -133,7 +128,7 @@ const transformCertificate = certificate => {
   return {
     certificate: {
       type: certificate.type,
-      path: certificate.path ? (0, pathUtils_1.validatePath)(certificate.path, 5) : undefined,
+      path: certificate.path ? validatePath(certificate.path, 5) : undefined,
       script_hash: certificate.scriptHash,
       key_hash: certificate.keyHash,
       pool: certificate.pool,
@@ -144,6 +139,4 @@ const transformCertificate = certificate => {
     poolOwners,
     poolRelays
   };
-};
-exports.transformCertificate = transformCertificate;
-//# sourceMappingURL=cardanoCertificate.js.map
+};

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

@@ -1,26 +1,25 @@
-import { Static } from '@trezor/schema-utils';
-import { PROTO } from '../../constants';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
+import type { Static } from '@trezor/schema-utils';
 export type Path = number[];
-export declare const Path: import("@trezor/schema-utils").TArray<import("@trezor/schema-utils").TNumber>;
+export declare const Path: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
 export type CollateralInputWithPath = {
-    collateralInput: PROTO.CardanoTxCollateralInput;
-    path?: Path;
+  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 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("@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 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;
-//# sourceMappingURL=cardanoInputs.d.ts.map
+export declare const transformReferenceInput: (referenceInput: unknown) => PROTO.CardanoTxReferenceInput;

package/lib/api/cardano/cardanoInputs.js

@@ -1,49 +1,39 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
+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.js";
+export const Path = Type.Array(Type.Number());
+export const InputWithPath = Type.Object({
+  input: PROTO.CardanoTxInput,
+  path: Type.Optional(Path)
 });
-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)
+export const InputWithPathParam = Type.Composite([PROTO.CardanoTxInput, Type.Object({
+  path: Type.Optional(DerivationPath)
 })]);
-const transformInput = input => {
-  (0, schema_utils_1.Assert)(exports.InputWithPathParam, input);
+export const transformInput = input => {
+  Assert(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
+    path: input.path ? validatePath(input.path, 5) : undefined
   };
 };
-exports.transformInput = transformInput;
-const transformCollateralInput = collateralInput => {
-  (0, schema_utils_1.Assert)(exports.InputWithPathParam, collateralInput);
+export const transformCollateralInput = collateralInput => {
+  Assert(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
+    path: collateralInput.path ? validatePath(collateralInput.path, 5) : undefined
   };
 };
-exports.transformCollateralInput = transformCollateralInput;
-const transformReferenceInput = referenceInput => {
-  (0, schema_utils_1.Assert)(constants_1.PROTO.CardanoTxInput, referenceInput);
+export const transformReferenceInput = referenceInput => {
+  Assert(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 +1,40 @@
-import { AssetGroupWithTokens } from './cardanoTokenBundle';
-import { PROTO } from '../../constants';
+import type { PROTO } from '@trezor/connect-common';
+import type { MessagesSchema as Messages } from '@trezor/protobuf';
+import type { AssetGroupWithTokens } from "./cardanoTokenBundle.js";
 export type OutputWithData = {
-    output: PROTO.CardanoTxOutput;
-    tokenBundle?: AssetGroupWithTokens[];
-    inlineDatum?: string;
-    referenceScript?: string;
+  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 OutputValidation: import("@sinclair/typebox").TObject<{
+  address: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+  amount: import("@trezor/schema-utils/lib/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: any, outputWithData: OutputWithData) => Promise<void>;
-//# sourceMappingURL=cardanoOutputs.d.ts.map
+export declare const sendOutput: (typedCall: Messages.TypedCall, outputWithData: OutputWithData) => Promise<void>;