@trezor/connect 9.0.0-beta.1

package/lib/api/cardanoGetAddress.js

@@ -0,0 +1,158 @@
+"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 cardanoAddressParameters_1 = require("./cardano/cardanoAddressParameters");
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+class CardanoGetAddress extends AbstractMethod_1.AbstractMethod {
+    constructor() {
+        super(...arguments);
+        this.progress = 0;
+    }
+    init() {
+        this.requiredPermissions = ['read'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
+        this.hasBundle = !!this.payload.bundle;
+        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: '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' },
+            ]);
+            (0, cardanoAddressParameters_1.validateAddressParameters)(batch.addressParameters);
+            return {
+                address_parameters: (0, cardanoAddressParameters_1.addressParametersToProto)(batch.addressParameters),
+                address: batch.address,
+                protocol_magic: batch.protocolMagic,
+                network_id: batch.networkId,
+                derivation_type: typeof batch.derivationType !== 'undefined'
+                    ? batch.derivationType
+                    : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+            };
+        });
+        const useEventListener = payload.useEventListener &&
+            this.params.length === 1 &&
+            typeof this.params[0].address === 'string' &&
+            this.params[0].show_display;
+        this.confirmed = useEventListener;
+        this.useUi = !useEventListener;
+        if (this.params.length === 1) {
+            this.info = `Export Cardano address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_parameters.address_n[2]) + 1}`;
+        }
+        else {
+            this.info = 'Export multiple Cardano addresses';
+        }
+    }
+    getButtonRequestData(code) {
+        if (code === 'ButtonRequest_Address') {
+            return {
+                type: 'address',
+                serializedPath: (0, pathUtils_1.getSerializedPath)(this.params[this.progress].address_parameters.address_n),
+                address: this.params[this.progress].address || 'not-set',
+            };
+        }
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'export-address',
+            label: this.info,
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async noBackupConfirmation() {
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'no-backup',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, }) {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('CardanoGetAddress', 'CardanoAddress', {
+            address_parameters,
+            protocol_magic,
+            network_id,
+            derivation_type,
+            show_display,
+        });
+        return response.message;
+    }
+    _ensureFirmwareSupportsBatch(batch) {
+        const SCRIPT_ADDRESSES_TYPES = [
+            constants_1.PROTO.CardanoAddressType.BASE_SCRIPT_KEY,
+            constants_1.PROTO.CardanoAddressType.BASE_KEY_SCRIPT,
+            constants_1.PROTO.CardanoAddressType.BASE_SCRIPT_SCRIPT,
+            constants_1.PROTO.CardanoAddressType.POINTER_SCRIPT,
+            constants_1.PROTO.CardanoAddressType.ENTERPRISE_SCRIPT,
+            constants_1.PROTO.CardanoAddressType.REWARD_SCRIPT,
+        ];
+        if (SCRIPT_ADDRESSES_TYPES.includes(batch.address_parameters.address_type)) {
+            if (!this.device.atLeast(['0', '2.4.3'])) {
+                throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Address type not supported by device firmware`);
+            }
+        }
+    }
+    async run() {
+        const responses = [];
+        for (let i = 0; i < this.params.length; i++) {
+            const batch = this.params[i];
+            this._ensureFirmwareSupportsBatch(batch);
+            batch.address_parameters = (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(this.device, batch.address_parameters);
+            if (batch.show_display) {
+                const silent = await this._call({
+                    ...batch,
+                    show_display: false,
+                });
+                if (typeof batch.address === 'string') {
+                    if (batch.address !== silent.address) {
+                        throw constants_1.ERRORS.TypedError('Method_AddressNotMatch');
+                    }
+                }
+                else {
+                    batch.address = silent.address;
+                }
+            }
+            const response = await this._call(batch);
+            responses.push({
+                addressParameters: (0, cardanoAddressParameters_1.addressParametersFromProto)(batch.address_parameters),
+                protocolMagic: batch.protocol_magic,
+                networkId: batch.network_id,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_parameters.address_n),
+                serializedStakingPath: (0, pathUtils_1.getSerializedPath)(batch.address_parameters.address_n_staking),
+                address: response.address,
+            });
+            if (this.hasBundle) {
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                    progress: i,
+                    response,
+                }));
+            }
+            this.progress++;
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = CardanoGetAddress;
+//# sourceMappingURL=cardanoGetAddress.js.map

package/lib/api/cardanoGetNativeScriptHash.d.ts

@@ -0,0 +1,12 @@
+import { PROTO } from '../constants';
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { CardanoNativeScript } from '../types/api/cardanoGetNativeScriptHash';
+export default class CardanoGetNativeScriptHash extends AbstractMethod<'cardanoGetNativeScriptHash', PROTO.CardanoGetNativeScriptHash> {
+    init(): void;
+    validateScript(script: CardanoNativeScript): void;
+    scriptToProto(script: CardanoNativeScript): PROTO.CardanoNativeScript;
+    run(): Promise<{
+        scriptHash: string;
+    }>;
+}
+//# sourceMappingURL=cardanoGetNativeScriptHash.d.ts.map

package/lib/api/cardanoGetNativeScriptHash.js

@@ -0,0 +1,79 @@
+"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");
+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);
+        this.info = 'Get Cardano native script hash';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'script', type: 'object', required: true },
+            { name: 'displayFormat', type: 'number', required: true },
+            { name: 'derivationType', type: 'number' },
+        ]);
+        this.validateScript(payload.script);
+        this.params = {
+            script: this.scriptToProto(payload.script),
+            display_format: payload.displayFormat,
+            derivation_type: typeof payload.derivationType !== 'undefined'
+                ? payload.derivationType
+                : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
+        };
+    }
+    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);
+        }
+        if (script.scripts) {
+            script.scripts.forEach(nestedScript => {
+                this.validateScript(nestedScript);
+            });
+        }
+    }
+    scriptToProto(script) {
+        let scripts = [];
+        if (script.scripts) {
+            scripts = script.scripts.map(nestedScript => this.scriptToProto(nestedScript));
+        }
+        let keyPath = [];
+        if (script.keyPath) {
+            keyPath = (0, pathUtils_1.validatePath)(script.keyPath, 3);
+        }
+        return {
+            type: script.type,
+            scripts,
+            key_hash: script.keyHash,
+            key_path: keyPath,
+            required_signatures_count: script.requiredSignaturesCount,
+            invalid_before: script.invalidBefore,
+            invalid_hereafter: script.invalidHereafter,
+        };
+    }
+    async run() {
+        const { message } = await this.device
+            .getCommands()
+            .typedCall('CardanoGetNativeScriptHash', 'CardanoNativeScriptHash', {
+            script: this.params.script,
+            display_format: this.params.display_format,
+            derivation_type: this.params.derivation_type,
+        });
+        return {
+            scriptHash: message.script_hash,
+        };
+    }
+}
+exports.default = CardanoGetNativeScriptHash;
+//# sourceMappingURL=cardanoGetNativeScriptHash.js.map

package/lib/api/cardanoGetPublicKey.d.ts

@@ -0,0 +1,10 @@
+import { PROTO } from '../constants';
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class CardanoGetPublicKey extends AbstractMethod<'cardanoGetPublicKey', PROTO.CardanoGetPublicKey[]> {
+    hasBundle?: boolean;
+    confirmed?: boolean;
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("../types/api/cardanoGetPublicKey").CardanoPublicKey | import("../types/api/cardanoGetPublicKey").CardanoPublicKey[]>;
+}
+//# sourceMappingURL=cardanoGetPublicKey.d.ts.map

package/lib/api/cardanoGetPublicKey.js

@@ -0,0 +1,78 @@
+"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");
+class CardanoGetPublicKey extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
+        this.info = 'Export Cardano public key';
+        this.hasBundle = !!this.payload.bundle;
+        const payload = !this.payload.bundle
+            ? { ...this.payload, bundle: [this.payload] }
+            : this.payload;
+        (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: 'derivationType', type: 'number' },
+                { name: 'showOnTrezor', type: 'boolean' },
+            ]);
+            const path = (0, pathUtils_1.validatePath)(batch.path, 3);
+            return {
+                address_n: path,
+                derivation_type: typeof batch.derivationType !== 'undefined'
+                    ? batch.derivationType
+                    : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
+            };
+        });
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        let label;
+        if (this.params.length > 1) {
+            label = 'Export multiple Cardano public keys';
+        }
+        else {
+            label = `Export Cardano public key for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
+        }
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'export-xpub',
+            label,
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async run() {
+        const responses = [];
+        const cmd = this.device.getCommands();
+        for (let i = 0; i < this.params.length; i++) {
+            const batch = this.params[i];
+            const { message } = await cmd.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', batch);
+            responses.push({
+                path: batch.address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
+                publicKey: message.xpub,
+                node: message.node,
+            });
+            if (this.hasBundle) {
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                    progress: i,
+                    response: message,
+                }));
+            }
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = CardanoGetPublicKey;
+//# sourceMappingURL=cardanoGetPublicKey.js.map

package/lib/api/cardanoSignTransaction.d.ts

@@ -0,0 +1,48 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { CertificateWithPoolOwnersAndRelays } from './cardano/cardanoCertificate';
+import type { Path, InputWithPath, CollateralInputWithPath } from './cardano/cardanoInputs';
+import type { OutputWithTokens } from './cardano/cardanoOutputs';
+import { PROTO } from '../constants';
+import type { CardanoSignedTxData } from '../types/api/cardanoSignTransaction';
+import type { AssetGroupWithTokens } from './cardano/cardanoTokenBundle';
+declare const CardanoSignTransactionFeatures: Readonly<{
+    TransactionStreaming: string[];
+    TokenMinting: string[];
+    Multisig: string[];
+    NetworkIdInTxBody: string[];
+    OutputDatumHash: string[];
+    ScriptDataHash: string[];
+    Plutus: string[];
+    KeyHashStakeCredential: string[];
+}>;
+export declare type CardanoSignTransactionParams = {
+    signingMode: PROTO.CardanoTxSigningMode;
+    inputsWithPath: InputWithPath[];
+    outputsWithTokens: OutputWithTokens[];
+    fee: PROTO.UintType;
+    ttl?: PROTO.UintType;
+    certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[];
+    withdrawals: PROTO.CardanoTxWithdrawal[];
+    mint: AssetGroupWithTokens[];
+    auxiliaryData?: PROTO.CardanoTxAuxiliaryData;
+    validityIntervalStart?: PROTO.UintType;
+    scriptDataHash?: string;
+    collateralInputsWithPath: CollateralInputWithPath[];
+    requiredSigners: PROTO.CardanoTxRequiredSigner[];
+    protocolMagic: number;
+    networkId: number;
+    witnessPaths: Path[];
+    additionalWitnessRequests: Path[];
+    derivationType: PROTO.CardanoDerivationType;
+    includeNetworkId?: boolean;
+};
+export default class CardanoSignTransaction extends AbstractMethod<'cardanoSignTransaction', CardanoSignTransactionParams> {
+    init(): void;
+    _isFeatureSupported(feature: keyof typeof CardanoSignTransactionFeatures): boolean;
+    _ensureFeatureIsSupported(feature: keyof typeof CardanoSignTransactionFeatures): void;
+    _ensureFirmwareSupportsParams(): void;
+    _sign_tx(): Promise<CardanoSignedTxData>;
+    run(): Promise<CardanoSignedTxData>;
+}
+export {};
+//# sourceMappingURL=cardanoSignTransaction.d.ts.map

package/lib/api/cardanoSignTransaction.js

@@ -0,0 +1,283 @@
+"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 CardanoSignTransactionFeatures = Object.freeze({
+    TransactionStreaming: ['0', '2.4.2'],
+    TokenMinting: ['0', '2.4.3'],
+    Multisig: ['0', '2.4.3'],
+    NetworkIdInTxBody: ['0', '2.4.4'],
+    OutputDatumHash: ['0', '2.4.4'],
+    ScriptDataHash: ['0', '2.4.4'],
+    Plutus: ['0', '2.4.4'],
+    KeyHashStakeCredential: ['0', '2.4.4'],
+});
+class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Cardano'), this.firmwareRange);
+        this.info = 'Sign Cardano transaction';
+        const { payload } = this;
+        if (payload.metadata) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Metadata field has been replaced by auxiliaryData.');
+        }
+        if (payload.auxiliaryData && payload.auxiliaryData.blob) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Auxiliary data can now only be sent as a hash.');
+        }
+        (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: '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' },
+        ]);
+        const inputsWithPath = payload.inputs.map(cardanoInputs_1.transformInput);
+        const outputsWithTokens = payload.outputs.map(cardanoOutputs_1.transformOutput);
+        let certificatesWithPoolOwnersAndRelays = [];
+        if (payload.certificates) {
+            certificatesWithPoolOwnersAndRelays = payload.certificates.map(cardanoCertificate_1.transformCertificate);
+        }
+        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,
+                };
+            });
+        }
+        let mint = [];
+        if (payload.mint) {
+            mint = (0, cardanoTokenBundle_1.tokenBundleToProto)(payload.mint);
+        }
+        let auxiliaryData;
+        if (payload.auxiliaryData) {
+            auxiliaryData = (0, cardanoAuxiliaryData_1.transformAuxiliaryData)(payload.auxiliaryData);
+        }
+        let additionalWitnessRequests = [];
+        if (payload.additionalWitnessRequests) {
+            additionalWitnessRequests = payload.additionalWitnessRequests.map(witnessRequest => (0, pathUtils_1.validatePath)(witnessRequest, 3));
+        }
+        let collateralInputsWithPath = [];
+        if (payload.collateralInputs) {
+            collateralInputsWithPath = payload.collateralInputs.map(cardanoInputs_1.transformCollateralInput);
+        }
+        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,
+                };
+            });
+        }
+        this.params = {
+            signingMode: payload.signingMode,
+            inputsWithPath,
+            outputsWithTokens,
+            fee: payload.fee,
+            ttl: payload.ttl,
+            certificatesWithPoolOwnersAndRelays,
+            withdrawals,
+            mint,
+            auxiliaryData,
+            validityIntervalStart: payload.validityIntervalStart,
+            scriptDataHash: payload.scriptDataHash,
+            collateralInputsWithPath,
+            requiredSigners,
+            protocolMagic: payload.protocolMagic,
+            networkId: payload.networkId,
+            witnessPaths: (0, cardanoWitnesses_1.gatherWitnessPaths)(inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, payload.signingMode),
+            additionalWitnessRequests,
+            derivationType: typeof payload.derivationType !== 'undefined'
+                ? payload.derivationType
+                : constants_1.PROTO.CardanoDerivationType.ICARUS_TREZOR,
+            includeNetworkId: payload.includeNetworkId,
+        };
+    }
+    _isFeatureSupported(feature) {
+        return this.device.atLeast(CardanoSignTransactionFeatures[feature]);
+    }
+    _ensureFeatureIsSupported(feature) {
+        if (!this._isFeatureSupported(feature)) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Feature ${feature} not supported by device firmware`);
+        }
+    }
+    _ensureFirmwareSupportsParams() {
+        const { params } = this;
+        this._ensureFeatureIsSupported('TransactionStreaming');
+        params.certificatesWithPoolOwnersAndRelays.forEach(({ certificate }) => {
+            if (certificate.key_hash) {
+                this._ensureFeatureIsSupported('KeyHashStakeCredential');
+            }
+        });
+        params.outputsWithTokens.forEach(({ output }) => {
+            if (output.datum_hash) {
+                this._ensureFeatureIsSupported('OutputDatumHash');
+            }
+        });
+        params.withdrawals.forEach(withdrawal => {
+            if (withdrawal.key_hash) {
+                this._ensureFeatureIsSupported('KeyHashStakeCredential');
+            }
+        });
+        if (params.mint.length > 0) {
+            this._ensureFeatureIsSupported('TokenMinting');
+        }
+        if (params.additionalWitnessRequests.length > 0 ||
+            params.signingMode === constants_1.PROTO.CardanoTxSigningMode.MULTISIG_TRANSACTION) {
+            this._ensureFeatureIsSupported('Multisig');
+        }
+        if (params.includeNetworkId) {
+            this._ensureFeatureIsSupported('NetworkIdInTxBody');
+        }
+        if (params.scriptDataHash) {
+            this._ensureFeatureIsSupported('ScriptDataHash');
+        }
+        if (params.signingMode === constants_1.PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
+            this._ensureFeatureIsSupported('Plutus');
+        }
+    }
+    async _sign_tx() {
+        const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
+        const hasAuxiliaryData = !!this.params.auxiliaryData;
+        const signTxInitMessage = {
+            signing_mode: this.params.signingMode,
+            protocol_magic: this.params.protocolMagic,
+            network_id: this.params.networkId,
+            inputs_count: this.params.inputsWithPath.length,
+            outputs_count: this.params.outputsWithTokens.length,
+            fee: this.params.fee,
+            ttl: this.params.ttl,
+            certificates_count: this.params.certificatesWithPoolOwnersAndRelays.length,
+            withdrawals_count: this.params.withdrawals.length,
+            has_auxiliary_data: hasAuxiliaryData,
+            validity_interval_start: this.params.validityIntervalStart,
+            witness_requests_count: this.params.witnessPaths.length,
+            minting_asset_groups_count: this.params.mint.length,
+            script_data_hash: this.params.scriptDataHash,
+            collateral_inputs_count: this.params.collateralInputsWithPath.length,
+            required_signers_count: this.params.requiredSigners.length,
+            derivation_type: this.params.derivationType,
+            include_network_id: this.params.includeNetworkId,
+        };
+        await typedCall('CardanoSignTxInit', 'CardanoTxItemAck', signTxInitMessage);
+        for (const { input } of this.params.inputsWithPath) {
+            await typedCall('CardanoTxInput', 'CardanoTxItemAck', input);
+        }
+        for (const { output, tokenBundle } of this.params.outputsWithTokens) {
+            await typedCall('CardanoTxOutput', 'CardanoTxItemAck', output);
+            if (tokenBundle) {
+                for (const assetGroup of tokenBundle) {
+                    await typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+                        policy_id: assetGroup.policyId,
+                        tokens_count: assetGroup.tokens.length,
+                    });
+                    for (const token of assetGroup.tokens) {
+                        await typedCall('CardanoToken', 'CardanoTxItemAck', token);
+                    }
+                }
+            }
+        }
+        for (const { certificate, poolOwners, poolRelays } of this.params
+            .certificatesWithPoolOwnersAndRelays) {
+            await typedCall('CardanoTxCertificate', 'CardanoTxItemAck', certificate);
+            for (const poolOwner of poolOwners) {
+                await typedCall('CardanoPoolOwner', 'CardanoTxItemAck', poolOwner);
+            }
+            for (const poolRelay of poolRelays) {
+                await typedCall('CardanoPoolRelayParameters', 'CardanoTxItemAck', poolRelay);
+            }
+        }
+        for (const withdrawal of this.params.withdrawals) {
+            await typedCall('CardanoTxWithdrawal', 'CardanoTxItemAck', withdrawal);
+        }
+        let auxiliaryDataSupplement;
+        if (this.params.auxiliaryData) {
+            const { catalyst_registration_parameters } = this.params.auxiliaryData;
+            if (catalyst_registration_parameters) {
+                this.params.auxiliaryData = (0, cardanoAuxiliaryData_1.modifyAuxiliaryDataForBackwardsCompatibility)(this.device, this.params.auxiliaryData);
+            }
+            const { message } = await typedCall('CardanoTxAuxiliaryData', 'CardanoTxAuxiliaryDataSupplement', this.params.auxiliaryData);
+            const auxiliaryDataType = constants_1.PROTO.CardanoTxAuxiliaryDataSupplementType[message.type];
+            if (auxiliaryDataType !== constants_1.PROTO.CardanoTxAuxiliaryDataSupplementType.NONE) {
+                auxiliaryDataSupplement = {
+                    type: auxiliaryDataType,
+                    auxiliaryDataHash: message.auxiliary_data_hash,
+                    catalystSignature: message.catalyst_signature,
+                };
+            }
+            await typedCall('CardanoTxHostAck', 'CardanoTxItemAck');
+        }
+        if (this.params.mint.length > 0) {
+            await typedCall('CardanoTxMint', 'CardanoTxItemAck', {
+                asset_groups_count: this.params.mint.length,
+            });
+            for (const assetGroup of this.params.mint) {
+                await typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+                    policy_id: assetGroup.policyId,
+                    tokens_count: assetGroup.tokens.length,
+                });
+                for (const token of assetGroup.tokens) {
+                    await typedCall('CardanoToken', 'CardanoTxItemAck', token);
+                }
+            }
+        }
+        for (const { collateralInput } of this.params.collateralInputsWithPath) {
+            await typedCall('CardanoTxCollateralInput', 'CardanoTxItemAck', collateralInput);
+        }
+        for (const requiredSigner of this.params.requiredSigners) {
+            await typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
+        }
+        const witnesses = [];
+        for (const path of this.params.witnessPaths) {
+            const { message } = await typedCall('CardanoTxWitnessRequest', 'CardanoTxWitnessResponse', { path });
+            witnesses.push({
+                type: constants_1.PROTO.CardanoTxWitnessType[message.type],
+                pubKey: message.pub_key,
+                signature: message.signature,
+                chainCode: message.chain_code,
+            });
+        }
+        const { message: txBodyHashMessage } = await typedCall('CardanoTxHostAck', 'CardanoTxBodyHash');
+        await typedCall('CardanoTxHostAck', 'CardanoSignTxFinished');
+        return { hash: txBodyHashMessage.tx_hash, witnesses, auxiliaryDataSupplement };
+    }
+    run() {
+        this._ensureFirmwareSupportsParams();
+        return this._sign_tx();
+    }
+}
+exports.default = CardanoSignTransaction;
+//# sourceMappingURL=cardanoSignTransaction.js.map