@trezor/connect 9.1.4 → 9.1.6

package/lib/api/{cardanoGetPublicKey.js → cardano/api/cardanoGetPublicKey.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const constants_1 = require("../constants");
-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 events_1 = require("../events");
+const constants_1 = require("../../../constants");
+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 events_1 = require("../../../events");
 class CardanoGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];

package/lib/api/{cardanoSignTransaction.d.ts → cardano/api/cardanoSignTransaction.d.ts}

@@ -1,10 +1,10 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import type { CertificateWithPoolOwnersAndRelays } from './cardano/cardanoCertificate';
-import { Path, InputWithPath, CollateralInputWithPath } from './cardano/cardanoInputs';
-import type { OutputWithData } from './cardano/cardanoOutputs';
-import { PROTO } from '../constants';
-import type { CardanoSignedTxData } from '../types/api/cardano';
-import type { AssetGroupWithTokens } from './cardano/cardanoTokenBundle';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+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 { AssetGroupWithTokens } from '../cardanoTokenBundle';
 declare const CardanoSignTransactionFeatures: Readonly<{
     TransactionStreaming: string[];
     TokenMinting: string[];
@@ -41,6 +41,11 @@ export type CardanoSignTransactionParams = {
     additionalWitnessRequests: Path[];
     derivationType: PROTO.CardanoDerivationType;
     includeNetworkId?: boolean;
+    unsignedTx?: {
+        body: string;
+        hash: string;
+    };
+    testnet?: boolean;
 };
 export default class CardanoSignTransaction extends AbstractMethod<'cardanoSignTransaction', CardanoSignTransactionParams> {
     init(): void;
@@ -49,7 +54,12 @@ export default class CardanoSignTransaction extends AbstractMethod<'cardanoSignT
     _ensureFeatureIsSupported(feature: keyof typeof CardanoSignTransactionFeatures): void;
     _ensureFirmwareSupportsParams(): void;
     _sign_tx(): Promise<CardanoSignedTxData>;
-    run(): Promise<CardanoSignedTxData>;
+    run(): Promise<CardanoSignedTxData | {
+        serializedTx: string;
+        hash: string;
+        witnesses: CardanoSignedTxWitness[];
+        auxiliaryDataSupplement?: CardanoAuxiliaryDataSupplement | undefined;
+    }>;
 }
 export {};
 //# sourceMappingURL=cardanoSignTransaction.d.ts.map

package/lib/api/{cardanoSignTransaction.js → cardano/api/cardanoSignTransaction.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 coinInfo_1 = require("../data/coinInfo");
-const pathUtils_1 = require("../utils/pathUtils");
-const cardanoAuxiliaryData_1 = require("./cardano/cardanoAuxiliaryData");
-const cardanoCertificate_1 = require("./cardano/cardanoCertificate");
-const cardanoInputs_1 = require("./cardano/cardanoInputs");
-const cardanoOutputs_1 = require("./cardano/cardanoOutputs");
-const constants_1 = require("../constants");
-const cardanoWitnesses_1 = require("./cardano/cardanoWitnesses");
-const cardanoTokenBundle_1 = require("./cardano/cardanoTokenBundle");
+const coin_selection_1 = require("@fivebinaries/coin-selection");
+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 cardanoAuxiliaryData_1 = require("../cardanoAuxiliaryData");
+const cardanoCertificate_1 = require("../cardanoCertificate");
+const cardanoInputs_1 = require("../cardanoInputs");
+const cardanoOutputs_1 = require("../cardanoOutputs");
+const constants_1 = require("../../../constants");
+const cardanoWitnesses_1 = require("../cardanoWitnesses");
+const cardanoTokenBundle_1 = require("../cardanoTokenBundle");
 const CardanoSignTransactionFeatures = Object.freeze({
     TransactionStreaming: ['0', '2.4.2'],
     TokenMinting: ['0', '2.4.3'],
@@ -65,6 +66,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             { name: 'additionalWitnessRequests', type: 'array', allowEmpty: true },
             { name: 'derivationType', type: 'number' },
             { name: 'includeNetworkId', type: 'boolean' },
+            { name: 'unsignedTx', type: 'object' },
+            { name: 'testnet', type: 'boolean' },
         ]);
         const inputsWithPath = payload.inputs.map(cardanoInputs_1.transformInput);
         const outputsWithData = payload.outputs.map(cardanoOutputs_1.transformOutput);
@@ -148,6 +151,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
                 ? payload.derivationType
                 : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
             includeNetworkId: payload.includeNetworkId,
+            unsignedTx: 'unsignedTx' in payload ? payload.unsignedTx : undefined,
+            testnet: 'testnet' in payload ? payload.testnet : undefined,
         };
     }
     get info() {
@@ -329,9 +334,21 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         await typedCall('CardanoTxHostAck', 'CardanoSignTxFinished');
         return { hash: txBodyHashMessage.tx_hash, witnesses, auxiliaryDataSupplement };
     }
-    run() {
+    async run() {
         this._ensureFirmwareSupportsParams();
-        return this._sign_tx();
+        const result = await this._sign_tx();
+        if (!this.params.unsignedTx)
+            return result;
+        const { unsignedTx, testnet } = this.params;
+        const { hash, witnesses } = result;
+        if (hash !== unsignedTx.hash) {
+            throw constants_1.ERRORS.TypedError('Runtime', "Constructed transaction doesn't match the hash returned by the device.");
+        }
+        const serializedTx = coin_selection_1.trezorUtils.signTransaction(unsignedTx.body, witnesses, { testnet });
+        return {
+            ...result,
+            serializedTx,
+        };
     }
 }
 exports.default = CardanoSignTransaction;

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

@@ -0,0 +1,6 @@
+export { default as cardanoGetAddress } from './cardanoGetAddress';
+export { default as cardanoGetNativeScriptHash } from './cardanoGetNativeScriptHash';
+export { default as cardanoGetPublicKey } from './cardanoGetPublicKey';
+export { default as cardanoSignTransaction } from './cardanoSignTransaction';
+export { default as cardanoComposeTransaction } from './cardanoComposeTransaction';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cardanoComposeTransaction = exports.cardanoSignTransaction = exports.cardanoGetPublicKey = exports.cardanoGetNativeScriptHash = exports.cardanoGetAddress = void 0;
+var cardanoGetAddress_1 = require("./cardanoGetAddress");
+Object.defineProperty(exports, "cardanoGetAddress", { enumerable: true, get: function () { return __importDefault(cardanoGetAddress_1).default; } });
+var cardanoGetNativeScriptHash_1 = require("./cardanoGetNativeScriptHash");
+Object.defineProperty(exports, "cardanoGetNativeScriptHash", { enumerable: true, get: function () { return __importDefault(cardanoGetNativeScriptHash_1).default; } });
+var cardanoGetPublicKey_1 = require("./cardanoGetPublicKey");
+Object.defineProperty(exports, "cardanoGetPublicKey", { enumerable: true, get: function () { return __importDefault(cardanoGetPublicKey_1).default; } });
+var cardanoSignTransaction_1 = require("./cardanoSignTransaction");
+Object.defineProperty(exports, "cardanoSignTransaction", { enumerable: true, get: function () { return __importDefault(cardanoSignTransaction_1).default; } });
+var cardanoComposeTransaction_1 = require("./cardanoComposeTransaction");
+Object.defineProperty(exports, "cardanoComposeTransaction", { enumerable: true, get: function () { return __importDefault(cardanoComposeTransaction_1).default; } });
+//# sourceMappingURL=index.js.map

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

@@ -1,3 +1,9 @@
+import { types } from '@fivebinaries/coin-selection';
+import { AccountUtxo, CardanoCertificate } from '../../types';
+export declare const transformUtxos: (utxos: AccountUtxo[]) => types.Utxo[];
+export declare const prepareCertificates: (certs: CardanoCertificate[]) => types.Certificate[];
+export declare const getTtl: (testnet: boolean) => number;
+export declare const composeTxPlan: (descriptor: string, utxo: AccountUtxo[], outputs: types.UserOutput[], certificates: CardanoCertificate[], withdrawals: types.Withdrawal[], changeAddress: string, isTestnet: boolean, options?: types.Options) => types.PrecomposedTransaction;
 export declare const hexStringByteLength: (s: string) => number;
 export declare const sendChunkedHexString: (typedCall: any, data: string, chunkSize: number, messageType: string) => Promise<void>;
 //# sourceMappingURL=cardanoUtils.d.ts.map

package/lib/api/cardano/cardanoUtils.js

@@ -1,6 +1,69 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sendChunkedHexString = exports.hexStringByteLength = void 0;
+exports.sendChunkedHexString = exports.hexStringByteLength = exports.composeTxPlan = exports.getTtl = exports.prepareCertificates = exports.transformUtxos = void 0;
+const coin_selection_1 = require("@fivebinaries/coin-selection");
+const constants_1 = require("../../constants");
+const CARDANO_DEFAULT_TTL_OFFSET = 7200;
+const transformUtxos = (utxos) => {
+    const result = [];
+    utxos === null || utxos === void 0 ? void 0 : utxos.forEach(utxo => {
+        const foundItem = result.find(res => res.txHash === utxo.txid && res.outputIndex === utxo.vout);
+        if (utxo.cardanoSpecific) {
+            if (!foundItem) {
+                result.push({
+                    address: utxo.address,
+                    txHash: utxo.txid,
+                    outputIndex: utxo.vout,
+                    amount: [{ quantity: utxo.amount, unit: utxo.cardanoSpecific.unit }],
+                });
+            }
+            else {
+                foundItem.amount.push({ quantity: utxo.amount, unit: utxo.cardanoSpecific.unit });
+            }
+        }
+    });
+    return result;
+};
+exports.transformUtxos = transformUtxos;
+const prepareCertificates = (certs) => {
+    const convertedCerts = [];
+    certs.forEach(cert => {
+        switch (cert.type) {
+            case constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION:
+                convertedCerts.push({
+                    type: cert.type,
+                    pool: cert.pool,
+                });
+                break;
+            case constants_1.PROTO.CardanoCertificateType.STAKE_REGISTRATION:
+            case constants_1.PROTO.CardanoCertificateType.STAKE_DEREGISTRATION:
+                convertedCerts.push({
+                    type: cert.type,
+                });
+                break;
+        }
+    });
+    return convertedCerts;
+};
+exports.prepareCertificates = prepareCertificates;
+const getTtl = (testnet) => {
+    const shelleySlot = testnet ? 6192449 : 4924800;
+    const shelleyTimestamp = testnet ? 1672848449 : 1596491091;
+    const currentTimestamp = Math.floor(new Date().getTime() / 1000);
+    const currentSlot = shelleySlot + currentTimestamp - shelleyTimestamp;
+    return currentSlot + CARDANO_DEFAULT_TTL_OFFSET;
+};
+exports.getTtl = getTtl;
+const composeTxPlan = (descriptor, utxo, outputs, certificates, withdrawals, changeAddress, isTestnet, options) => (0, coin_selection_1.coinSelection)({
+    utxos: (0, exports.transformUtxos)(utxo),
+    outputs,
+    changeAddress,
+    certificates: (0, exports.prepareCertificates)(certificates),
+    withdrawals,
+    accountPubKey: descriptor,
+    ttl: (0, exports.getTtl)(isTestnet),
+}, options);
+exports.composeTxPlan = composeTxPlan;
 const hexStringByteLength = (s) => s.length / 2;
 exports.hexStringByteLength = hexStringByteLength;
 const sendChunkedHexString = async (typedCall, data, chunkSize, messageType) => {

package/lib/api/checkFirmwareAuthenticity.js

@@ -14,15 +14,17 @@ class CheckFirmwareAuthenticity extends AbstractMethod_1.AbstractMethod {
         this.useDeviceState = false;
     }
     async run() {
+        var _a;
         const { device } = this;
-        const deviceVersion = `${device.features.major_version}.${device.features.minor_version}.${device.features.patch_version}`;
-        const releases = (0, firmwareInfo_1.getReleases)(device.features.major_version);
-        const release = releases.find(release => release.version.join('.') === deviceVersion);
+        const firmwareVersion = `${device.features.major_version}.${device.features.minor_version}.${device.features.patch_version}`;
+        const releases = (0, firmwareInfo_1.getReleases)((_a = device.features) === null || _a === void 0 ? void 0 : _a.internal_model);
+        const release = releases.find(release => release.version.join('.') === firmwareVersion);
         if (!release) {
             throw constants_1.ERRORS.TypedError('Runtime', 'checkFirmwareAuthenticity: No release found for device firmware');
         }
-        const baseUrl = `https://data.trezor.io/firmware/${device.features.major_version}`;
-        const fwUrl = `${baseUrl}/trezor-${deviceVersion}${device.firmwareType === types_1.FirmwareType.BitcoinOnly ? '-bitcoinonly.bin' : '.bin'}`;
+        const deviceModelPath = `${device.features.internal_model}`.toLowerCase();
+        const baseUrl = `https://data.trezor.io/firmware/${deviceModelPath}`;
+        const fwUrl = `${baseUrl}/trezor-${deviceModelPath}-${firmwareVersion}${device.firmwareType === types_1.FirmwareType.BitcoinOnly ? '-bitcoinonly.bin' : '.bin'}`;
         const fw = await (0, assets_1.httpRequest)(fwUrl, 'binary');
         if (!fw) {
             throw constants_1.ERRORS.TypedError('Runtime', 'checkFirmwareAuthenticity: firmware binary not found');

package/lib/api/common/paramsValidator.js

@@ -68,25 +68,22 @@ const validateCoinPath = (path, coinInfo) => {
 };
 exports.validateCoinPath = validateCoinPath;
 const getFirmwareRange = (method, coinInfo, currentRange) => {
-    const current = JSON.parse(JSON.stringify(currentRange));
+    const range = JSON.parse(JSON.stringify(currentRange));
+    const models = Object.keys(range);
     if (coinInfo) {
-        if (!coinInfo.support || typeof coinInfo.support.trezor1 !== 'string') {
-            current['1'].min = '0';
-        }
-        else if (utils_1.versionUtils.isNewer(coinInfo.support.trezor1, current['1'].min)) {
-            current['1'].min = coinInfo.support.trezor1;
-        }
-        if (!coinInfo.support || typeof coinInfo.support.trezor2 !== 'string') {
-            current['2'].min = '0';
-        }
-        else if (utils_1.versionUtils.isNewer(coinInfo.support.trezor2, current['2'].min)) {
-            current['2'].min = coinInfo.support.trezor2;
-        }
+        models.forEach(model => {
+            if (!coinInfo.support || typeof coinInfo.support[model] !== 'string') {
+                range[model].min = '0';
+            }
+            else if (range[model].min !== '0' &&
+                utils_1.versionUtils.isNewer(coinInfo.support[model], range[model].min)) {
+                range[model].min = coinInfo.support[model];
+            }
+        });
     }
-    const coinType = coinInfo ? coinInfo.type : null;
-    const shortcut = coinInfo ? coinInfo.shortcut.toLowerCase() : null;
-    const { supportedFirmware } = config_1.config;
-    const ranges = supportedFirmware
+    const coinType = coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.type;
+    const shortcut = coinInfo === null || coinInfo === void 0 ? void 0 : coinInfo.shortcut.toLowerCase();
+    const configRules = config_1.config.supportedFirmware
         .filter(rule => {
         if (rule.methods) {
             return rule.methods.includes(method);
@@ -96,45 +93,42 @@ const getFirmwareRange = (method, coinInfo, currentRange) => {
         }
         return true;
     })
-        .filter(c => {
-        if (c.coinType) {
-            return c.coinType === coinType;
+        .filter(rule => {
+        if (rule.coinType) {
+            return rule.coinType === coinType;
         }
-        if (c.coin) {
-            return (typeof c.coin === 'string' ? [c.coin] : c.coin).includes(shortcut);
+        if (rule.coin) {
+            return (typeof rule.coin === 'string' ? [rule.coin] : rule.coin).includes(shortcut);
         }
-        return c.methods || c.capabilities;
+        return rule.methods || rule.capabilities;
     });
-    ranges.forEach(range => {
-        const { min, max } = range;
-        if (min) {
-            const [t1, t2] = min;
-            if (t1 === '0' ||
-                current['1'].min === '0' ||
-                !utils_1.versionUtils.isNewerOrEqual(current['1'].min, t1)) {
-                current['1'].min = t1;
-            }
-            if (t2 === '0' ||
-                current['2'].min === '0' ||
-                !utils_1.versionUtils.isNewerOrEqual(current['2'].min, t2)) {
-                current['2'].min = t2;
-            }
-        }
-        if (max) {
-            const [t1, t2] = max;
-            if (t1 === '0' ||
-                current['1'].max === '0' ||
-                !utils_1.versionUtils.isNewerOrEqual(current['1'].max, t1)) {
-                current['1'].max = t1;
-            }
-            if (t2 === '0' ||
-                current['2'].max === '0' ||
-                !utils_1.versionUtils.isNewerOrEqual(current['2'].max, t2)) {
-                current['2'].max = t2;
-            }
+    configRules.forEach(rule => {
+        if (rule.min) {
+            models.forEach(model => {
+                const modelMin = rule.min[model];
+                if (modelMin) {
+                    if (modelMin === '0' ||
+                        range[model].min === '0' ||
+                        !utils_1.versionUtils.isNewerOrEqual(range[model].min, modelMin)) {
+                        range[model].min = modelMin;
+                    }
+                }
+            });
+        }
+        if (rule.max) {
+            models.forEach(model => {
+                const modelMax = rule.max[model];
+                if (modelMax) {
+                    if (modelMax === '0' ||
+                        range[model].max === '0' ||
+                        !utils_1.versionUtils.isNewerOrEqual(range[model].max, modelMax)) {
+                        range[model].max = modelMax;
+                    }
+                }
+            });
         }
     });
-    return current;
+    return range;
 };
 exports.getFirmwareRange = getFirmwareRange;
 //# sourceMappingURL=paramsValidator.js.map

package/lib/api/composeTransaction.d.ts

@@ -2,9 +2,9 @@ import BigNumber from 'bignumber.js';
 import { AbstractMethod } from '../core/AbstractMethod';
 import { Discovery } from './common/Discovery';
 import { TransactionComposer } from './bitcoin';
-import type { ComposeOutput, ComposeResult } from '@trezor/utxo-lib';
+import type { ComposeOutput } from '@trezor/utxo-lib';
 import type { BitcoinNetworkInfo, DiscoveryAccount, AccountUtxo } from '../types';
-import type { SignedTransaction, PrecomposeParams, PrecomposedTransaction } from '../types/api/composeTransaction';
+import type { SignedTransaction, PrecomposeParams, ComposeResult, PrecomposedResult } from '../types/api/composeTransaction';
 type Params = {
     outputs: ComposeOutput[];
     coinInfo: BitcoinNetworkInfo;
@@ -21,13 +21,13 @@ export default class ComposeTransaction extends AbstractMethod<'composeTransacti
     discovery?: Discovery;
     init(): void;
     get info(): string;
-    precompose(account: PrecomposeParams['account'], feeLevels: PrecomposeParams['feeLevels']): Promise<PrecomposedTransaction[]>;
-    run(): Promise<SignedTransaction | PrecomposedTransaction[]>;
+    precompose(account: PrecomposeParams['account'], feeLevels: PrecomposeParams['feeLevels']): Promise<PrecomposedResult[]>;
+    run(): Promise<SignedTransaction | PrecomposedResult[]>;
     selectAccount(): Promise<{
         account: DiscoveryAccount;
         utxo: AccountUtxo[];
     }>;
-    selectFee(account: DiscoveryAccount, utxo: AccountUtxo[]): Promise<SignedTransaction | "change-account">;
+    selectFee(account: DiscoveryAccount, utxos: AccountUtxo[]): Promise<SignedTransaction | "change-account">;
     _selectFeeUiResponse(composer: TransactionComposer): Promise<SignedTransaction | 'change-account'>;
     _sign(tx: ComposeResult): Promise<import("../types").SignedTransaction>;
     dispose(): void;

package/lib/api/composeTransaction.js

@@ -77,7 +77,7 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
                 address_n,
                 addresses: account.addresses,
             },
-            utxo: account.utxo,
+            utxos: account.utxo,
             coinInfo,
             outputs,
             baseFee,
@@ -89,21 +89,16 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
             composer.composeCustomFee(level.feePerUnit);
             const tx = { ...composer.composed.custom };
             if (tx.type === 'final') {
-                const inputs = tx.transaction.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence || 0xffffffff));
-                const { sorted, permutation } = tx.transaction.outputs;
-                const txOutputs = sorted.map(out => (0, bitcoin_1.outputToTrezor)(out, coinInfo));
                 return {
-                    type: 'final',
-                    max: tx.max,
-                    totalSpent: tx.totalSpent,
-                    fee: tx.fee,
-                    feePerByte: tx.feePerByte,
-                    bytes: tx.bytes,
-                    transaction: {
-                        inputs,
-                        outputs: txOutputs,
-                        outputsPermutation: permutation,
-                    },
+                    ...tx,
+                    inputs: tx.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence)),
+                    outputs: tx.outputs.map(bitcoin_1.outputToTrezor),
+                };
+            }
+            if (tx.type === 'nonfinal') {
+                return {
+                    ...tx,
+                    inputs: tx.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence)),
                 };
             }
             return tx;
@@ -184,12 +179,12 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
             utxo,
         };
     }
-    async selectFee(account, utxo) {
+    async selectFee(account, utxos) {
         const { coinInfo, outputs } = this.params;
         const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage);
         const composer = new bitcoin_1.TransactionComposer({
             account,
-            utxo,
+            utxos,
             coinInfo,
             outputs,
         });
@@ -227,8 +222,8 @@ class ComposeTransaction extends AbstractMethod_1.AbstractMethod {
             throw constants_1.ERRORS.TypedError('Runtime', 'ComposeTransaction: Trying to sign unfinished tx');
         const { coinInfo } = this.params;
         const options = (0, bitcoin_1.enhanceSignTx)({}, coinInfo);
-        const inputs = tx.transaction.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence || 0xffffffff));
-        const outputs = tx.transaction.outputs.sorted.map(out => (0, bitcoin_1.outputToTrezor)(out, coinInfo));
+        const inputs = tx.inputs.map(inp => (0, bitcoin_1.inputToTrezor)(inp, this.params.sequence));
+        const outputs = tx.outputs.map(bitcoin_1.outputToTrezor);
         let refTxs = [];
         const requiredRefTxs = (0, bitcoin_1.requireReferencedTransactions)(inputs, options, coinInfo);
         const refTxsIds = (0, bitcoin_1.getReferencedTransactions)(inputs);

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

@@ -0,0 +1,11 @@
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { PROTO } from '../../../constants';
+export default class EosGetPublicKey extends AbstractMethod<'eosGetPublicKey', PROTO.EosGetPublicKey[]> {
+    hasBundle?: boolean;
+    confirmed?: boolean;
+    init(): void;
+    get info(): string;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("../../..").EosPublicKey | import("../../..").EosPublicKey[]>;
+}
+//# sourceMappingURL=eosGetPublicKey.d.ts.map

package/lib/api/{eosGetPublicKey.js → eos/api/eosGetPublicKey.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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 events_1 = require("../events");
+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 events_1 = require("../../../events");
 class EosGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];

package/lib/api/{eosSignTransaction.d.ts → eos/api/eosSignTransaction.d.ts}

@@ -1,5 +1,5 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import type { PROTO } from '../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { PROTO } from '../../../constants';
 type Params = {
     path: number[];
     chain_id: string;

package/lib/api/{eosSignTransaction.js → eos/api/eosSignTransaction.js}

@@ -1,11 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-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 helper = tslib_1.__importStar(require("./eos/eosSignTx"));
+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 helper = tslib_1.__importStar(require("../eosSignTx"));
 class EosSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];

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

@@ -0,0 +1,3 @@
+export { default as eosGetPublicKey } from './eosGetPublicKey';
+export { default as eosSignTransaction } from './eosSignTransaction';
+//# sourceMappingURL=index.d.ts.map

package/lib/api/eos/api/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.eosSignTransaction = exports.eosGetPublicKey = void 0;
+var eosGetPublicKey_1 = require("./eosGetPublicKey");
+Object.defineProperty(exports, "eosGetPublicKey", { enumerable: true, get: function () { return __importDefault(eosGetPublicKey_1).default; } });
+var eosSignTransaction_1 = require("./eosSignTransaction");
+Object.defineProperty(exports, "eosSignTransaction", { enumerable: true, get: function () { return __importDefault(eosSignTransaction_1).default; } });
+//# sourceMappingURL=index.js.map

package/lib/api/{ethereumGetAddress.d.ts → ethereum/api/ethereumGetAddress.d.ts}

@@ -1,6 +1,6 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { PROTO } from '../constants';
-import type { EthereumNetworkInfo } from '../types';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import { PROTO } from '../../../constants';
+import type { EthereumNetworkInfo } from '../../../types';
 type Params = PROTO.EthereumGetAddress & {
     address?: string;
     network?: EthereumNetworkInfo;
@@ -25,7 +25,7 @@ export default class EthereumGetAddress extends AbstractMethod<'ethereumGetAddre
         serializedPath: string;
         address: string;
     }>;
-    run(): Promise<import("../types").Address | import("../types").Address[]>;
+    run(): Promise<import("../../../types").Address | import("../../../types").Address[]>;
 }
 export {};
 //# sourceMappingURL=ethereumGetAddress.d.ts.map

package/lib/api/{ethereumGetAddress.js → ethereum/api/ethereumGetAddress.js}

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const pathUtils_1 = require("../utils/pathUtils");
-const ethereumUtils_1 = require("../utils/ethereumUtils");
-const coinInfo_1 = require("../data/coinInfo");
-const formatUtils_1 = require("../utils/formatUtils");
-const constants_1 = require("../constants");
-const events_1 = require("../events");
-const ethereumDefinitions_1 = require("./ethereum/ethereumDefinitions");
+const AbstractMethod_1 = require("../../../core/AbstractMethod");
+const paramsValidator_1 = require("../../common/paramsValidator");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const ethereumUtils_1 = require("../../../utils/ethereumUtils");
+const coinInfo_1 = require("../../../data/coinInfo");
+const formatUtils_1 = require("../../../utils/formatUtils");
+const constants_1 = require("../../../constants");
+const events_1 = require("../../../events");
+const ethereumDefinitions_1 = require("../ethereumDefinitions");
 class EthereumGetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);

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

@@ -0,0 +1,16 @@
+import { AbstractMethod } from '../../../core/AbstractMethod';
+import type { PROTO } from '../../../constants';
+import type { EthereumNetworkInfo } from '../../../types';
+type Params = PROTO.EthereumGetPublicKey & {
+    network?: EthereumNetworkInfo;
+};
+export default class EthereumGetPublicKey extends AbstractMethod<'ethereumGetPublicKey', Params[]> {
+    hasBundle?: boolean;
+    confirmed?: boolean;
+    init(): void;
+    get info(): string;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("../../../types/api/getPublicKey").HDNodeResponse | import("../../../types/api/getPublicKey").HDNodeResponse[]>;
+}
+export {};
+//# sourceMappingURL=ethereumGetPublicKey.d.ts.map