@trezor/connect 9.1.9 → 9.1.11

package/lib/api/blockchainDisconnect.js

@@ -1,17 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
 const constants_1 = require("../constants");
 const BlockchainLink_1 = require("../backend/BlockchainLink");
 const coinInfo_1 = require("../data/coinInfo");
+const types_1 = require("../types");
+const schema_utils_1 = require("@trezor/schema-utils");
 class BlockchainDisconnect extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = [];
         this.useDevice = false;
         this.useUi = false;
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [{ name: 'coin', type: 'string', required: true }]);
+        (0, schema_utils_1.Assert)(types_1.CoinObj, payload);
         const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
         if (!coinInfo) {
             throw constants_1.ERRORS.TypedError('Method_UnknownCoin');

package/lib/api/blockchainGetAccountBalanceHistory.d.ts

@@ -6,7 +6,7 @@ type Params = {
 };
 export default class BlockchainGetAccountBalanceHistory extends AbstractMethod<'blockchainGetAccountBalanceHistory', Params> {
     init(): void;
-    run(): Promise<import("packages/blockchain-link-types/lib/common").AccountBalanceHistory[]>;
+    run(): Promise<import("@trezor/blockchain-link-types/lib/common").AccountBalanceHistory[]>;
 }
 export {};
 //# sourceMappingURL=blockchainGetAccountBalanceHistory.d.ts.map

package/lib/api/blockchainGetCurrentFiatRates.d.ts

@@ -9,7 +9,7 @@ export default class BlockchainGetCurrentFiatRates extends AbstractMethod<'block
     init(): void;
     run(): Promise<{
         ts: number;
-        rates: import("packages/blockchain-link-types/lib/common").FiatRates;
+        rates: import("@trezor/blockchain-link-types/lib/common").FiatRates;
     }>;
 }
 export {};

package/lib/api/blockchainGetFiatRatesForTimestamps.d.ts

@@ -11,7 +11,7 @@ export default class BlockchainGetFiatRatesForTimestamps extends AbstractMethod<
     run(): Promise<{
         tickers: {
             ts: number;
-            rates: import("packages/blockchain-link-types/lib/common").FiatRates;
+            rates: import("@trezor/blockchain-link-types/lib/common").FiatRates;
         }[];
     }>;
 }

package/lib/api/blockchainGetTransactions.d.ts

@@ -6,7 +6,7 @@ type Params = {
 };
 export default class BlockchainGetTransactions extends AbstractMethod<'blockchainGetTransactions', Params> {
     init(): void;
-    run(): Promise<import("packages/blockchain-link-types/lib/common").Transaction[]>;
+    run(): Promise<import("@trezor/blockchain-link-types/lib/common").Transaction[]>;
 }
 export {};
 //# sourceMappingURL=blockchainGetTransactions.d.ts.map

package/lib/api/cancelCoinjoinAuthorization.d.ts

@@ -3,6 +3,8 @@ import { PROTO } from '../constants';
 export default class CancelCoinjoinAuthorization extends AbstractMethod<'cancelCoinjoinAuthorization', PROTO.CancelAuthorization> {
     init(): void;
     get info(): string;
-    run(): Promise<PROTO.Success>;
+    run(): Promise<{
+        message: string;
+    }>;
 }
 //# sourceMappingURL=cancelCoinjoinAuthorization.d.ts.map

package/lib/api/cancelCoinjoinAuthorization.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractMethod_1 = require("../core/AbstractMethod");
 const paramsValidator_1 = require("./common/paramsValidator");
+const schema_utils_1 = require("@trezor/schema-utils");
+const cancelCoinjoinAuthorization_1 = require("../types/api/cancelCoinjoinAuthorization");
 class CancelCoinjoinAuthorization extends AbstractMethod_1.AbstractMethod {
     init() {
         const { payload } = this;
+        (0, schema_utils_1.Assert)(cancelCoinjoinAuthorization_1.CancelCoinjoinAuthorization, payload);
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
         this.preauthorized =
             typeof payload.preauthorized === 'boolean' ? payload.preauthorized : true;

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

@@ -16,9 +16,11 @@ export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress
     } | undefined;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
-    _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, chunkify, }: Params): Promise<PROTO.CardanoAddress>;
+    _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, chunkify, }: Params): Promise<{
+        address: string;
+    }>;
     _ensureFirmwareSupportsBatch(batch: Params): void;
-    run(): Promise<import("../../..").CardanoAddress | import("../../..").CardanoAddress[]>;
+    run(): Promise<import("../../../types").CardanoAddress | import("../../../types").CardanoAddress[]>;
 }
 export {};
 //# sourceMappingURL=cardanoGetAddress.d.ts.map

package/lib/api/cardano/api/cardanoGetAddress.js

@@ -7,6 +7,9 @@ const pathUtils_1 = require("../../../utils/pathUtils");
 const cardanoAddressParameters_1 = require("../cardanoAddressParameters");
 const constants_1 = require("../../../constants");
 const events_1 = require("../../../events");
+const schema_utils_1 = require("@trezor/schema-utils");
+const types_1 = require("../../../types");
+const cardano_1 = require("../../../types/api/cardano");
 class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);
@@ -19,20 +22,8 @@ class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
         const payload = !this.payload.bundle
             ? { ...this.payload, bundle: [this.payload] }
             : this.payload;
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'bundle', type: 'array' },
-            { name: 'useEventListener', type: 'boolean' },
-        ]);
+        (0, schema_utils_1.Assert)((0, types_1.Bundle)(cardano_1.CardanoGetAddress), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'addressParameters', type: 'object', required: true },
-                { name: 'networkId', type: 'number', required: true },
-                { name: 'protocolMagic', type: 'number', required: true },
-                { name: 'derivationType', type: 'number' },
-                { name: 'address', type: 'string' },
-                { name: 'showOnTrezor', type: 'boolean' },
-                { name: 'chunkify', type: 'boolean' },
-            ]);
             (0, cardanoAddressParameters_1.validateAddressParameters)(batch.addressParameters);
             return {
                 address_parameters: (0, cardanoAddressParameters_1.addressParametersToProto)(batch.addressParameters),

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

@@ -1,6 +1,6 @@
 import { PROTO } from '../../../constants';
 import { AbstractMethod } from '../../../core/AbstractMethod';
-import type { CardanoNativeScript } from '../../../types/api/cardano';
+import { CardanoNativeScript } from '../../../types/api/cardano';
 export default class CardanoGetNativeScriptHash extends AbstractMethod<'cardanoGetNativeScriptHash', PROTO.CardanoGetNativeScriptHash> {
     init(): void;
     get info(): string;

package/lib/api/cardano/api/cardanoGetNativeScriptHash.js

@@ -5,16 +5,14 @@ const AbstractMethod_1 = require("../../../core/AbstractMethod");
 const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
+const cardano_1 = require("../../../types/api/cardano");
+const schema_utils_1 = require("@trezor/schema-utils");
 class CardanoGetNativeScriptHash extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'script', type: 'object', required: true },
-            { name: 'displayFormat', type: 'number', required: true },
-            { name: 'derivationType', type: 'number' },
-        ]);
+        (0, schema_utils_1.Assert)(cardano_1.CardanoGetNativeScriptHash, payload);
         this.validateScript(payload.script);
         this.params = {
             script: this.scriptToProto(payload.script),
@@ -28,14 +26,6 @@ class CardanoGetNativeScriptHash extends AbstractMethod_1.AbstractMethod {
         return 'Get Cardano native script hash';
     }
     validateScript(script) {
-        (0, paramsValidator_1.validateParams)(script, [
-            { name: 'type', type: 'number', required: true },
-            { name: 'scripts', type: 'array', allowEmpty: true },
-            { name: 'keyHash', type: 'string' },
-            { name: 'requiredSignaturesCount', type: 'number' },
-            { name: 'invalidBefore', type: 'uint' },
-            { name: 'invalidHereafter', type: 'uint' },
-        ]);
         if (script.keyPath) {
             (0, pathUtils_1.validatePath)(script.keyPath, 3);
         }

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

@@ -10,7 +10,7 @@ export default class CardanoGetPublicKey extends AbstractMethod<'cardanoGetPubli
     get info(): string;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(allowSuppression?: boolean): Promise<boolean>;
-    run(): Promise<import("../../..").CardanoPublicKey | import("../../..").CardanoPublicKey[]>;
+    run(): Promise<import("../../../types").CardanoPublicKey | import("../../../types").CardanoPublicKey[]>;
 }
 export {};
 //# sourceMappingURL=cardanoGetPublicKey.d.ts.map

package/lib/api/cardano/api/cardanoGetPublicKey.js

@@ -6,6 +6,9 @@ const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const events_1 = require("../../../events");
+const schema_utils_1 = require("@trezor/schema-utils");
+const types_1 = require("../../../types");
+const cardano_1 = require("../../../types/api/cardano");
 class CardanoGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
@@ -14,14 +17,8 @@ class CardanoGetPublicKey extends AbstractMethod_1.AbstractMethod {
         const payload = !this.payload.bundle
             ? { ...this.payload, bundle: [this.payload] }
             : this.payload;
-        (0, paramsValidator_1.validateParams)(payload, [{ name: 'bundle', type: 'array' }]);
+        (0, schema_utils_1.Assert)((0, types_1.Bundle)(cardano_1.CardanoGetPublicKey), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'derivationType', type: 'number' },
-                { name: 'showOnTrezor', type: 'boolean' },
-                { name: 'suppressBackupWarning', type: 'boolean' },
-            ]);
             const path = (0, pathUtils_1.validatePath)(batch.path, 3);
             return {
                 address_n: path,

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

@@ -3,7 +3,7 @@ import type { CertificateWithPoolOwnersAndRelays } from '../cardanoCertificate';
 import { Path, InputWithPath, CollateralInputWithPath } from '../cardanoInputs';
 import type { OutputWithData } from '../cardanoOutputs';
 import { PROTO } from '../../../constants';
-import type { CardanoAuxiliaryDataSupplement, CardanoSignedTxData, CardanoSignedTxWitness } from '../../../types/api/cardano';
+import { type CardanoSignedTxData } from '../../../types/api/cardano';
 import type { AssetGroupWithTokens } from '../cardanoTokenBundle';
 declare const CardanoSignTransactionFeatures: Readonly<{
     TransactionStreaming: string[];
@@ -55,11 +55,33 @@ export default class CardanoSignTransaction extends AbstractMethod<'cardanoSignT
     _ensureFeatureIsSupported(feature: keyof typeof CardanoSignTransactionFeatures): void;
     _ensureFirmwareSupportsParams(): void;
     _sign_tx(): Promise<CardanoSignedTxData>;
-    run(): Promise<CardanoSignedTxData | {
+    run(): Promise<{
+        auxiliaryDataSupplement?: {
+            cVoteRegistrationSignature?: string | undefined;
+            type: PROTO.CardanoTxAuxiliaryDataSupplementType;
+            auxiliaryDataHash: string;
+        } | undefined;
+        hash: string;
+        witnesses: {
+            chainCode?: string | undefined;
+            type: PROTO.CardanoTxWitnessType;
+            signature: string;
+            pubKey: string;
+        }[];
+    } | {
         serializedTx: string;
+        auxiliaryDataSupplement?: {
+            cVoteRegistrationSignature?: string | undefined;
+            type: PROTO.CardanoTxAuxiliaryDataSupplementType;
+            auxiliaryDataHash: string;
+        } | undefined;
         hash: string;
-        witnesses: CardanoSignedTxWitness[];
-        auxiliaryDataSupplement?: CardanoAuxiliaryDataSupplement | undefined;
+        witnesses: {
+            chainCode?: string | undefined;
+            type: PROTO.CardanoTxWitnessType;
+            signature: string;
+            pubKey: string;
+        }[];
     }>;
 }
 export {};

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

@@ -10,8 +10,10 @@ const cardanoCertificate_1 = require("../cardanoCertificate");
 const cardanoInputs_1 = require("../cardanoInputs");
 const cardanoOutputs_1 = require("../cardanoOutputs");
 const constants_1 = require("../../../constants");
+const cardano_1 = require("../../../types/api/cardano");
 const cardanoWitnesses_1 = require("../cardanoWitnesses");
 const cardanoTokenBundle_1 = require("../cardanoTokenBundle");
+const schema_utils_1 = require("@trezor/schema-utils");
 const CardanoSignTransactionFeatures = Object.freeze({
     TransactionStreaming: ['0', '2.4.2'],
     TokenMinting: ['0', '2.4.3'],
@@ -46,30 +48,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             payload.auxiliaryData.cVoteRegistrationParameters =
                 payload.auxiliaryData.governanceRegistrationParameters;
         }
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'signingMode', type: 'number', required: true },
-            { name: 'inputs', type: 'array', required: true },
-            { name: 'outputs', type: 'array', required: true, allowEmpty: true },
-            { name: 'fee', type: 'uint', required: true },
-            { name: 'ttl', type: 'uint' },
-            { name: 'certificates', type: 'array', allowEmpty: true },
-            { name: 'withdrawals', type: 'array', allowEmpty: true },
-            { name: 'mint', type: 'array', allowEmpty: true },
-            { name: 'validityIntervalStart', type: 'uint' },
-            { name: 'scriptDataHash', type: 'string' },
-            { name: 'collateralInputs', type: 'array', allowEmpty: true },
-            { name: 'requiredSigners', type: 'array', allowEmpty: true },
-            { name: 'totalCollateral', type: 'uint' },
-            { name: 'referenceInputs', type: 'array', allowEmpty: true },
-            { name: 'protocolMagic', type: 'number', required: true },
-            { name: 'networkId', type: 'number', required: true },
-            { name: 'additionalWitnessRequests', type: 'array', allowEmpty: true },
-            { name: 'derivationType', type: 'number' },
-            { name: 'includeNetworkId', type: 'boolean' },
-            { name: 'unsignedTx', type: 'object' },
-            { name: 'testnet', type: 'boolean' },
-            { name: 'chunkify', type: 'boolean' },
-        ]);
+        (0, schema_utils_1.AssertWeak)(schema_utils_1.Type.Union([cardano_1.CardanoSignTransaction, cardano_1.CardanoSignTransactionExtended]), payload);
         const inputsWithPath = payload.inputs.map(cardanoInputs_1.transformInput);
         const outputsWithData = payload.outputs.map(cardanoOutputs_1.transformOutput);
         let certificatesWithPoolOwnersAndRelays = [];
@@ -78,19 +57,12 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         }
         let withdrawals = [];
         if (payload.withdrawals) {
-            withdrawals = payload.withdrawals.map(withdrawal => {
-                (0, paramsValidator_1.validateParams)(withdrawal, [
-                    { name: 'amount', type: 'uint', required: true },
-                    { name: 'scriptHash', type: 'string' },
-                    { name: 'keyHash', type: 'string' },
-                ]);
-                return {
-                    path: withdrawal.path ? (0, pathUtils_1.validatePath)(withdrawal.path, 5) : undefined,
-                    amount: withdrawal.amount,
-                    script_hash: withdrawal.scriptHash,
-                    key_hash: withdrawal.keyHash,
-                };
-            });
+            withdrawals = payload.withdrawals.map(withdrawal => ({
+                path: withdrawal.path ? (0, pathUtils_1.validatePath)(withdrawal.path, 5) : undefined,
+                amount: withdrawal.amount,
+                script_hash: withdrawal.scriptHash,
+                key_hash: withdrawal.keyHash,
+            }));
         }
         let mint = [];
         if (payload.mint) {
@@ -110,15 +82,12 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         }
         let requiredSigners = [];
         if (payload.requiredSigners) {
-            requiredSigners = payload.requiredSigners.map(requiredSigner => {
-                (0, paramsValidator_1.validateParams)(requiredSigner, [{ name: 'keyHash', type: 'string' }]);
-                return {
-                    key_path: requiredSigner.keyPath
-                        ? (0, pathUtils_1.validatePath)(requiredSigner.keyPath, 3)
-                        : undefined,
-                    key_hash: requiredSigner.keyHash,
-                };
-            });
+            requiredSigners = payload.requiredSigners.map(requiredSigner => ({
+                key_path: requiredSigner.keyPath
+                    ? (0, pathUtils_1.validatePath)(requiredSigner.keyPath, 3)
+                    : undefined,
+                key_hash: requiredSigner.keyHash,
+            }));
         }
         const collateralReturnWithData = payload.collateralReturn
             ? (0, cardanoOutputs_1.transformOutput)(payload.collateralReturn)

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

@@ -1,6 +1,6 @@
 import { PROTO } from '../../constants';
 import type { Device } from '../../device/Device';
-import type { CardanoAddressParameters } from '../../types/api/cardano';
+import { CardanoAddressParameters } from '../../types/api/cardano';
 export declare const validateAddressParameters: (addressParameters: CardanoAddressParameters) => void;
 export declare const modifyAddressParametersForBackwardsCompatibility: (device: Device, address_parameters: PROTO.CardanoAddressParametersType) => PROTO.CardanoAddressParametersType;
 export declare const addressParametersToProto: (addressParameters: CardanoAddressParameters) => PROTO.CardanoAddressParametersType;

package/lib/api/cardano/cardanoAddressParameters.js

@@ -1,29 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.addressParametersFromProto = exports.addressParametersToProto = exports.modifyAddressParametersForBackwardsCompatibility = exports.validateAddressParameters = void 0;
-const paramsValidator_1 = require("../common/paramsValidator");
 const pathUtils_1 = require("../../utils/pathUtils");
 const constants_1 = require("../../constants");
+const cardano_1 = require("../../types/api/cardano");
+const schema_utils_1 = require("@trezor/schema-utils");
 const validateAddressParameters = (addressParameters) => {
-    (0, paramsValidator_1.validateParams)(addressParameters, [
-        { name: 'addressType', type: 'number', required: true },
-        { name: 'stakingKeyHash', type: 'string' },
-        { name: 'paymentScriptHash', type: 'string' },
-        { name: 'stakingScriptHash', type: 'string' },
-    ]);
+    (0, schema_utils_1.Assert)(cardano_1.CardanoAddressParameters, addressParameters);
     if (addressParameters.path) {
         (0, pathUtils_1.validatePath)(addressParameters.path);
     }
     if (addressParameters.stakingPath) {
         (0, pathUtils_1.validatePath)(addressParameters.stakingPath);
     }
-    if (addressParameters.certificatePointer) {
-        (0, paramsValidator_1.validateParams)(addressParameters.certificatePointer, [
-            { name: 'blockIndex', type: 'number', required: true },
-            { name: 'txIndex', type: 'number', required: true },
-            { name: 'certificateIndex', type: 'number', required: true },
-        ]);
-    }
 };
 exports.validateAddressParameters = validateAddressParameters;
 const modifyAddressParametersForBackwardsCompatibility = (device, address_parameters) => {

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

@@ -1,6 +1,6 @@
 import type { Device } from '../../device/Device';
 import { PROTO } from '../../constants';
-import type { CardanoAuxiliaryData } from '../../types/api/cardano';
+import { CardanoAuxiliaryData } from '../../types/api/cardano';
 export declare const transformAuxiliaryData: (auxiliaryData: CardanoAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;
 export declare const modifyAuxiliaryDataForBackwardsCompatibility: (device: Device, auxiliary_data: PROTO.CardanoTxAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;
 //# sourceMappingURL=cardanoAuxiliaryData.d.ts.map

package/lib/api/cardano/cardanoAuxiliaryData.js

@@ -2,19 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.modifyAuxiliaryDataForBackwardsCompatibility = exports.transformAuxiliaryData = void 0;
 const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
-const paramsValidator_1 = require("../common/paramsValidator");
 const pathUtils_1 = require("../../utils/pathUtils");
 const constants_1 = require("../../constants");
+const cardano_1 = require("../../types/api/cardano");
+const schema_utils_1 = require("@trezor/schema-utils");
 const MAX_DELEGATION_COUNT = 32;
 const transformDelegation = (delegation) => {
     if (delegation.votingPublicKey) {
         console.warn('Please use votePublicKey instead of votingPublicKey.');
         delegation.votePublicKey = delegation.votingPublicKey;
     }
-    (0, paramsValidator_1.validateParams)(delegation, [
-        { name: 'votePublicKey', type: 'string', required: true },
-        { name: 'weight', type: 'uint', required: true },
-    ]);
+    (0, schema_utils_1.Assert)(cardano_1.CardanoCVoteRegistrationDelegation, delegation);
     return {
         vote_public_key: delegation.votePublicKey,
         weight: delegation.weight,
@@ -30,15 +28,7 @@ const transformCvoteRegistrationParameters = (cVoteRegistrationParameters) => {
         cVoteRegistrationParameters.paymentAddressParameters =
             cVoteRegistrationParameters.rewardAddressParameters;
     }
-    (0, paramsValidator_1.validateParams)(cVoteRegistrationParameters, [
-        { name: 'votePublicKey', type: 'string' },
-        { name: 'stakingPath', required: true },
-        { name: 'nonce', type: 'uint', required: true },
-        { name: 'format', type: 'number' },
-        { name: 'delegations', type: 'array', allowEmpty: true },
-        { name: 'votingPurpose', type: 'uint' },
-        { name: 'address', type: 'string' },
-    ]);
+    (0, schema_utils_1.Assert)(cardano_1.CardanoCVoteRegistrationParameters, cVoteRegistrationParameters);
     const { paymentAddressParameters } = cVoteRegistrationParameters;
     if (paymentAddressParameters) {
         (0, cardanoAddressParameters_1.validateAddressParameters)(paymentAddressParameters);
@@ -61,12 +51,7 @@ const transformCvoteRegistrationParameters = (cVoteRegistrationParameters) => {
     };
 };
 const transformAuxiliaryData = (auxiliaryData) => {
-    (0, paramsValidator_1.validateParams)(auxiliaryData, [
-        {
-            name: 'hash',
-            type: 'string',
-        },
-    ]);
+    (0, schema_utils_1.Assert)(cardano_1.CardanoAuxiliaryData, auxiliaryData);
     let cVoteRegistrationParameters;
     if (auxiliaryData.cVoteRegistrationParameters) {
         cVoteRegistrationParameters = transformCvoteRegistrationParameters(auxiliaryData.cVoteRegistrationParameters);

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

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
-import type { CardanoCertificate } from '../../types/api/cardano';
+import { CardanoCertificate } from '../../types/api/cardano';
 export type CertificateWithPoolOwnersAndRelays = {
     certificate: PROTO.CardanoTxCertificate;
     poolOwners: PROTO.CardanoPoolOwner[];

package/lib/api/cardano/cardanoCertificate.js

@@ -1,57 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transformCertificate = void 0;
-const paramsValidator_1 = require("../common/paramsValidator");
 const pathUtils_1 = require("../../utils/pathUtils");
 const constants_1 = require("../../constants");
+const cardano_1 = require("../../types/api/cardano");
+const schema_utils_1 = require("@trezor/schema-utils");
 const ipv4AddressToHex = (ipv4Address) => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
 const ipv6AddressToHex = (ipv6Address) => ipv6Address.split(':').join('');
-const validatePoolMargin = (margin) => {
-    (0, paramsValidator_1.validateParams)(margin, [
-        { name: 'numerator', type: 'string', required: true },
-        { name: 'denominator', type: 'string', required: true },
-    ]);
-};
-const validatePoolMetadata = (metadata) => {
-    (0, paramsValidator_1.validateParams)(metadata, [
-        { name: 'url', type: 'string', required: true },
-        { name: 'hash', type: 'string', required: true },
-    ]);
-};
 const validatePoolRelay = (relay) => {
-    (0, paramsValidator_1.validateParams)(relay, [{ name: 'type', type: 'number', required: true }]);
+    (0, schema_utils_1.Assert)(cardano_1.CardanoPoolRelay, relay);
     if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_IP) {
-        const paramsToValidate = [
-            { name: 'port', type: 'number', required: true },
-        ];
-        if (relay.ipv4Address) {
-            paramsToValidate.push({ name: 'ipv4Address', type: 'string', required: false });
-        }
-        if (relay.ipv6Address) {
-            paramsToValidate.push({ name: 'ipv6Address', type: 'string', required: false });
-        }
-        (0, paramsValidator_1.validateParams)(relay, paramsToValidate);
         if (!relay.ipv4Address && !relay.ipv6Address) {
             throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either ipv4Address or ipv6Address must be supplied');
         }
     }
     else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
-        (0, paramsValidator_1.validateParams)(relay, [
-            { name: 'hostName', type: 'string', required: true },
-            { name: 'port', type: 'number', required: true },
-        ]);
+        if (!relay.hostName) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
+        }
+        if (!relay.port) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'port must be supplied');
+        }
     }
     else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
-        (0, paramsValidator_1.validateParams)(relay, [{ name: 'hostName', type: 'string', required: true }]);
+        if (!relay.hostName) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'hostName must be supplied');
+        }
     }
 };
 const validatePoolOwners = (owners) => {
     owners.forEach(owner => {
-        if (owner.stakingKeyHash) {
-            (0, paramsValidator_1.validateParams)(owner, [
-                { name: 'stakingKeyHash', type: 'string', required: !owner.stakingKeyPath },
-            ]);
-        }
         if (owner.stakingKeyPath) {
             (0, pathUtils_1.validatePath)(owner.stakingKeyPath, 5);
         }
@@ -65,23 +43,9 @@ const validatePoolOwners = (owners) => {
     }
 };
 const validatePoolParameters = (poolParameters) => {
-    (0, paramsValidator_1.validateParams)(poolParameters, [
-        { name: 'poolId', type: 'string', required: true },
-        { name: 'vrfKeyHash', type: 'string', required: true },
-        { name: 'pledge', type: 'string', required: true },
-        { name: 'cost', type: 'string', required: true },
-        { name: 'margin', type: 'object', required: true },
-        { name: 'rewardAccount', type: 'string', required: true },
-        { name: 'owners', type: 'array', required: true },
-        { name: 'relays', type: 'array', required: true, allowEmpty: true },
-        { name: 'metadata', type: 'object' },
-    ]);
-    validatePoolMargin(poolParameters.margin);
+    (0, schema_utils_1.Assert)(cardano_1.CardanoPoolParameters, poolParameters);
     validatePoolOwners(poolParameters.owners);
     poolParameters.relays.forEach(validatePoolRelay);
-    if (poolParameters.metadata) {
-        validatePoolMetadata(poolParameters.metadata);
-    }
 };
 const transformPoolParameters = (poolParameters) => {
     if (!poolParameters) {
@@ -117,20 +81,17 @@ const transformPoolParameters = (poolParameters) => {
     };
 };
 const transformCertificate = (certificate) => {
-    const paramsToValidate = [
-        { name: 'type', type: 'number', required: true },
-    ];
-    if (certificate.type !== constants_1.PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
-        paramsToValidate.push({ name: 'scriptHash', type: 'string' });
-        paramsToValidate.push({ name: 'keyHash', type: 'string' });
-    }
+    (0, schema_utils_1.Assert)(cardano_1.CardanoCertificate, certificate);
     if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION) {
-        paramsToValidate.push({ name: 'pool', type: 'string', required: true });
+        if (!certificate.pool) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'pool must be supplied for STAKE_DELEGATION');
+        }
     }
     if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
-        paramsToValidate.push({ name: 'poolParameters', type: 'object', required: true });
+        if (!certificate.poolParameters) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'poolParameters must be supplied for STAKE_POOL_REGISTRATION');
+        }
     }
-    (0, paramsValidator_1.validateParams)(certificate, paramsToValidate);
     const { poolParameters, poolOwners, poolRelays } = transformPoolParameters(certificate.poolParameters);
     return {
         certificate: {

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

@@ -1,14 +1,26 @@
-import type { PROTO } from '../../constants';
+import { PROTO } from '../../constants';
+import { Static } from '@trezor/schema-utils';
 export type Path = number[];
-export type InputWithPath = {
-    input: PROTO.CardanoTxInput;
-    path?: Path;
-};
+export declare const Path: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>;
 export type CollateralInputWithPath = {
     collateralInput: PROTO.CardanoTxCollateralInput;
     path?: Path;
 };
-export declare const transformInput: (input: any) => InputWithPath;
-export declare const transformCollateralInput: (collateralInput: any) => CollateralInputWithPath;
-export declare const transformReferenceInput: (referenceInput: any) => PROTO.CardanoTxReferenceInput;
+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<{
+    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TNumber>]>>;
+    prev_hash: import("@sinclair/typebox").TString;
+    prev_index: 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