@trezor/connect 9.1.9 → 9.1.11

package/lib/api/getAccountInfo.d.ts

@@ -21,19 +21,19 @@ export default class GetAccountInfo extends AbstractMethod<'getAccountInfo', Req
         balance: string;
         availableBalance: string;
         empty: boolean;
-        tokens?: import("packages/blockchain-link-types/lib/common").TokenInfo[] | undefined;
-        addresses?: import("packages/blockchain-link-types/lib/common").AccountAddresses | undefined;
+        tokens?: import("@trezor/blockchain-link-types/lib/common").TokenInfo[] | undefined;
+        addresses?: import("@trezor/blockchain-link-types/lib/common").AccountAddresses | undefined;
         history: {
             total: number;
             tokens?: number | undefined;
             unconfirmed: number;
-            transactions?: import("packages/blockchain-link-types/lib/common").Transaction[] | undefined;
+            transactions?: import("@trezor/blockchain-link-types/lib/common").Transaction[] | undefined;
             txids?: string[] | undefined;
             addrTxCount?: number | undefined;
         };
         misc?: {
             nonce?: string | undefined;
-            erc20Contract?: import("packages/blockchain-link-types/lib/common").TokenInfo | undefined;
+            erc20Contract?: import("@trezor/blockchain-link-types/lib/common").TokenInfo | undefined;
             sequence?: number | undefined;
             reserve?: string | undefined;
             rewards?: string | undefined;
@@ -62,19 +62,19 @@ export default class GetAccountInfo extends AbstractMethod<'getAccountInfo', Req
         balance: string;
         availableBalance: string;
         empty: boolean;
-        tokens?: import("packages/blockchain-link-types/lib/common").TokenInfo[] | undefined;
-        addresses?: import("packages/blockchain-link-types/lib/common").AccountAddresses | undefined;
+        tokens?: import("@trezor/blockchain-link-types/lib/common").TokenInfo[] | undefined;
+        addresses?: import("@trezor/blockchain-link-types/lib/common").AccountAddresses | undefined;
         history: {
             total: number;
             tokens?: number | undefined;
             unconfirmed: number;
-            transactions?: import("packages/blockchain-link-types/lib/common").Transaction[] | undefined;
+            transactions?: import("@trezor/blockchain-link-types/lib/common").Transaction[] | undefined;
             txids?: string[] | undefined;
             addrTxCount?: number | undefined;
         };
         misc?: {
             nonce?: string | undefined;
-            erc20Contract?: import("packages/blockchain-link-types/lib/common").TokenInfo | undefined;
+            erc20Contract?: import("@trezor/blockchain-link-types/lib/common").TokenInfo | undefined;
             sequence?: number | undefined;
             reserve?: string | undefined;
             rewards?: string | undefined;

package/lib/api/getAddress.d.ts

@@ -1,6 +1,6 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 import { PROTO } from '../constants';
-import type { BitcoinNetworkInfo } from '../types';
+import { type BitcoinNetworkInfo } from '../types';
 type Params = PROTO.GetAddress & {
     address?: string;
     coinInfo: BitcoinNetworkInfo;
@@ -24,7 +24,13 @@ export default class GetAddress extends AbstractMethod<'getAddress', Params[]> {
         serializedPath: string;
         address: string;
     }>;
-    run(): Promise<(import("../types").Address & PROTO.Address) | (import("../types").Address & PROTO.Address)[]>;
+    run(): Promise<(import("../types").Address & {
+        mac?: string | undefined;
+        address: string;
+    }) | (import("../types").Address & {
+        mac?: string | undefined;
+        address: string;
+    })[]>;
 }
 export {};
 //# sourceMappingURL=getAddress.d.ts.map

package/lib/api/getAddress.js

@@ -6,6 +6,9 @@ const pathUtils_1 = require("../utils/pathUtils");
 const coinInfo_1 = require("../data/coinInfo");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
+const types_1 = require("../types");
+const schema_utils_1 = require("@trezor/schema-utils");
+const getAddress_1 = require("../types/api/getAddress");
 class GetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);
@@ -17,27 +20,14 @@ class GetAddress 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' },
-        ]);
-        this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'coin', type: 'string' },
-                { name: 'address', type: 'string' },
-                { name: 'showOnTrezor', type: 'boolean' },
-                { name: 'multisig', type: 'object' },
-                { name: 'scriptType', type: 'string' },
-                { name: 'unlockPath', type: 'object' },
-                { name: 'chunkify', type: 'boolean' },
-            ]);
-            if (batch.unlockPath) {
-                (0, paramsValidator_1.validateParams)(batch.unlockPath, [
-                    { name: 'address_n', required: true, type: 'array' },
-                    { name: 'mac', required: true, type: 'string' },
-                ]);
+        payload === null || payload === void 0 ? void 0 : payload.bundle.forEach(bundleElement => {
+            var _a, _b;
+            if (bundleElement.multisig && ((_a = bundleElement.multisig) === null || _a === void 0 ? void 0 : _a.signatures) === undefined) {
+                bundleElement.multisig.signatures = Array((_b = bundleElement.multisig) === null || _b === void 0 ? void 0 : _b.pubkeys.length).fill('');
             }
+        });
+        (0, schema_utils_1.Assert)((0, types_1.Bundle)(getAddress_1.GetAddress), payload);
+        this.params = payload.bundle.map(batch => {
             const path = (0, pathUtils_1.validatePath)(batch.path, 1);
             let coinInfo;
             if (batch.coin) {

package/lib/api/getCoinInfo.d.ts

@@ -1,11 +1,126 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { CoinInfo } from '../types';
+import { CoinInfo } from '../types';
 type Params = {
     coinInfo: CoinInfo;
 };
 export default class GetCoinInfo extends AbstractMethod<'getCoinInfo', Params> {
     init(): void;
-    run(): Promise<CoinInfo>;
+    run(): Promise<({
+        blockchainLink?: {
+            type: string;
+            url: string[];
+        } | undefined;
+        name: string;
+        label: string;
+        blockTime: number;
+        minFee: number;
+        maxFee: number;
+        shortcut: string;
+        slip44: number;
+        support: {
+            T1B1: string | false;
+            T2T1: string | false;
+            T2B1: string | false;
+            connect: boolean;
+        };
+        decimals: number;
+        defaultFees: {
+            feeLimit?: string | undefined;
+            feePerTx?: string | undefined;
+            label: "high" | "normal" | "economy" | "low" | "custom";
+            feePerUnit: string;
+            blocks: number;
+        }[];
+    } & {
+        cashAddrPrefix?: string | undefined;
+        xPubMagicSegwitNative?: number | undefined;
+        xPubMagicSegwit?: number | undefined;
+        taproot?: boolean | undefined;
+        type: "bitcoin";
+        dustLimit: number;
+        curveName: string;
+        forceBip143: boolean;
+        hashGenesisBlock: string;
+        maxAddressLength: number;
+        maxFeeSatoshiKb: number;
+        minAddressLength: number;
+        minFeeSatoshiKb: number;
+        segwit: boolean;
+        xPubMagic: number;
+        network: {
+            forkId?: number | undefined;
+            messagePrefix: string;
+            bech32: string;
+            bip32: {
+                public: number;
+                private: number;
+            };
+            pubKeyHash: number;
+            scriptHash: number;
+            wif: number;
+        };
+        isBitcoin: boolean;
+    }) | ({
+        blockchainLink?: {
+            type: string;
+            url: string[];
+        } | undefined;
+        name: string;
+        label: string;
+        blockTime: number;
+        minFee: number;
+        maxFee: number;
+        shortcut: string;
+        slip44: number;
+        support: {
+            T1B1: string | false;
+            T2T1: string | false;
+            T2B1: string | false;
+            connect: boolean;
+        };
+        decimals: number;
+        defaultFees: {
+            feeLimit?: string | undefined;
+            feePerTx?: string | undefined;
+            label: "high" | "normal" | "economy" | "low" | "custom";
+            feePerUnit: string;
+            blocks: number;
+        }[];
+    } & {
+        network?: undefined;
+        type: "ethereum";
+        chainId: number;
+    }) | ({
+        blockchainLink?: {
+            type: string;
+            url: string[];
+        } | undefined;
+        name: string;
+        label: string;
+        blockTime: number;
+        minFee: number;
+        maxFee: number;
+        shortcut: string;
+        slip44: number;
+        support: {
+            T1B1: string | false;
+            T2T1: string | false;
+            T2B1: string | false;
+            connect: boolean;
+        };
+        decimals: number;
+        defaultFees: {
+            feeLimit?: string | undefined;
+            feePerTx?: string | undefined;
+            label: "high" | "normal" | "economy" | "low" | "custom";
+            feePerUnit: string;
+            blocks: number;
+        }[];
+    } & {
+        network?: undefined;
+        type: "nem" | "misc";
+        curve: string;
+    })>;
 }
 export {};
 //# sourceMappingURL=getCoinInfo.d.ts.map

package/lib/api/getCoinInfo.js

@@ -1,16 +1,17 @@
 "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 coinInfo_1 = require("../data/coinInfo");
+const types_1 = require("../types");
+const schema_utils_1 = require("@trezor/schema-utils");
 class GetCoinInfo 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/getFeatures.d.ts

@@ -1,6 +1,54 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 export default class GetFeatures extends AbstractMethod<'getFeatures'> {
     init(): void;
-    run(): Promise<import("packages/protobuf/lib/messages").Features>;
+    run(): Promise<{
+        hide_passphrase_from_host?: boolean | undefined;
+        _passphrase_cached?: boolean | undefined;
+        busy?: boolean | undefined;
+        homescreen_format?: "Toif" | "Jpeg" | "ToiG" | undefined;
+        unit_color?: number | undefined;
+        unit_btconly?: boolean | undefined;
+        homescreen_width?: number | undefined;
+        homescreen_height?: number | undefined;
+        bootloader_locked?: boolean | undefined;
+        flags: number | null;
+        language: string | null;
+        label: string | null;
+        auto_lock_delay_ms: number | null;
+        display_rotation: number | null;
+        passphrase_always_on_device: boolean | null;
+        safety_checks: "Strict" | "PromptAlways" | "PromptTemporarily" | null;
+        experimental_features: boolean | null;
+        vendor: string;
+        major_version: number;
+        minor_version: number;
+        patch_version: number;
+        bootloader_mode: boolean | null;
+        device_id: string | null;
+        pin_protection: boolean | null;
+        passphrase_protection: boolean | null;
+        initialized: boolean | null;
+        revision: string | null;
+        bootloader_hash: string | null;
+        imported: boolean | null;
+        unlocked: boolean | null;
+        firmware_present: boolean | null;
+        needs_backup: boolean | null;
+        model: string;
+        fw_major: number | null;
+        fw_minor: number | null;
+        fw_patch: number | null;
+        fw_vendor: string | null;
+        unfinished_backup: boolean | null;
+        no_backup: boolean | null;
+        recovery_mode: boolean | null;
+        capabilities: ("Capability_Bitcoin" | "Capability_Bitcoin_like" | "Capability_Binance" | "Capability_Cardano" | "Capability_Crypto" | "Capability_EOS" | "Capability_Ethereum" | "Capability_Lisk" | "Capability_Monero" | "Capability_NEM" | "Capability_Ripple" | "Capability_Stellar" | "Capability_Tezos" | "Capability_U2F" | "Capability_Shamir" | "Capability_ShamirGroups" | "Capability_PassphraseEntry" | "Capability_Solana")[];
+        backup_type: "Bip39" | "Slip39_Basic" | "Slip39_Advanced" | null;
+        sd_card_present: boolean | null;
+        sd_protection: boolean | null;
+        wipe_code_protection: boolean | null;
+        session_id: string | null;
+        internal_model: import("@trezor/protobuf/lib/messages-schema").DeviceModelInternal;
+    }>;
 }
 //# sourceMappingURL=getFeatures.d.ts.map

package/lib/api/getFirmwareHash.d.ts

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

package/lib/api/getFirmwareHash.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const AbstractMethod_1 = require("../core/AbstractMethod");
+const constants_1 = require("../constants");
 const events_1 = require("../events");
 const paramsValidator_1 = require("./common/paramsValidator");
+const schema_utils_1 = require("@trezor/schema-utils");
 class GetFirmwareHash extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['management'];
@@ -10,7 +12,7 @@ class GetFirmwareHash extends AbstractMethod_1.AbstractMethod {
         this.useDeviceState = false;
         this.allowDeviceMode = [events_1.UI.INITIALIZE];
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [{ name: 'challenge', type: 'string' }]);
+        (0, schema_utils_1.Assert)(constants_1.PROTO.GetFirmwareHash, payload);
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, null, this.firmwareRange);
         this.params = {
             challenge: payload.challenge,

package/lib/api/getOwnershipId.js

@@ -5,6 +5,9 @@ const paramsValidator_1 = require("./common/paramsValidator");
 const pathUtils_1 = require("../utils/pathUtils");
 const coinInfo_1 = require("../data/coinInfo");
 const events_1 = require("../events");
+const schema_utils_1 = require("@trezor/schema-utils");
+const exports_1 = require("../exports");
+const getOwnershipId_1 = require("../types/api/getOwnershipId");
 class GetOwnershipId extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
@@ -12,14 +15,8 @@ class GetOwnershipId 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, exports_1.Bundle)(getOwnershipId_1.GetOwnershipId), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'coin', type: 'string' },
-                { name: 'multisig', type: 'object' },
-                { name: 'scriptType', type: 'string' },
-            ]);
             const address_n = (0, pathUtils_1.validatePath)(batch.path, 1);
             const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(batch.coin || address_n);
             const script_type = batch.scriptType || (0, pathUtils_1.getScriptType)(address_n);

package/lib/api/getOwnershipProof.js

@@ -5,6 +5,9 @@ const paramsValidator_1 = require("./common/paramsValidator");
 const pathUtils_1 = require("../utils/pathUtils");
 const coinInfo_1 = require("../data/coinInfo");
 const events_1 = require("../events");
+const schema_utils_1 = require("@trezor/schema-utils");
+const exports_1 = require("../exports");
+const getOwnershipProof_1 = require("../types/api/getOwnershipProof");
 class GetOwnershipProof extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
@@ -12,18 +15,8 @@ class GetOwnershipProof 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, exports_1.Bundle)(getOwnershipProof_1.GetOwnershipProof), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'coin', type: 'string' },
-                { name: 'multisig', type: 'object' },
-                { name: 'scriptType', type: 'string' },
-                { name: 'userConfirmation', type: 'boolean' },
-                { name: 'ownershipIds', type: 'array' },
-                { name: 'commitmentData', type: 'string' },
-                { name: 'preauthorized', type: 'boolean' },
-            ]);
             const address_n = (0, pathUtils_1.validatePath)(batch.path, 1);
             const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(batch.coin || address_n);
             const script_type = batch.scriptType || (0, pathUtils_1.getScriptType)(address_n);

package/lib/api/getPublicKey.d.ts

@@ -13,7 +13,27 @@ export default class GetPublicKey extends AbstractMethod<'getPublicKey', Params[
     get info(): string;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(allowSuppression?: boolean): 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=getPublicKey.d.ts.map

package/lib/api/getPublicKey.js

@@ -6,6 +6,9 @@ const pathUtils_1 = require("../utils/pathUtils");
 const events_1 = require("../events");
 const coinInfo_1 = require("../data/coinInfo");
 const accountUtils_1 = require("../utils/accountUtils");
+const schema_utils_1 = require("@trezor/schema-utils");
+const types_1 = require("../types");
+const getPublicKey_1 = require("../types/api/getPublicKey");
 class GetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];
@@ -13,25 +16,8 @@ class GetPublicKey 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)(getPublicKey_1.GetPublicKey), payload);
         this.params = payload.bundle.map(batch => {
-            (0, paramsValidator_1.validateParams)(batch, [
-                { name: 'path', required: true },
-                { name: 'coin', type: 'string' },
-                { name: 'crossChain', type: 'boolean' },
-                { name: 'showOnTrezor', type: 'boolean' },
-                { name: 'scriptType', type: ['string', 'number'] },
-                { name: 'ignoreXpubMagic', type: 'boolean' },
-                { name: 'ecdsaCurveName', type: 'boolean' },
-                { name: 'unlockPath', type: 'object' },
-                { name: 'suppressBackupWarning', type: 'boolean' },
-            ]);
-            if (batch.unlockPath) {
-                (0, paramsValidator_1.validateParams)(batch.unlockPath, [
-                    { name: 'address_n', required: true, type: 'array' },
-                    { name: 'mac', required: true, type: 'string' },
-                ]);
-            }
             let coinInfo;
             if (batch.coin) {
                 coinInfo = (0, coinInfo_1.getBitcoinNetwork)(batch.coin);

package/lib/api/nem/api/nemGetAddress.d.ts

@@ -16,8 +16,10 @@ export default class NEMGetAddress extends AbstractMethod<'nemGetAddress', Param
     } | undefined;
     confirmation(): Promise<boolean>;
     noBackupConfirmation(): Promise<boolean>;
-    _call({ address_n, network, show_display, chunkify }: Params): Promise<PROTO.NEMAddress>;
-    run(): Promise<import("../../..").Address | import("../../..").Address[]>;
+    _call({ address_n, network, show_display, chunkify }: Params): Promise<{
+        address: string;
+    }>;
+    run(): Promise<import("../../../types").Address | import("../../../types").Address[]>;
 }
 export {};
 //# sourceMappingURL=nemGetAddress.d.ts.map

package/lib/api/nem/api/nemGetAddress.js

@@ -6,6 +6,9 @@ const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const constants_1 = require("../../../constants");
 const events_1 = require("../../../events");
+const schema_utils_1 = require("@trezor/schema-utils");
+const types_1 = require("../../../types");
+const getAddress_1 = require("../../../types/api/getAddress");
 const MAINNET = 0x68;
 const TESTNET = 0x98;
 const MIJIN = 0x60;
@@ -21,18 +24,8 @@ class NEMGetAddress 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: 'network', type: 'number' },
-                { name: 'showOnTrezor', type: 'boolean' },
-                { name: 'chunkify', type: 'boolean' },
-            ]);
             const path = (0, pathUtils_1.validatePath)(batch.path, 3);
             return {
                 address_n: path,

package/lib/api/nem/api/nemSignTransaction.d.ts

@@ -3,6 +3,9 @@ import type { PROTO } from '../../../constants';
 export default class NEMSignTransaction extends AbstractMethod<'nemSignTransaction', PROTO.NEMSignTx> {
     init(): void;
     get info(): string;
-    run(): Promise<PROTO.NEMSignedTx>;
+    run(): Promise<{
+        signature: string;
+        data: string;
+    }>;
 }
 //# sourceMappingURL=nemSignTransaction.d.ts.map

package/lib/api/nem/api/nemSignTransaction.js

@@ -6,16 +6,18 @@ const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
 const pathUtils_1 = require("../../../utils/pathUtils");
 const helper = tslib_1.__importStar(require("../nemSignTx"));
+const schema_utils_1 = require("@trezor/schema-utils");
+const nem_1 = require("../../../types/api/nem");
 class NEMSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
+        var _a;
         this.requiredPermissions = ['read', 'write'];
         this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('NEM'), this.firmwareRange);
         const { payload } = this;
-        (0, paramsValidator_1.validateParams)(payload, [
-            { name: 'path', required: true },
-            { name: 'transaction', required: true },
-            { name: 'chunkify', type: 'boolean' },
-        ]);
+        if ((_a = payload === null || payload === void 0 ? void 0 : payload.transaction) === null || _a === void 0 ? void 0 : _a.timestamp) {
+            payload.transaction.timeStamp = payload.transaction.timestamp;
+        }
+        (0, schema_utils_1.AssertWeak)(nem_1.NEMSignTransaction, payload);
         const path = (0, pathUtils_1.validatePath)(payload.path, 3);
         this.params = helper.createTx(payload.transaction, path, payload.chunkify);
     }

package/lib/api/nem/nemSignTx.d.ts

@@ -1,4 +1,78 @@
 import { PROTO } from '../../constants';
 import * as $T from '../../types/api/nem';
-export declare const createTx: (tx: $T.NEMTransaction, address_n: number[], chunkify?: boolean) => PROTO.NEMSignTx;
+export declare const createTx: (tx: $T.NEMTransaction, address_n: number[], chunkify?: boolean) => {
+    chunkify?: boolean | undefined;
+    transfer?: {
+        payload?: string | undefined;
+        public_key?: string | undefined;
+        mosaics?: {
+            quantity: number;
+            namespace: string;
+            mosaic: string;
+        }[] | undefined;
+        amount: string | number;
+        recipient: string;
+    } | undefined;
+    multisig?: {
+        address_n?: number[] | undefined;
+        network?: number | undefined;
+        signer?: string | undefined;
+        timestamp: number;
+        fee: string | number;
+        deadline: number;
+    } | undefined;
+    cosigning?: boolean | undefined;
+    provision_namespace?: {
+        parent?: string | undefined;
+        fee: string | number;
+        namespace: string;
+        sink: string;
+    } | undefined;
+    mosaic_creation?: {
+        fee: string | number;
+        sink: string;
+        definition: {
+            name?: string | undefined;
+            fee?: string | number | undefined;
+            levy?: PROTO.NEMMosaicLevy | undefined;
+            divisibility?: number | undefined;
+            transferable?: boolean | undefined;
+            ticker?: string | undefined;
+            levy_address?: string | undefined;
+            levy_namespace?: string | undefined;
+            levy_mosaic?: string | undefined;
+            supply?: number | undefined;
+            mutable_supply?: boolean | undefined;
+            networks?: number[] | undefined;
+            description: string;
+            namespace: string;
+            mosaic: string;
+        };
+    } | undefined;
+    supply_change?: {
+        type: PROTO.NEMSupplyChangeType;
+        delta: number;
+        namespace: string;
+        mosaic: string;
+    } | undefined;
+    aggregate_modification?: {
+        modifications?: {
+            type: PROTO.NEMModificationType;
+            public_key: string;
+        }[] | undefined;
+        relative_change?: number | undefined;
+    } | undefined;
+    importance_transfer?: {
+        public_key: string;
+        mode: PROTO.NEMImportanceTransferMode;
+    } | undefined;
+    transaction: {
+        address_n?: number[] | undefined;
+        network?: number | undefined;
+        signer?: string | undefined;
+        timestamp: number;
+        fee: string | number;
+        deadline: number;
+    };
+};
 //# sourceMappingURL=nemSignTx.d.ts.map