@onekeyfe/hd-core 0.2.8 → 0.2.9

package/dist/index.js

@@ -108,6 +108,9 @@ const inject = ({ call, cancel, dispose, eventEmitter, init, uiResponse, }) => {
         suiGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'suiGetAddress' })),
         suiGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'suiGetPublicKey' })),
         suiSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'suiSignTransaction' })),
+        cardanoGetAddress: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cardanoGetAddress' })),
+        cardanoGetPublicKey: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cardanoGetPublicKey' })),
+        cardanoSignTransaction: (connectId, deviceId, params) => call(Object.assign(Object.assign({}, params), { connectId, deviceId, method: 'cardanoSignTransaction' })),
     };
     return api;
 };
@@ -2833,6 +2836,45 @@ var nested = {
 				rule: "required",
 				type: "CardanoDerivationType",
 				id: 14
+			},
+			include_network_id: {
+				type: "bool",
+				id: 15,
+				options: {
+					"default": false
+				}
+			},
+			script_data_hash: {
+				type: "bytes",
+				id: 16
+			},
+			collateral_inputs_count: {
+				rule: "required",
+				type: "uint32",
+				id: 17
+			},
+			required_signers_count: {
+				rule: "required",
+				type: "uint32",
+				id: 18
+			},
+			has_collateral_return: {
+				type: "bool",
+				id: 19,
+				options: {
+					"default": false
+				}
+			},
+			total_collateral: {
+				type: "uint64",
+				id: 20
+			},
+			reference_inputs_count: {
+				type: "uint32",
+				id: 21,
+				options: {
+					"default": 0
+				}
 			}
 		}
 	},
@@ -11839,6 +11881,9 @@ class Device extends events.exports {
             if (internalState) {
                 payload.session_id = internalState;
             }
+            if (options === null || options === void 0 ? void 0 : options.deriveCardano) {
+                payload.derive_cardano = true;
+            }
             Log$5.debug('initialize payload:', payload);
             const { message } = yield this.commands.typedCall('Initialize', 'Features', payload);
             this._updateFeatures(message, options === null || options === void 0 ? void 0 : options.initSession);
@@ -12135,8 +12180,10 @@ class BaseMethod {
         if (!this.device || !this.device.features)
             return;
         const inputPinOnSoftware = supportInputPinOnSoftware(this.device.features);
+        const modifyHomescreen = supportModifyHomescreen(this.device.features);
         this.postMessage(createDeviceMessage(DEVICE.SUPPORT_FEATURES, {
             inputPinOnSoftware,
+            modifyHomescreen,
             device: this.device.toMessageObject(),
         }));
     }
@@ -12403,6 +12450,15 @@ const validateParams = (values, fields) => {
                         throw invalidParameter(`Parameter "${field.name}" is empty.`);
                     }
                     break;
+                case 'uint':
+                    if (typeof value !== 'string' && typeof value !== 'number') {
+                        throw invalidParameter(`Parameter [${field.name}] has invalid type. "string|number" expected.`);
+                    }
+                    if ((typeof value === 'number' && !Number.isSafeInteger(value)) ||
+                        !/^(?:[1-9]\d*|\d)$/.test(value.toString().replace(/^-/, field.allowNegative ? '' : '-'))) {
+                        throw invalidParameter(`Parameter [${field.name}] has invalid value "${value}". Integer representation expected.`);
+                    }
+                    break;
                 case 'bigNumber':
                     if (typeof value !== 'string') {
                         throw invalidParameter(`Parameter [${field.name}] is of type invalid and should be [string].`);
@@ -12791,7 +12847,6 @@ const getInfo = ({ features, updateType }) => {
     return findLatestRelease(releaseInfo);
 };
 
-getLogger(exports.LoggerNames.Device);
 const postConfirmationMessage = (device) => {
     var _a;
     if ((_a = device.features) === null || _a === void 0 ? void 0 : _a.firmware_present) {
@@ -13848,7 +13903,7 @@ const saveTxSignatures = (serializedTx, signatures, txRequest) => {
     }
     if (typeof signature_index === 'number') {
         if (!signature) {
-            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in trezor:TxRequestSerialized signature.');
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.RuntimeError, 'saveTxSignatures: Unexpected null in oneKey:TxRequestSerialized signature.');
         }
         signatures[signature_index] = signature;
     }
@@ -16441,6 +16496,794 @@ class SuiSignTransaction extends BaseMethod {
     }
 }
 
+const safeThrowError = (error) => {
+    if (error instanceof hdShared.HardwareError) {
+        throw error;
+    }
+    else if (error.code === 'ERR_NETWORK') {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNotInstalled);
+    }
+    else if (error.code === 'ECONNABORTED') {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
+    }
+    else {
+        throw hdShared.ERRORS.TypedError(error);
+    }
+};
+
+const validateAddressParameters = (addressParameters) => {
+    validateParams(addressParameters, [
+        { name: 'addressType', type: 'number', required: true },
+        { name: 'stakingKeyHash', type: 'string' },
+        { name: 'paymentScriptHash', type: 'string' },
+        { name: 'stakingScriptHash', type: 'string' },
+    ]);
+    if (addressParameters.path) {
+        validatePath(addressParameters.path);
+    }
+    if (addressParameters.stakingPath) {
+        validatePath(addressParameters.stakingPath);
+    }
+    if (addressParameters.certificatePointer) {
+        validateParams(addressParameters.certificatePointer, [
+            { name: 'blockIndex', type: 'number', required: true },
+            { name: 'txIndex', type: 'number', required: true },
+            { name: 'certificateIndex', type: 'number', required: true },
+        ]);
+    }
+};
+const addressParametersToProto = (addressParameters) => {
+    let path = [];
+    if (addressParameters.path) {
+        path = validatePath(addressParameters.path, 3);
+    }
+    let stakingPath = [];
+    if (addressParameters.stakingPath) {
+        stakingPath = validatePath(addressParameters.stakingPath, 3);
+    }
+    let certificatePointer;
+    if (addressParameters.certificatePointer) {
+        certificatePointer = {
+            block_index: addressParameters.certificatePointer.blockIndex,
+            tx_index: addressParameters.certificatePointer.txIndex,
+            certificate_index: addressParameters.certificatePointer.certificateIndex,
+        };
+    }
+    return {
+        address_type: addressParameters.addressType,
+        address_n: path,
+        address_n_staking: stakingPath,
+        staking_key_hash: addressParameters.stakingKeyHash,
+        certificate_pointer: certificatePointer,
+        script_payment_hash: addressParameters.paymentScriptHash,
+        script_staking_hash: addressParameters.stakingScriptHash,
+    };
+};
+const addressParametersFromProto = (addressParameters) => {
+    let certificatePointer;
+    if (addressParameters.certificate_pointer) {
+        certificatePointer = {
+            blockIndex: addressParameters.certificate_pointer.block_index,
+            txIndex: addressParameters.certificate_pointer.tx_index,
+            certificateIndex: addressParameters.certificate_pointer.certificate_index,
+        };
+    }
+    return {
+        addressType: addressParameters.address_type,
+        path: addressParameters.address_n,
+        stakingPath: addressParameters.address_n_staking,
+        stakingKeyHash: addressParameters.staking_key_hash,
+        certificatePointer,
+    };
+};
+const modifyAddressParametersForBackwardsCompatibility = (address_parameters) => {
+    if (address_parameters.address_type === hdTransport.Messages.CardanoAddressType.REWARD) {
+        let { address_n, address_n_staking } = address_parameters;
+        if (address_n.length > 0 && address_n_staking.length > 0) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Only stakingPath is allowed for CardanoAddressType.REWARD`);
+        }
+        if (address_n.length > 0) {
+            address_n_staking = address_n;
+            address_n = [];
+        }
+        return Object.assign(Object.assign({}, address_parameters), { address_n,
+            address_n_staking });
+    }
+    return address_parameters;
+};
+
+class CardanoGetAddress extends BaseMethod {
+    init() {
+        var _a;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        this.params = payload.bundle.map((batch) => {
+            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' },
+            ]);
+            validateAddressParameters(batch.addressParameters);
+            return {
+                address_parameters: addressParametersToProto(batch.addressParameters),
+                address: batch.address,
+                protocol_magic: batch.protocolMagic,
+                network_id: batch.networkId,
+                derivation_type: typeof batch.derivationType !== 'undefined'
+                    ? batch.derivationType
+                    : hdTransport.Messages.CardanoDerivationType.ICARUS_TREZOR,
+                show_display: typeof batch.showOnOneKey === 'boolean' ? !!batch.showOneKey : true,
+            };
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            for (const batch of this.params) {
+                const { address_parameters, protocol_magic, network_id, derivation_type, show_display } = batch;
+                const response = yield this.device.commands.typedCall('CardanoGetAddress', 'CardanoAddress', {
+                    address_parameters,
+                    protocol_magic,
+                    network_id,
+                    derivation_type,
+                    show_display,
+                });
+                const publicKeyRes = yield this.device.commands.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', {
+                    address_n: address_parameters.address_n.slice(0, 3),
+                    derivation_type,
+                    show_display,
+                });
+                responses.push({
+                    addressParameters: addressParametersFromProto(batch.address_parameters),
+                    protocolMagic: batch.protocol_magic,
+                    networkId: batch.network_id,
+                    serializedPath: serializedPath(batch.address_parameters.address_n),
+                    serializedStakingPath: serializedPath(batch.address_parameters.address_n_staking),
+                    address: response.message.address,
+                    xpub: publicKeyRes.message.xpub,
+                });
+            }
+            return this.hasBundle ? responses : responses[0];
+        });
+    }
+}
+
+class CardanoGetPublicKey extends BaseMethod {
+    init() {
+        var _a;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const payload = this.hasBundle ? this.payload : { bundle: [this.payload] };
+        validateParams(payload, [{ name: 'bundle', type: 'array' }]);
+        this.params = payload.bundle.map((batch) => {
+            validateParams(batch, [
+                { name: 'path', required: true },
+                { name: 'derivationType', type: 'number' },
+                { name: 'showOnTrezor', type: 'boolean' },
+            ]);
+            const path = validatePath(batch.path, 3);
+            return {
+                address_n: path,
+                derivation_type: typeof batch.derivationType !== 'undefined'
+                    ? batch.derivationType
+                    : hdTransport.Messages.CardanoDerivationType.ICARUS_TREZOR,
+                show_display: typeof batch.showOnOneKey === 'boolean' ? batch.showOnOneKey : false,
+            };
+        });
+    }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const responses = [];
+            const cmd = this.device.getCommands();
+            for (let i = 0; i < this.params.length; i++) {
+                const batch = this.params[i];
+                const { message } = yield cmd.typedCall('CardanoGetPublicKey', 'CardanoPublicKey', batch);
+                responses.push({
+                    path: batch.address_n,
+                    serializedPath: serializedPath(batch.address_n),
+                    publicKey: message.xpub,
+                    node: message.node,
+                });
+            }
+            return this.hasBundle ? responses : responses[0];
+        });
+    }
+}
+
+const transformInput = (input) => {
+    validateParams(input, [
+        { name: 'prev_hash', type: 'string', required: true },
+        { name: 'prev_index', type: 'number', required: true },
+    ]);
+    return {
+        input: {
+            prev_hash: input.prev_hash,
+            prev_index: input.prev_index,
+        },
+        path: input.path ? validatePath(input.path, 5) : undefined,
+    };
+};
+const transformCollateralInput = (collateralInput) => {
+    validateParams(collateralInput, [
+        { name: 'prev_hash', type: 'string', required: true },
+        { name: 'prev_index', type: 'number', required: true },
+    ]);
+    return {
+        collateralInput: {
+            prev_hash: collateralInput.prev_hash,
+            prev_index: collateralInput.prev_index,
+        },
+        path: collateralInput.path ? validatePath(collateralInput.path, 5) : undefined,
+    };
+};
+const transformReferenceInput = (referenceInput) => {
+    validateParams(referenceInput, [
+        { name: 'prev_hash', type: 'string', required: true },
+        { name: 'prev_index', type: 'number', required: true },
+    ]);
+    return {
+        prev_hash: referenceInput.prev_hash,
+        prev_index: referenceInput.prev_index,
+    };
+};
+
+const validateTokens = (tokenAmounts) => {
+    tokenAmounts.forEach(tokenAmount => {
+        validateParams(tokenAmount, [
+            { name: 'assetNameBytes', type: 'string', required: true },
+            { name: 'amount', type: 'uint' },
+            { name: 'mintAmount', type: 'uint', allowNegative: true },
+        ]);
+    });
+};
+const validateTokenBundle = (tokenBundle) => {
+    tokenBundle.forEach(tokenGroup => {
+        validateParams(tokenGroup, [
+            { name: 'policyId', type: 'string', required: true },
+            { name: 'tokenAmounts', type: 'array', required: true },
+        ]);
+        validateTokens(tokenGroup.tokenAmounts);
+    });
+};
+const tokenBundleToProto = (tokenBundle) => {
+    validateTokenBundle(tokenBundle);
+    return tokenBundle.map(tokenGroup => ({
+        policyId: tokenGroup.policyId,
+        tokens: tokenAmountsToProto(tokenGroup.tokenAmounts),
+    }));
+};
+const tokenAmountsToProto = (tokenAmounts) => tokenAmounts.map(tokenAmount => ({
+    asset_name_bytes: tokenAmount.assetNameBytes,
+    amount: tokenAmount.amount,
+    mint_amount: tokenAmount.mintAmount,
+}));
+
+const hexStringByteLength = (s) => s.length / 2;
+const sendChunkedHexString = (typedCall, data, chunkSize, messageType) => __awaiter(void 0, void 0, void 0, function* () {
+    let processedSize = 0;
+    while (processedSize < data.length) {
+        const chunk = data.slice(processedSize, processedSize + chunkSize);
+        yield typedCall(messageType, 'CardanoTxItemAck', {
+            data: chunk,
+        });
+        processedSize += chunkSize;
+    }
+});
+
+const transformOutput = (output) => {
+    validateParams(output, [
+        { name: 'address', type: 'string' },
+        { name: 'amount', type: 'uint', required: true },
+        { name: 'tokenBundle', type: 'array', allowEmpty: true },
+        { name: 'datumHash', type: 'string' },
+        { name: 'format', type: 'number' },
+        { name: 'inlineDatum', type: 'string' },
+        { name: 'referenceScript', type: 'string' },
+    ]);
+    const result = {
+        output: {
+            amount: output.amount,
+            asset_groups_count: 0,
+            datum_hash: output.datumHash,
+            format: output.format,
+            inline_datum_size: output.inlineDatum ? hexStringByteLength(output.inlineDatum) : undefined,
+            reference_script_size: output.referenceScript
+                ? hexStringByteLength(output.referenceScript)
+                : undefined,
+        },
+        inlineDatum: output.inlineDatum,
+        referenceScript: output.referenceScript,
+    };
+    if (output.addressParameters) {
+        validateAddressParameters(output.addressParameters);
+        result.output.address_parameters = addressParametersToProto(output.addressParameters);
+    }
+    else {
+        result.output.address = output.address;
+    }
+    if (output.tokenBundle) {
+        result.tokenBundle = tokenBundleToProto(output.tokenBundle);
+        result.output.asset_groups_count = result.tokenBundle.length;
+    }
+    else {
+        result.output.asset_groups_count = 0;
+    }
+    return result;
+};
+const sendOutput = (typedCall, outputWithData) => __awaiter(void 0, void 0, void 0, function* () {
+    const MAX_CHUNK_SIZE = 1024 * 2;
+    const { output, tokenBundle, inlineDatum, referenceScript } = outputWithData;
+    yield typedCall('CardanoTxOutput', 'CardanoTxItemAck', output);
+    if (tokenBundle) {
+        for (const assetGroup of tokenBundle) {
+            yield typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+                policy_id: assetGroup.policyId,
+                tokens_count: assetGroup.tokens.length,
+            });
+            for (const token of assetGroup.tokens) {
+                yield typedCall('CardanoToken', 'CardanoTxItemAck', token);
+            }
+        }
+    }
+    if (inlineDatum) {
+        yield sendChunkedHexString(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
+    }
+    if (referenceScript) {
+        yield sendChunkedHexString(typedCall, referenceScript, MAX_CHUNK_SIZE, 'CardanoTxReferenceScriptChunk');
+    }
+});
+
+const ipv4AddressToHex = (ipv4Address) => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
+const ipv6AddressToHex = (ipv6Address) => ipv6Address.split(':').join('');
+const validatePoolMargin = (margin) => {
+    validateParams(margin, [
+        { name: 'numerator', type: 'string', required: true },
+        { name: 'denominator', type: 'string', required: true },
+    ]);
+};
+const validatePoolMetadata = (metadata) => {
+    validateParams(metadata, [
+        { name: 'url', type: 'string', required: true },
+        { name: 'hash', type: 'string', required: true },
+    ]);
+};
+const validatePoolRelay = (relay) => {
+    validateParams(relay, [{ name: 'type', type: 'number', required: true }]);
+    if (relay.type === hdTransport.Messages.CardanoPoolRelayType.SINGLE_HOST_IP) {
+        const paramsToValidate = [
+            { name: 'port', type: 'number', required: true },
+        ];
+        if (relay.ipv4Address) {
+            paramsToValidate.push({ name: 'ipv4Address', type: 'string', required: false });
+        }
+        if (relay.ipv6Address) {
+            paramsToValidate.push({ name: 'ipv6Address', type: 'string', required: false });
+        }
+        validateParams(relay, paramsToValidate);
+        if (!relay.ipv4Address && !relay.ipv6Address) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Either ipv4Address or ipv6Address must be supplied');
+        }
+    }
+    else if (relay.type === hdTransport.Messages.CardanoPoolRelayType.SINGLE_HOST_NAME) {
+        validateParams(relay, [
+            { name: 'hostName', type: 'string', required: true },
+            { name: 'port', type: 'number', required: true },
+        ]);
+    }
+    else if (relay.type === hdTransport.Messages.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
+        validateParams(relay, [{ name: 'hostName', type: 'string', required: true }]);
+    }
+};
+const validatePoolOwners = (owners) => {
+    owners.forEach(owner => {
+        if (owner.stakingKeyHash) {
+            validateParams(owner, [
+                { name: 'stakingKeyHash', type: 'string', required: !owner.stakingKeyPath },
+            ]);
+        }
+        if (owner.stakingKeyPath) {
+            validatePath(owner.stakingKeyPath, 5);
+        }
+        if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
+            throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Either stakingKeyHash or stakingKeyPath must be supplied');
+        }
+    });
+    const ownersAsPathCount = owners.filter(owner => !!owner.stakingKeyPath).length;
+    if (ownersAsPathCount !== 1) {
+        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, 'Exactly one pool owner must be given as a path');
+    }
+};
+const validatePoolParameters = (poolParameters) => {
+    validateParams(poolParameters, [
+        { name: 'poolId', type: 'string', required: true },
+        { name: 'vrfKeyHash', type: 'string', required: true },
+        { name: 'pledge', type: 'string', required: true },
+        { name: 'cost', type: 'string', required: true },
+        { name: 'margin', type: 'object', required: true },
+        { name: 'rewardAccount', type: 'string', required: true },
+        { name: 'owners', type: 'array', required: true },
+        { name: 'relays', type: 'array', required: true, allowEmpty: true },
+        { name: 'metadata', type: 'object' },
+    ]);
+    validatePoolMargin(poolParameters.margin);
+    validatePoolOwners(poolParameters.owners);
+    poolParameters.relays.forEach(validatePoolRelay);
+    if (poolParameters.metadata) {
+        validatePoolMetadata(poolParameters.metadata);
+    }
+};
+const transformPoolParameters = (poolParameters) => {
+    if (!poolParameters) {
+        return { poolParameters: undefined, poolOwners: [], poolRelays: [] };
+    }
+    validatePoolParameters(poolParameters);
+    return {
+        poolParameters: {
+            pool_id: poolParameters.poolId,
+            vrf_key_hash: poolParameters.vrfKeyHash,
+            pledge: poolParameters.pledge,
+            cost: poolParameters.cost,
+            margin_numerator: poolParameters.margin.numerator,
+            margin_denominator: poolParameters.margin.denominator,
+            reward_account: poolParameters.rewardAccount,
+            metadata: poolParameters.metadata,
+            owners_count: poolParameters.owners.length,
+            relays_count: poolParameters.relays.length,
+        },
+        poolOwners: poolParameters.owners.map(owner => ({
+            staking_key_hash: owner.stakingKeyHash,
+            staking_key_path: owner.stakingKeyPath ? validatePath(owner.stakingKeyPath, 5) : undefined,
+        })),
+        poolRelays: poolParameters.relays.map(relay => ({
+            type: relay.type,
+            ipv4_address: relay.ipv4Address ? ipv4AddressToHex(relay.ipv4Address) : undefined,
+            ipv6_address: relay.ipv6Address ? ipv6AddressToHex(relay.ipv6Address) : undefined,
+            host_name: relay.hostName,
+            port: relay.port,
+        })),
+    };
+};
+const transformCertificate = (certificate) => {
+    const paramsToValidate = [
+        { name: 'type', type: 'number', required: true },
+    ];
+    if (certificate.type !== hdTransport.Messages.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+        paramsToValidate.push({ name: 'scriptHash', type: 'string' });
+        paramsToValidate.push({ name: 'keyHash', type: 'string' });
+    }
+    if (certificate.type === hdTransport.Messages.CardanoCertificateType.STAKE_DELEGATION) {
+        paramsToValidate.push({ name: 'pool', type: 'string', required: true });
+    }
+    if (certificate.type === hdTransport.Messages.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+        paramsToValidate.push({ name: 'poolParameters', type: 'object', required: true });
+    }
+    validateParams(certificate, paramsToValidate);
+    const { poolParameters, poolOwners, poolRelays } = transformPoolParameters(certificate.poolParameters);
+    return {
+        certificate: {
+            type: certificate.type,
+            path: certificate.path ? validatePath(certificate.path, 5) : undefined,
+            script_hash: certificate.scriptHash,
+            key_hash: certificate.keyHash,
+            pool: certificate.pool,
+            pool_parameters: poolParameters,
+        },
+        poolOwners,
+        poolRelays,
+    };
+};
+
+const transformCatalystRegistrationParameters = (catalystRegistrationParameters) => {
+    validateParams(catalystRegistrationParameters, [
+        { name: 'votingPublicKey', type: 'string', required: true },
+        { name: 'stakingPath', required: true },
+        { name: 'nonce', type: 'uint', required: true },
+    ]);
+    validateAddressParameters(catalystRegistrationParameters.rewardAddressParameters);
+    return {
+        voting_public_key: catalystRegistrationParameters.votingPublicKey,
+        staking_path: validatePath(catalystRegistrationParameters.stakingPath, 3),
+        reward_address_parameters: addressParametersToProto(catalystRegistrationParameters.rewardAddressParameters),
+        nonce: catalystRegistrationParameters.nonce,
+    };
+};
+const transformAuxiliaryData = (auxiliaryData) => {
+    validateParams(auxiliaryData, [
+        {
+            name: 'hash',
+            type: 'string',
+        },
+    ]);
+    let catalystRegistrationParameters;
+    if (auxiliaryData.catalystRegistrationParameters) {
+        catalystRegistrationParameters = transformCatalystRegistrationParameters(auxiliaryData.catalystRegistrationParameters);
+    }
+    return {
+        hash: auxiliaryData.hash,
+        catalyst_registration_parameters: catalystRegistrationParameters,
+    };
+};
+const modifyAuxiliaryDataForBackwardsCompatibility = (auxiliary_data) => {
+    const { catalyst_registration_parameters } = auxiliary_data;
+    if (catalyst_registration_parameters) {
+        catalyst_registration_parameters.reward_address_parameters =
+            modifyAddressParametersForBackwardsCompatibility(catalyst_registration_parameters.reward_address_parameters);
+        return Object.assign(Object.assign({}, auxiliary_data), { catalyst_registration_parameters });
+    }
+    return auxiliary_data;
+};
+
+const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, signingMode) => {
+    const witnessPaths = new Map();
+    function _insert(path) {
+        const pathKey = JSON.stringify(path);
+        witnessPaths.set(pathKey, path);
+    }
+    if (signingMode !== hdTransport.Messages.CardanoTxSigningMode.MULTISIG_TRANSACTION) {
+        inputsWithPath.forEach(({ path }) => {
+            if (path)
+                _insert(path);
+        });
+        certificatesWithPoolOwnersAndRelays.forEach(({ certificate, poolOwners }) => {
+            if (certificate.path &&
+                (certificate.type === hdTransport.Messages.CardanoCertificateType.STAKE_DELEGATION ||
+                    certificate.type === hdTransport.Messages.CardanoCertificateType.STAKE_DEREGISTRATION)) {
+                _insert(certificate.path);
+            }
+            poolOwners.forEach(poolOwner => {
+                if (poolOwner.staking_key_path)
+                    _insert(poolOwner.staking_key_path);
+            });
+        });
+        withdrawals.forEach(({ path }) => {
+            if (path)
+                _insert(path);
+        });
+    }
+    if (signingMode === hdTransport.Messages.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
+        collateralInputsWithPath.forEach(({ path }) => {
+            if (path)
+                _insert(path);
+        });
+    }
+    requiredSigners.forEach(({ key_path }) => {
+        if (key_path)
+            _insert(key_path);
+    });
+    additionalWitnessRequests.forEach(path => {
+        _insert(path);
+    });
+    return Array.from(witnessPaths.values());
+};
+
+class CardanoSignTransaction extends BaseMethod {
+    init() {
+        var _a;
+        this.checkDeviceId = true;
+        this.allowDeviceMode = [...this.allowDeviceMode, UI_REQUEST.INITIALIZE];
+        this.hasBundle = !!((_a = this.payload) === null || _a === void 0 ? void 0 : _a.bundle);
+        const { payload } = this;
+        validateParams(payload, [
+            { name: 'signingMode', type: 'number', required: true },
+            { name: 'inputs', type: 'array', required: true },
+            { name: 'outputs', type: 'array', required: true, allowEmpty: true },
+            { name: 'fee', type: 'uint', required: true },
+            { name: 'ttl', type: 'uint' },
+            { name: 'certificates', type: 'array', allowEmpty: true },
+            { name: 'withdrawals', type: 'array', allowEmpty: true },
+            { name: 'mint', type: 'array', allowEmpty: true },
+            { name: 'validityIntervalStart', type: 'uint' },
+            { name: 'scriptDataHash', type: 'string' },
+            { name: 'collateralInputs', type: 'array', allowEmpty: true },
+            { name: 'requiredSigners', type: 'array', allowEmpty: true },
+            { name: 'totalCollateral', type: 'uint' },
+            { name: 'referenceInputs', type: 'array', allowEmpty: true },
+            { name: 'protocolMagic', type: 'number', required: true },
+            { name: 'networkId', type: 'number', required: true },
+            { name: 'additionalWitnessRequests', type: 'array', allowEmpty: true },
+            { name: 'derivationType', type: 'number' },
+            { name: 'includeNetworkId', type: 'boolean' },
+        ]);
+        const inputsWithPath = payload.inputs.map(transformInput);
+        const outputsWithData = payload.outputs.map(transformOutput);
+        let certificatesWithPoolOwnersAndRelays = [];
+        if (payload.certificates) {
+            certificatesWithPoolOwnersAndRelays = payload.certificates.map(transformCertificate);
+        }
+        let withdrawals = [];
+        if (payload.withdrawals) {
+            withdrawals = payload.withdrawals.map((withdrawal) => {
+                validateParams(withdrawal, [
+                    { name: 'amount', type: 'uint', required: true },
+                    { name: 'scriptHash', type: 'string' },
+                    { name: 'keyHash', type: 'string' },
+                ]);
+                return {
+                    path: withdrawal.path ? validatePath(withdrawal.path, 5) : undefined,
+                    amount: withdrawal.amount,
+                    script_hash: withdrawal.scriptHash,
+                    key_hash: withdrawal.keyHash,
+                };
+            });
+        }
+        let mint = [];
+        if (payload.mint) {
+            mint = tokenBundleToProto(payload.mint);
+        }
+        let auxiliaryData;
+        if (payload.auxiliaryData) {
+            auxiliaryData = transformAuxiliaryData(payload.auxiliaryData);
+        }
+        let additionalWitnessRequests = [];
+        if (payload.additionalWitnessRequests) {
+            additionalWitnessRequests = payload.additionalWitnessRequests.map((witnessRequest) => validatePath(witnessRequest, 3));
+        }
+        let collateralInputsWithPath = [];
+        if (payload.collateralInputs) {
+            collateralInputsWithPath = payload.collateralInputs.map(transformCollateralInput);
+        }
+        let requiredSigners = [];
+        if (payload.requiredSigners) {
+            requiredSigners = payload.requiredSigners.map((requiredSigner) => {
+                validateParams(requiredSigner, [{ name: 'keyHash', type: 'string' }]);
+                return {
+                    key_path: requiredSigner.keyPath ? validatePath(requiredSigner.keyPath, 3) : undefined,
+                    key_hash: requiredSigner.keyHash,
+                };
+            });
+        }
+        const collateralReturnWithData = payload.collateralReturn
+            ? transformOutput(payload.collateralReturn)
+            : undefined;
+        let referenceInputs = [];
+        if (payload.referenceInputs) {
+            referenceInputs = payload.referenceInputs.map(transformReferenceInput);
+        }
+        this.params = {
+            signingMode: payload.signingMode,
+            inputsWithPath,
+            outputsWithData,
+            fee: payload.fee,
+            ttl: payload.ttl,
+            certificatesWithPoolOwnersAndRelays,
+            withdrawals,
+            mint,
+            auxiliaryData,
+            validityIntervalStart: payload.validityIntervalStart,
+            scriptDataHash: payload.scriptDataHash,
+            collateralInputsWithPath,
+            requiredSigners,
+            collateralReturnWithData,
+            totalCollateral: payload.totalCollateral,
+            referenceInputs,
+            protocolMagic: payload.protocolMagic,
+            networkId: payload.networkId,
+            witnessPaths: gatherWitnessPaths(inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, payload.signingMode),
+            additionalWitnessRequests,
+            derivationType: typeof payload.derivationType !== 'undefined'
+                ? payload.derivationType
+                : hdTransport.Messages.CardanoDerivationType.ICARUS_TREZOR,
+            includeNetworkId: payload.includeNetworkId,
+        };
+    }
+    signTx() {
+        return __awaiter(this, void 0, void 0, function* () {
+            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.outputsWithData.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,
+                has_collateral_return: this.params.collateralReturnWithData != null,
+                total_collateral: this.params.totalCollateral,
+                reference_inputs_count: this.params.referenceInputs.length,
+                derivation_type: this.params.derivationType,
+                include_network_id: this.params.includeNetworkId,
+            };
+            yield typedCall('CardanoSignTxInit', 'CardanoTxItemAck', signTxInitMessage);
+            for (const { input } of this.params.inputsWithPath) {
+                yield typedCall('CardanoTxInput', 'CardanoTxItemAck', input);
+            }
+            for (const outputWithData of this.params.outputsWithData) {
+                yield sendOutput(typedCall, outputWithData);
+            }
+            for (const { certificate, poolOwners, poolRelays } of this.params
+                .certificatesWithPoolOwnersAndRelays) {
+                yield typedCall('CardanoTxCertificate', 'CardanoTxItemAck', certificate);
+                for (const poolOwner of poolOwners) {
+                    yield typedCall('CardanoPoolOwner', 'CardanoTxItemAck', poolOwner);
+                }
+                for (const poolRelay of poolRelays) {
+                    yield typedCall('CardanoPoolRelayParameters', 'CardanoTxItemAck', poolRelay);
+                }
+            }
+            for (const withdrawal of this.params.withdrawals) {
+                yield typedCall('CardanoTxWithdrawal', 'CardanoTxItemAck', withdrawal);
+            }
+            let auxiliaryDataSupplement;
+            if (this.params.auxiliaryData) {
+                const { catalyst_registration_parameters } = this.params.auxiliaryData;
+                if (catalyst_registration_parameters) {
+                    this.params.auxiliaryData = modifyAuxiliaryDataForBackwardsCompatibility(this.params.auxiliaryData);
+                }
+                const { message } = yield typedCall('CardanoTxAuxiliaryData', 'CardanoTxAuxiliaryDataSupplement', this.params.auxiliaryData);
+                const auxiliaryDataType = hdTransport.Messages.CardanoTxAuxiliaryDataSupplementType[message.type];
+                if (auxiliaryDataType !== hdTransport.Messages.CardanoTxAuxiliaryDataSupplementType.NONE) {
+                    auxiliaryDataSupplement = {
+                        type: auxiliaryDataType,
+                        auxiliaryDataHash: message.auxiliary_data_hash,
+                        catalystSignature: message.catalyst_signature,
+                    };
+                }
+                yield typedCall('CardanoTxHostAck', 'CardanoTxItemAck');
+            }
+            if (this.params.mint.length > 0) {
+                yield typedCall('CardanoTxMint', 'CardanoTxItemAck', {
+                    asset_groups_count: this.params.mint.length,
+                });
+                for (const assetGroup of this.params.mint) {
+                    yield typedCall('CardanoAssetGroup', 'CardanoTxItemAck', {
+                        policy_id: assetGroup.policyId,
+                        tokens_count: assetGroup.tokens.length,
+                    });
+                    for (const token of assetGroup.tokens) {
+                        yield typedCall('CardanoToken', 'CardanoTxItemAck', token);
+                    }
+                }
+            }
+            for (const { collateralInput } of this.params.collateralInputsWithPath) {
+                yield typedCall('CardanoTxCollateralInput', 'CardanoTxItemAck', collateralInput);
+            }
+            for (const requiredSigner of this.params.requiredSigners) {
+                yield typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
+            }
+            if (this.params.collateralReturnWithData) {
+                yield sendOutput(typedCall, this.params.collateralReturnWithData);
+            }
+            for (const referenceInput of this.params.referenceInputs) {
+                yield typedCall('CardanoTxReferenceInput', 'CardanoTxItemAck', referenceInput);
+            }
+            const witnesses = [];
+            for (const path of this.params.witnessPaths) {
+                const { message } = yield typedCall('CardanoTxWitnessRequest', 'CardanoTxWitnessResponse', {
+                    path,
+                });
+                witnesses.push({
+                    type: hdTransport.Messages.CardanoTxWitnessType[message.type],
+                    pubKey: message.pub_key,
+                    signature: message.signature,
+                    chainCode: message.chain_code,
+                });
+            }
+            const { message: txBodyHashMessage } = yield typedCall('CardanoTxHostAck', 'CardanoTxBodyHash');
+            yield typedCall('CardanoTxHostAck', 'CardanoSignTxFinished');
+            return { hash: txBodyHashMessage.tx_hash, witnesses, auxiliaryDataSupplement };
+        });
+    }
+    run() {
+        return this.signTx();
+    }
+}
+
 var ApiMethods = /*#__PURE__*/Object.freeze({
     __proto__: null,
     searchDevices: SearchDevices,
@@ -16513,7 +17356,10 @@ var ApiMethods = /*#__PURE__*/Object.freeze({
     xrpSignTransaction: XrpGetAddress,
     suiGetAddress: SuiGetAddress,
     suiGetPublicKey: SuiGetPublicKey,
-    suiSignTransaction: SuiSignTransaction
+    suiSignTransaction: SuiSignTransaction,
+    cardanoGetAddress: CardanoGetAddress,
+    cardanoGetPublicKey: CardanoGetPublicKey,
+    cardanoSignTransaction: CardanoSignTransaction
 });
 
 function findMethod(message) {
@@ -16528,21 +17374,6 @@ function findMethod(message) {
     throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.CallMethodInvalidParameter, `Method ${method} is not set`);
 }
 
-const safeThrowError = (error) => {
-    if (error instanceof hdShared.HardwareError) {
-        throw error;
-    }
-    else if (error.code === 'ERR_NETWORK') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeNotInstalled);
-    }
-    else if (error.code === 'ECONNABORTED') {
-        throw hdShared.ERRORS.TypedError(hdShared.HardwareErrorCode.BridgeTimeoutError);
-    }
-    else {
-        throw hdShared.ERRORS.TypedError(error);
-    }
-};
-
 const resolveAfter = (msec, value) => new Promise(resolve => {
     setTimeout(resolve, msec, value);
 });
@@ -16649,6 +17480,7 @@ const parseInitOptions = (method) => ({
     initSession: method === null || method === void 0 ? void 0 : method.payload.initSession,
     passphraseState: method === null || method === void 0 ? void 0 : method.payload.passphraseState,
     deviceId: method === null || method === void 0 ? void 0 : method.payload.deviceId,
+    deriveCardano: method === null || method === void 0 ? void 0 : method.name.startsWith('cardano'),
 });
 let _core;
 let _deviceList;