@trezor/connect 9.1.8 → 9.1.10

package/lib/api/cardano/cardanoInputs.js

@@ -1,13 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformReferenceInput = exports.transformCollateralInput = exports.transformInput = void 0;
-const paramsValidator_1 = require("../common/paramsValidator");
+exports.transformReferenceInput = exports.transformCollateralInput = exports.transformInput = exports.InputWithPathParam = exports.InputWithPath = exports.Path = void 0;
 const pathUtils_1 = require("../../utils/pathUtils");
+const constants_1 = require("../../constants");
+const schema_utils_1 = require("@trezor/schema-utils");
+const exports_1 = require("../../exports");
+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(exports_1.DerivationPath),
+    }),
+]);
 const transformInput = (input) => {
-    (0, paramsValidator_1.validateParams)(input, [
-        { name: 'prev_hash', type: 'string', required: true },
-        { name: 'prev_index', type: 'number', required: true },
-    ]);
+    (0, schema_utils_1.Assert)(exports.InputWithPathParam, input);
     return {
         input: {
             prev_hash: input.prev_hash,
@@ -18,10 +28,7 @@ const transformInput = (input) => {
 };
 exports.transformInput = transformInput;
 const transformCollateralInput = (collateralInput) => {
-    (0, paramsValidator_1.validateParams)(collateralInput, [
-        { name: 'prev_hash', type: 'string', required: true },
-        { name: 'prev_index', type: 'number', required: true },
-    ]);
+    (0, schema_utils_1.Assert)(exports.InputWithPathParam, collateralInput);
     return {
         collateralInput: {
             prev_hash: collateralInput.prev_hash,
@@ -32,10 +39,7 @@ const transformCollateralInput = (collateralInput) => {
 };
 exports.transformCollateralInput = transformCollateralInput;
 const transformReferenceInput = (referenceInput) => {
-    (0, paramsValidator_1.validateParams)(referenceInput, [
-        { name: 'prev_hash', type: 'string', required: true },
-        { name: 'prev_index', type: 'number', required: true },
-    ]);
+    (0, schema_utils_1.Assert)(constants_1.PROTO.CardanoTxInput, referenceInput);
     return {
         prev_hash: referenceInput.prev_hash,
         prev_index: referenceInput.prev_index,

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

@@ -1,4 +1,4 @@
-import type { AssetGroupWithTokens } from './cardanoTokenBundle';
+import { AssetGroupWithTokens } from './cardanoTokenBundle';
 import { PROTO } from '../../constants';
 export type OutputWithData = {
     output: PROTO.CardanoTxOutput;
@@ -6,6 +6,35 @@ export type OutputWithData = {
     inlineDatum?: string;
     referenceScript?: string;
 };
-export declare const transformOutput: (output: any) => OutputWithData;
+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

package/lib/api/cardano/cardanoOutputs.js

@@ -1,20 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendOutput = exports.transformOutput = void 0;
-const paramsValidator_1 = require("../common/paramsValidator");
+exports.sendOutput = exports.transformOutput = exports.OutputValidation = void 0;
 const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
 const cardanoTokenBundle_1 = require("./cardanoTokenBundle");
 const cardanoUtils_1 = require("./cardanoUtils");
+const cardano_1 = require("../../types/api/cardano");
+const schema_utils_1 = require("@trezor/schema-utils");
+exports.OutputValidation = schema_utils_1.Type.Object({
+    address: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    amount: schema_utils_1.Type.Uint(),
+    tokenBundle: schema_utils_1.Type.Optional(schema_utils_1.Type.Array(cardano_1.CardanoAssetGroup)),
+    datumHash: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    format: schema_utils_1.Type.Optional(schema_utils_1.Type.Number()),
+    inlineDatum: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    referenceScript: schema_utils_1.Type.Optional(schema_utils_1.Type.String()),
+    addressParameters: schema_utils_1.Type.Optional(cardano_1.CardanoAddressParameters),
+});
 const transformOutput = (output) => {
-    (0, paramsValidator_1.validateParams)(output, [
-        { name: 'address', type: 'string' },
-        { name: 'amount', type: 'uint', required: true },
-        { name: 'tokenBundle', type: 'array', allowEmpty: true },
-        { name: 'datumHash', type: 'string' },
-        { name: 'format', type: 'number' },
-        { name: 'inlineDatum', type: 'string' },
-        { name: 'referenceScript', type: 'string' },
-    ]);
+    (0, schema_utils_1.Assert)(exports.OutputValidation, output);
     const result = {
         output: {
             amount: output.amount,

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

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

package/lib/api/cardano/cardanoTokenBundle.js

@@ -1,32 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tokenBundleToProto = void 0;
-const paramsValidator_1 = require("../common/paramsValidator");
-const validateTokens = (tokenAmounts) => {
-    tokenAmounts.forEach(tokenAmount => {
-        (0, paramsValidator_1.validateParams)(tokenAmount, [
-            { name: 'assetNameBytes', type: 'string', required: true },
-            { name: 'amount', type: 'uint' },
-            { name: 'mintAmount', type: 'uint', allowNegative: true },
-        ]);
-    });
-};
-const validateTokenBundle = (tokenBundle) => {
-    tokenBundle.forEach(tokenGroup => {
-        (0, paramsValidator_1.validateParams)(tokenGroup, [
-            { name: 'policyId', type: 'string', required: true },
-            { name: 'tokenAmounts', type: 'array', required: true },
-        ]);
-        validateTokens(tokenGroup.tokenAmounts);
-    });
-};
+exports.tokenBundleToProto = exports.AssetGroupWithTokens = void 0;
+const constants_1 = require("../../constants");
+const cardano_1 = require("../../types/api/cardano");
+const schema_utils_1 = require("@trezor/schema-utils");
+exports.AssetGroupWithTokens = schema_utils_1.Type.Object({
+    policyId: schema_utils_1.Type.String(),
+    tokens: schema_utils_1.Type.Array(constants_1.PROTO.CardanoToken, { minItems: 1 }),
+});
 const tokenAmountsToProto = (tokenAmounts) => tokenAmounts.map(tokenAmount => ({
     asset_name_bytes: tokenAmount.assetNameBytes,
     amount: tokenAmount.amount,
     mint_amount: tokenAmount.mintAmount,
 }));
 const tokenBundleToProto = (tokenBundle) => {
-    validateTokenBundle(tokenBundle);
+    (0, schema_utils_1.Assert)(schema_utils_1.Type.Array(cardano_1.CardanoAssetGroup), tokenBundle);
     return tokenBundle.map(tokenGroup => ({
         policyId: tokenGroup.policyId,
         tokens: tokenAmountsToProto(tokenGroup.tokenAmounts),

package/lib/api/changePin.d.ts

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

package/lib/api/changePin.js

@@ -1,13 +1,14 @@
 "use strict";
 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 constants_1 = require("../constants");
 class ChangePin extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['management'];
         this.useDeviceState = false;
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [{ name: 'remove', type: 'boolean' }]);
+        (0, schema_utils_1.Assert)(constants_1.PROTO.ChangePin, payload);
         this.params = {
             remove: payload.remove,
         };

package/lib/api/changeWipeCode.d.ts

@@ -2,6 +2,8 @@ import { AbstractMethod } from '../core/AbstractMethod';
 import type { PROTO } from '../constants';
 export default class ChangeWipeCode extends AbstractMethod<'changeWipeCode', PROTO.ChangeWipeCode> {
     init(): void;
-    run(): Promise<PROTO.Success>;
+    run(): Promise<{
+        message: string;
+    }>;
 }
 //# sourceMappingURL=changeWipeCode.d.ts.map

package/lib/api/cipherKeyValue.d.ts

@@ -4,6 +4,10 @@ export default class CipherKeyValue extends AbstractMethod<'cipherKeyValue', PRO
     hasBundle?: boolean;
     init(): void;
     get info(): string;
-    run(): Promise<PROTO.CipheredKeyValue | PROTO.CipheredKeyValue[]>;
+    run(): Promise<{
+        value: string;
+    } | {
+        value: string;
+    }[]>;
 }
 //# sourceMappingURL=cipherKeyValue.d.ts.map

package/lib/api/cipherKeyValue.js

@@ -4,6 +4,9 @@ const events_1 = require("../events");
 const AbstractMethod_1 = require("../core/AbstractMethod");
 const paramsValidator_1 = require("./common/paramsValidator");
 const pathUtils_1 = require("../utils/pathUtils");
+const schema_utils_1 = require("@trezor/schema-utils");
+const params_1 = require("../types/params");
+const cipherKeyValue_1 = require("../types/api/cipherKeyValue");
 class CipherKeyValue extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
@@ -14,27 +17,16 @@ class CipherKeyValue extends AbstractMethod_1.AbstractMethod {
             : this.payload;
         this.useEmptyPassphrase =
             typeof payload.useEmptyPassphrase === 'boolean' ? payload.useEmptyPassphrase : true;
-        (0, paramsValidator_1.validateParams)(payload, [{ name: 'bundle', type: 'array' }]);
-        this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'key', type: 'string' },
-                { name: 'value', type: 'string' },
-                { name: 'encrypt', type: 'boolean' },
-                { name: 'askOnEncrypt', type: 'boolean' },
-                { name: 'askOnDecrypt', type: 'boolean' },
-                { name: 'iv', type: 'string' },
-            ]);
-            return {
-                address_n: (0, pathUtils_1.validatePath)(batch.path),
-                key: batch.key,
-                value: batch.value instanceof Buffer ? batch.value.toString('hex') : batch.value,
-                encrypt: batch.encrypt,
-                ask_on_encrypt: batch.askOnEncrypt,
-                ask_on_decrypt: batch.askOnDecrypt,
-                iv: batch.iv instanceof Buffer ? batch.iv.toString('hex') : batch.iv,
-            };
-        });
+        (0, schema_utils_1.Assert)((0, params_1.Bundle)(cipherKeyValue_1.CipherKeyValue), payload);
+        this.params = payload.bundle.map(batch => ({
+            address_n: (0, pathUtils_1.validatePath)(batch.path),
+            key: batch.key,
+            value: batch.value instanceof Buffer ? batch.value.toString('hex') : batch.value,
+            encrypt: batch.encrypt,
+            ask_on_encrypt: batch.askOnEncrypt,
+            ask_on_decrypt: batch.askOnDecrypt,
+            iv: batch.iv instanceof Buffer ? batch.iv.toString('hex') : batch.iv,
+        }));
     }
     get info() {
         return 'Cipher key value';

package/lib/api/common/paramsValidator.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getFirmwareRange = exports.validateCoinPath = exports.validateParams = void 0;
-const utils_1 = require("@trezor/utils");
+const tslib_1 = require("tslib");
+const versionUtils = tslib_1.__importStar(require("@trezor/utils/lib/versionUtils"));
 const constants_1 = require("../../constants");
 const pathUtils_1 = require("../../utils/pathUtils");
 const config_1 = require("../../data/config");
@@ -78,7 +79,7 @@ const getFirmwareRange = (method, coinInfo, currentRange) => {
             }
             else if (range[model].min !== '0' &&
                 typeof supportVersion === 'string' &&
-                utils_1.versionUtils.isNewer(supportVersion, range[model].min)) {
+                versionUtils.isNewer(supportVersion, range[model].min)) {
                 range[model].min = supportVersion;
             }
         });
@@ -111,7 +112,7 @@ const getFirmwareRange = (method, coinInfo, currentRange) => {
                 if (modelMin) {
                     if (modelMin === '0' ||
                         range[model].min === '0' ||
-                        !utils_1.versionUtils.isNewerOrEqual(range[model].min, modelMin)) {
+                        !versionUtils.isNewerOrEqual(range[model].min, modelMin)) {
                         range[model].min = modelMin;
                     }
                 }
@@ -123,7 +124,7 @@ const getFirmwareRange = (method, coinInfo, currentRange) => {
                 if (modelMax) {
                     if (modelMax === '0' ||
                         range[model].max === '0' ||
-                        !utils_1.versionUtils.isNewerOrEqual(range[model].max, modelMax)) {
+                        !versionUtils.isNewerOrEqual(range[model].max, modelMax)) {
                         range[model].max = modelMax;
                     }
                 }

package/lib/api/eos/api/eosGetPublicKey.d.ts

@@ -6,6 +6,16 @@ export default class EosGetPublicKey extends AbstractMethod<'eosGetPublicKey', P
     init(): void;
     get info(): string;
     confirmation(): Promise<boolean>;
-    run(): Promise<import("../../..").EosPublicKey | import("../../..").EosPublicKey[]>;
+    run(): Promise<{
+        path: number[];
+        serializedPath: string;
+        wifPublicKey: string;
+        rawPublicKey: string;
+    } | {
+        path: number[];
+        serializedPath: string;
+        wifPublicKey: string;
+        rawPublicKey: string;
+    }[]>;
 }
 //# sourceMappingURL=eosGetPublicKey.d.ts.map

package/lib/api/eos/api/eosGetPublicKey.js

@@ -5,6 +5,8 @@ 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");
 class EosGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
@@ -13,13 +15,8 @@ class EosGetPublicKey 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)(types_1.GetPublicKey), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'showOnTrezor', type: 'boolean' },
-                { name: 'chunkify', type: 'boolean' },
-            ]);
             const path = (0, pathUtils_1.validatePath)(batch.path, 3);
             return {
                 address_n: path,

package/lib/api/eos/api/eosSignTransaction.js

@@ -6,16 +6,14 @@ const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const helper = tslib_1.__importStar(require("../eosSignTx"));
+const schema_utils_1 = require("@trezor/schema-utils");
+const eos_1 = require("../../../types/api/eos");
 class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('EOS'), this.firmwareRange);
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'path', required: true },
-            { name: 'transaction', required: true },
-            { name: 'chunkify', type: 'boolean' },
-        ]);
+        (0, schema_utils_1.Assert)(eos_1.EosSignTransaction, payload);
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);
         const { chain_id, header, ack } = helper.validate(payload.transaction);
         this.params = {

package/lib/api/eos/eosSignTx.d.ts

@@ -11,7 +11,165 @@ export declare const validate: (tx: EosSDKTransaction) => {
         max_cpu_usage_ms: number;
         delay_sec: number;
     };
-    ack: PROTO.EosTxActionAck[];
+    ack: {
+        transfer?: {
+            memo: string;
+            quantity: {
+                symbol: string;
+                amount: string | number;
+            };
+            sender: string;
+            receiver: string;
+        } | undefined;
+        refund?: {
+            owner: string;
+        } | undefined;
+        unknown?: {
+            data_size: number;
+            data_chunk: string;
+        } | undefined;
+        new_account?: {
+            name: string;
+            owner: {
+                keys: {
+                    type?: number | undefined;
+                    address_n?: number[] | undefined;
+                    weight: number;
+                    key: string;
+                }[];
+                threshold: number;
+                accounts: {
+                    weight: number;
+                    account: {
+                        permission: string;
+                        actor: string;
+                    };
+                }[];
+                waits: {
+                    weight: number;
+                    wait_sec: number;
+                }[];
+            };
+            creator: string;
+            active: {
+                keys: {
+                    type?: number | undefined;
+                    address_n?: number[] | undefined;
+                    weight: number;
+                    key: string;
+                }[];
+                threshold: number;
+                accounts: {
+                    weight: number;
+                    account: {
+                        permission: string;
+                        actor: string;
+                    };
+                }[];
+                waits: {
+                    weight: number;
+                    wait_sec: number;
+                }[];
+            };
+        } | undefined;
+        delegate?: {
+            transfer: boolean;
+            sender: string;
+            receiver: string;
+            net_quantity: {
+                symbol: string;
+                amount: string | number;
+            };
+            cpu_quantity: {
+                symbol: string;
+                amount: string | number;
+            };
+        } | undefined;
+        undelegate?: {
+            sender: string;
+            receiver: string;
+            net_quantity: {
+                symbol: string;
+                amount: string | number;
+            };
+            cpu_quantity: {
+                symbol: string;
+                amount: string | number;
+            };
+        } | undefined;
+        buy_ram?: {
+            quantity: {
+                symbol: string;
+                amount: string | number;
+            };
+            receiver: string;
+            payer: string;
+        } | undefined;
+        buy_ram_bytes?: {
+            bytes: number;
+            receiver: string;
+            payer: string;
+        } | undefined;
+        sell_ram?: {
+            bytes: number;
+            account: string;
+        } | undefined;
+        vote_producer?: {
+            voter: string;
+            proxy: string;
+            producers: string[];
+        } | undefined;
+        update_auth?: {
+            permission: string;
+            account: string;
+            parent: string;
+            auth: {
+                keys: {
+                    type?: number | undefined;
+                    address_n?: number[] | undefined;
+                    weight: number;
+                    key: string;
+                }[];
+                threshold: number;
+                accounts: {
+                    weight: number;
+                    account: {
+                        permission: string;
+                        actor: string;
+                    };
+                }[];
+                waits: {
+                    weight: number;
+                    wait_sec: number;
+                }[];
+            };
+        } | undefined;
+        delete_auth?: {
+            permission: string;
+            account: string;
+        } | undefined;
+        link_auth?: {
+            type: string;
+            account: string;
+            code: string;
+            requirement: string;
+        } | undefined;
+        unlink_auth?: {
+            type: string;
+            account: string;
+            code: string;
+        } | undefined;
+        common: {
+            name: string;
+            account: string;
+            authorization: {
+                permission: string;
+                actor: string;
+            }[];
+        };
+    }[];
 };
-export declare const signTx: (typedCall: TypedCall, address_n: number[], chain_id: string, header: PROTO.EosTxHeader, actions: PROTO.EosTxActionAck[], chunkify: boolean) => Promise<PROTO.EosSignedTx>;
+export declare const signTx: (typedCall: TypedCall, address_n: number[], chain_id: string, header: PROTO.EosTxHeader, actions: PROTO.EosTxActionAck[], chunkify: boolean) => Promise<{
+    signature: string;
+}>;
 //# sourceMappingURL=eosSignTx.d.ts.map

package/lib/api/ethereum/api/ethereumGetAddress.js

@@ -9,6 +9,9 @@ const formatUtils_1 = require("../../../utils/formatUtils");
 const constants_1 = require("../../../constants");
 const events_1 = require("../../../events");
 const ethereumDefinitions_1 = require("../ethereumDefinitions");
+const schema_utils_1 = require("@trezor/schema-utils");
+const types_1 = require("../../../types");
+const getAddress_1 = require("../../../types/api/getAddress");
 class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);
@@ -20,17 +23,8 @@ class EthereumGetAddress 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)(getAddress_1.GetAddress), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'address', type: 'string' },
-                { name: 'showOnTrezor', type: 'boolean' },
-                { name: 'chunkify', type: 'boolean' },
-            ]);
             const path = (0, pathUtils_1.validatePath)(batch.path, 3);
             const network = (0, coinInfo_1.getEthereumNetwork)(path);
             this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);

package/lib/api/ethereum/api/ethereumGetPublicKey.d.ts

@@ -10,7 +10,27 @@ export default class EthereumGetPublicKey extends AbstractMethod<'ethereumGetPub
     init(): void;
     get info(): string;
     confirmation(): Promise<boolean>;
-    run(): Promise<import("../../../types/api/getPublicKey").HDNodeResponse | import("../../../types/api/getPublicKey").HDNodeResponse[]>;
+    run(): Promise<{
+        xpubSegwit?: string | undefined;
+        path: number[];
+        publicKey: string;
+        serializedPath: string;
+        depth: number;
+        fingerprint: number;
+        chainCode: string;
+        childNum: number;
+        xpub: string;
+    } | {
+        xpubSegwit?: string | undefined;
+        path: number[];
+        publicKey: string;
+        serializedPath: string;
+        depth: number;
+        fingerprint: number;
+        chainCode: string;
+        childNum: number;
+        xpub: string;
+    }[]>;
 }
 export {};
 //# sourceMappingURL=ethereumGetPublicKey.d.ts.map

package/lib/api/ethereum/api/ethereumGetPublicKey.js

@@ -6,6 +6,8 @@ const pathUtils_1 = require("../../../utils/pathUtils");
 const ethereumUtils_1 = require("../../../utils/ethereumUtils");
 const coinInfo_1 = require("../../../data/coinInfo");
 const events_1 = require("../../../events");
+const schema_utils_1 = require("@trezor/schema-utils");
+const types_1 = require("../../../types");
 class EthereumGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
@@ -13,12 +15,8 @@ class EthereumGetPublicKey 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)(types_1.GetPublicKey), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'showOnTrezor', type: 'boolean' },
-            ]);
             const path = (0, pathUtils_1.validatePath)(batch.path, 3);
             const network = (0, coinInfo_1.getEthereumNetwork)(path);
             this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, network, this.firmwareRange);