@trezor/connect 9.0.0-beta.1

package/lib/api/blockchainUnsubscribe.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainUnsubscribe extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'accounts', type: 'array', allowEmpty: true },
+            { name: 'coin', type: 'string', required: true },
+        ]);
+        if (payload.accounts) {
+            payload.accounts.forEach(account => {
+                (0, paramsValidator_1.validateParams)(account, [{ name: 'descriptor', type: 'string', required: true }]);
+            });
+        }
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            accounts: payload.accounts,
+            coinInfo,
+        };
+    }
+    async run() {
+        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        return backend.unsubscribe(this.params.accounts);
+    }
+}
+exports.default = BlockchainUnsubscribe;
+//# sourceMappingURL=blockchainUnsubscribe.js.map

package/lib/api/blockchainUnsubscribeFiatRates.d.ts

@@ -0,0 +1,13 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    coinInfo: CoinInfo;
+};
+export default class BlockchainUnsubscribeFiatRates extends AbstractMethod<'blockchainUnsubscribeFiatRates', Params> {
+    init(): void;
+    run(): Promise<{
+        subscribed: boolean;
+    }>;
+}
+export {};
+//# sourceMappingURL=blockchainUnsubscribeFiatRates.d.ts.map

package/lib/api/blockchainUnsubscribeFiatRates.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainUnsubscribeFiatRates extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [{ name: 'coin', type: 'string', required: true }]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            coinInfo,
+        };
+    }
+    async run() {
+        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        return backend.unsubscribeFiatRates();
+    }
+}
+exports.default = BlockchainUnsubscribeFiatRates;
+//# sourceMappingURL=blockchainUnsubscribeFiatRates.js.map

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

@@ -0,0 +1,8 @@
+import { PROTO } from '../../constants';
+import type { Device } from '../../device/Device';
+import type { CardanoAddressParameters } from '../../types/api/cardanoGetAddress';
+export declare const validateAddressParameters: (addressParameters: CardanoAddressParameters) => void;
+export declare const modifyAddressParametersForBackwardsCompatibility: (device: Device, address_parameters: PROTO.CardanoAddressParametersType) => PROTO.CardanoAddressParametersType;
+export declare const addressParametersToProto: (addressParameters: CardanoAddressParameters) => PROTO.CardanoAddressParametersType;
+export declare const addressParametersFromProto: (addressParameters: PROTO.CardanoAddressParametersType) => CardanoAddressParameters;
+//# sourceMappingURL=cardanoAddressParameters.d.ts.map

package/lib/api/cardano/cardanoAddressParameters.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addressParametersFromProto = exports.addressParametersToProto = exports.modifyAddressParametersForBackwardsCompatibility = exports.validateAddressParameters = void 0;
+const paramsValidator_1 = require("../common/paramsValidator");
+const pathUtils_1 = require("../../utils/pathUtils");
+const constants_1 = require("../../constants");
+const validateAddressParameters = (addressParameters) => {
+    (0, paramsValidator_1.validateParams)(addressParameters, [
+        { name: 'addressType', type: 'number', required: true },
+        { name: 'stakingKeyHash', type: 'string' },
+        { name: 'paymentScriptHash', type: 'string' },
+        { name: 'stakingScriptHash', type: 'string' },
+    ]);
+    if (addressParameters.path) {
+        (0, pathUtils_1.validatePath)(addressParameters.path);
+    }
+    if (addressParameters.stakingPath) {
+        (0, pathUtils_1.validatePath)(addressParameters.stakingPath);
+    }
+    if (addressParameters.certificatePointer) {
+        (0, paramsValidator_1.validateParams)(addressParameters.certificatePointer, [
+            { name: 'blockIndex', type: 'number', required: true },
+            { name: 'txIndex', type: 'number', required: true },
+            { name: 'certificateIndex', type: 'number', required: true },
+        ]);
+    }
+};
+exports.validateAddressParameters = validateAddressParameters;
+const modifyAddressParametersForBackwardsCompatibility = (device, address_parameters) => {
+    if (address_parameters.address_type === constants_1.PROTO.CardanoAddressType.REWARD) {
+        let { address_n, address_n_staking } = address_parameters;
+        if (address_n.length > 0 && address_n_staking.length > 0) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Only stakingPath is allowed for CardanoAddressType.REWARD`);
+        }
+        if (device.atLeast(['0', '2.4.3'])) {
+            if (address_n.length > 0) {
+                address_n_staking = address_n;
+                address_n = [];
+            }
+        }
+        else if (address_n_staking.length > 0) {
+            address_n = address_n_staking;
+            address_n_staking = [];
+        }
+        return {
+            ...address_parameters,
+            address_n,
+            address_n_staking,
+        };
+    }
+    return address_parameters;
+};
+exports.modifyAddressParametersForBackwardsCompatibility = modifyAddressParametersForBackwardsCompatibility;
+const addressParametersToProto = (addressParameters) => {
+    let path = [];
+    if (addressParameters.path) {
+        path = (0, pathUtils_1.validatePath)(addressParameters.path, 3);
+    }
+    let stakingPath = [];
+    if (addressParameters.stakingPath) {
+        stakingPath = (0, pathUtils_1.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,
+    };
+};
+exports.addressParametersToProto = addressParametersToProto;
+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,
+    };
+};
+exports.addressParametersFromProto = addressParametersFromProto;
+//# sourceMappingURL=cardanoAddressParameters.js.map

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

@@ -0,0 +1,6 @@
+import type { Device } from '../../device/Device';
+import type { PROTO } from '../../constants';
+import type { CardanoAuxiliaryData } from '../../types/api/cardanoSignTransaction';
+export declare const transformAuxiliaryData: (auxiliaryData: CardanoAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;
+export declare const modifyAuxiliaryDataForBackwardsCompatibility: (device: Device, auxiliary_data: PROTO.CardanoTxAuxiliaryData) => PROTO.CardanoTxAuxiliaryData;
+//# sourceMappingURL=cardanoAuxiliaryData.d.ts.map

package/lib/api/cardano/cardanoAuxiliaryData.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.modifyAuxiliaryDataForBackwardsCompatibility = exports.transformAuxiliaryData = void 0;
+const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
+const paramsValidator_1 = require("../common/paramsValidator");
+const pathUtils_1 = require("../../utils/pathUtils");
+const transformCatalystRegistrationParameters = (catalystRegistrationParameters) => {
+    (0, paramsValidator_1.validateParams)(catalystRegistrationParameters, [
+        { name: 'votingPublicKey', type: 'string', required: true },
+        { name: 'stakingPath', required: true },
+        { name: 'nonce', type: 'uint', required: true },
+    ]);
+    (0, cardanoAddressParameters_1.validateAddressParameters)(catalystRegistrationParameters.rewardAddressParameters);
+    return {
+        voting_public_key: catalystRegistrationParameters.votingPublicKey,
+        staking_path: (0, pathUtils_1.validatePath)(catalystRegistrationParameters.stakingPath, 3),
+        reward_address_parameters: (0, cardanoAddressParameters_1.addressParametersToProto)(catalystRegistrationParameters.rewardAddressParameters),
+        nonce: catalystRegistrationParameters.nonce,
+    };
+};
+const transformAuxiliaryData = (auxiliaryData) => {
+    (0, paramsValidator_1.validateParams)(auxiliaryData, [
+        {
+            name: 'hash',
+            type: 'string',
+        },
+    ]);
+    let catalystRegistrationParameters;
+    if (auxiliaryData.catalystRegistrationParameters) {
+        catalystRegistrationParameters = transformCatalystRegistrationParameters(auxiliaryData.catalystRegistrationParameters);
+    }
+    return {
+        hash: auxiliaryData.hash,
+        catalyst_registration_parameters: catalystRegistrationParameters,
+    };
+};
+exports.transformAuxiliaryData = transformAuxiliaryData;
+const modifyAuxiliaryDataForBackwardsCompatibility = (device, auxiliary_data) => {
+    const { catalyst_registration_parameters } = auxiliary_data;
+    if (catalyst_registration_parameters) {
+        catalyst_registration_parameters.reward_address_parameters =
+            (0, cardanoAddressParameters_1.modifyAddressParametersForBackwardsCompatibility)(device, catalyst_registration_parameters.reward_address_parameters);
+        return {
+            ...auxiliary_data,
+            catalyst_registration_parameters,
+        };
+    }
+    return auxiliary_data;
+};
+exports.modifyAuxiliaryDataForBackwardsCompatibility = modifyAuxiliaryDataForBackwardsCompatibility;
+//# sourceMappingURL=cardanoAuxiliaryData.js.map

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

@@ -0,0 +1,14 @@
+import { PROTO } from '../../constants';
+import type { CardanoCertificate } from '../../types/api/cardanoSignTransaction';
+export declare type CertificateWithPoolOwnersAndRelays = {
+    certificate: PROTO.CardanoTxCertificate;
+    poolOwners: PROTO.CardanoPoolOwner[];
+    poolRelays: PROTO.CardanoPoolRelayParameters[];
+};
+export declare type PoolParametersWithOwnersAndRelays = {
+    poolParameters?: PROTO.CardanoPoolParametersType;
+    poolOwners: PROTO.CardanoPoolOwner[];
+    poolRelays: PROTO.CardanoPoolRelayParameters[];
+};
+export declare const transformCertificate: (certificate: CardanoCertificate) => CertificateWithPoolOwnersAndRelays;
+//# sourceMappingURL=cardanoCertificate.d.ts.map

package/lib/api/cardano/cardanoCertificate.js

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformCertificate = void 0;
+const paramsValidator_1 = require("../common/paramsValidator");
+const pathUtils_1 = require("../../utils/pathUtils");
+const constants_1 = require("../../constants");
+const ipv4AddressToHex = (ipv4Address) => Buffer.from(ipv4Address.split('.').map(ipPart => parseInt(ipPart, 10))).toString('hex');
+const ipv6AddressToHex = (ipv6Address) => ipv6Address.split(':').join('');
+const validatePoolMargin = (margin) => {
+    (0, paramsValidator_1.validateParams)(margin, [
+        { name: 'numerator', type: 'string', required: true },
+        { name: 'denominator', type: 'string', required: true },
+    ]);
+};
+const validatePoolMetadata = (metadata) => {
+    (0, paramsValidator_1.validateParams)(metadata, [
+        { name: 'url', type: 'string', required: true },
+        { name: 'hash', type: 'string', required: true },
+    ]);
+};
+const validatePoolRelay = (relay) => {
+    (0, paramsValidator_1.validateParams)(relay, [{ name: 'type', type: 'number', required: true }]);
+    if (relay.type === constants_1.PROTO.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 });
+        }
+        (0, paramsValidator_1.validateParams)(relay, paramsToValidate);
+        if (!relay.ipv4Address && !relay.ipv6Address) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either ipv4Address or ipv6Address must be supplied');
+        }
+    }
+    else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.SINGLE_HOST_NAME) {
+        (0, paramsValidator_1.validateParams)(relay, [
+            { name: 'hostName', type: 'string', required: true },
+            { name: 'port', type: 'number', required: true },
+        ]);
+    }
+    else if (relay.type === constants_1.PROTO.CardanoPoolRelayType.MULTIPLE_HOST_NAME) {
+        (0, paramsValidator_1.validateParams)(relay, [{ name: 'hostName', type: 'string', required: true }]);
+    }
+};
+const validatePoolOwners = (owners) => {
+    owners.forEach(owner => {
+        if (owner.stakingKeyHash) {
+            (0, paramsValidator_1.validateParams)(owner, [
+                { name: 'stakingKeyHash', type: 'string', required: !owner.stakingKeyPath },
+            ]);
+        }
+        if (owner.stakingKeyPath) {
+            (0, pathUtils_1.validatePath)(owner.stakingKeyPath, 5);
+        }
+        if (!owner.stakingKeyHash && !owner.stakingKeyPath) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Either stakingKeyHash or stakingKeyPath must be supplied');
+        }
+    });
+    const ownersAsPathCount = owners.filter(owner => !!owner.stakingKeyPath).length;
+    if (ownersAsPathCount !== 1) {
+        throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Exactly one pool owner must be given as a path');
+    }
+};
+const validatePoolParameters = (poolParameters) => {
+    (0, paramsValidator_1.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
+                ? (0, pathUtils_1.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 !== constants_1.PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+        paramsToValidate.push({ name: 'scriptHash', type: 'string' });
+        paramsToValidate.push({ name: 'keyHash', type: 'string' });
+    }
+    if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION) {
+        paramsToValidate.push({ name: 'pool', type: 'string', required: true });
+    }
+    if (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_POOL_REGISTRATION) {
+        paramsToValidate.push({ name: 'poolParameters', type: 'object', required: true });
+    }
+    (0, paramsValidator_1.validateParams)(certificate, paramsToValidate);
+    const { poolParameters, poolOwners, poolRelays } = transformPoolParameters(certificate.poolParameters);
+    return {
+        certificate: {
+            type: certificate.type,
+            path: certificate.path ? (0, pathUtils_1.validatePath)(certificate.path, 5) : undefined,
+            script_hash: certificate.scriptHash,
+            key_hash: certificate.keyHash,
+            pool: certificate.pool,
+            pool_parameters: poolParameters,
+        },
+        poolOwners,
+        poolRelays,
+    };
+};
+exports.transformCertificate = transformCertificate;
+//# sourceMappingURL=cardanoCertificate.js.map

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

@@ -0,0 +1,13 @@
+import type { PROTO } from '../../constants';
+export declare type Path = number[];
+export declare type InputWithPath = {
+    input: PROTO.CardanoTxInput;
+    path?: Path;
+};
+export declare type CollateralInputWithPath = {
+    collateralInput: PROTO.CardanoTxCollateralInput;
+    path?: Path;
+};
+export declare const transformInput: (input: any) => InputWithPath;
+export declare const transformCollateralInput: (collateralInput: any) => CollateralInputWithPath;
+//# sourceMappingURL=cardanoInputs.d.ts.map

package/lib/api/cardano/cardanoInputs.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformCollateralInput = exports.transformInput = void 0;
+const paramsValidator_1 = require("../common/paramsValidator");
+const pathUtils_1 = require("../../utils/pathUtils");
+const transformInput = (input) => {
+    (0, paramsValidator_1.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 ? (0, pathUtils_1.validatePath)(input.path, 5) : undefined,
+    };
+};
+exports.transformInput = transformInput;
+const transformCollateralInput = (collateralInput) => {
+    (0, paramsValidator_1.validateParams)(collateralInput, [
+        { name: 'prev_hash', type: 'string', required: true },
+        { name: 'prev_index', type: 'number', required: true },
+    ]);
+    return {
+        collateralInput: {
+            prev_hash: collateralInput.prev_hash,
+            prev_index: collateralInput.prev_index,
+        },
+        path: collateralInput.path ? (0, pathUtils_1.validatePath)(collateralInput.path, 5) : undefined,
+    };
+};
+exports.transformCollateralInput = transformCollateralInput;
+//# sourceMappingURL=cardanoInputs.js.map

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

@@ -0,0 +1,8 @@
+import type { AssetGroupWithTokens } from './cardanoTokenBundle';
+import type { PROTO } from '../../constants';
+export declare type OutputWithTokens = {
+    output: PROTO.CardanoTxOutput;
+    tokenBundle?: AssetGroupWithTokens[];
+};
+export declare const transformOutput: (output: any) => OutputWithTokens;
+//# sourceMappingURL=cardanoOutputs.d.ts.map

package/lib/api/cardano/cardanoOutputs.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOutput = void 0;
+const paramsValidator_1 = require("../common/paramsValidator");
+const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
+const cardanoTokenBundle_1 = require("./cardanoTokenBundle");
+const transformOutput = (output) => {
+    (0, paramsValidator_1.validateParams)(output, [
+        { name: 'address', type: 'string' },
+        { name: 'amount', type: 'uint', required: true },
+        { name: 'tokenBundle', type: 'array', allowEmpty: true },
+        { name: 'datumHash', type: 'string' },
+    ]);
+    const result = {
+        output: {
+            amount: output.amount,
+            asset_groups_count: 0,
+            datum_hash: output.datumHash,
+        },
+    };
+    if (output.addressParameters) {
+        (0, cardanoAddressParameters_1.validateAddressParameters)(output.addressParameters);
+        result.output.address_parameters = (0, cardanoAddressParameters_1.addressParametersToProto)(output.addressParameters);
+    }
+    else {
+        result.output.address = output.address;
+    }
+    if (output.tokenBundle) {
+        result.tokenBundle = (0, cardanoTokenBundle_1.tokenBundleToProto)(output.tokenBundle);
+        result.output.asset_groups_count = result.tokenBundle.length;
+    }
+    else {
+        result.output.asset_groups_count = 0;
+    }
+    return result;
+};
+exports.transformOutput = transformOutput;
+//# sourceMappingURL=cardanoOutputs.js.map

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

@@ -0,0 +1,8 @@
+import type { PROTO } from '../../constants';
+import type { CardanoAssetGroup } from '../../types/api/cardanoSignTransaction';
+export declare type AssetGroupWithTokens = {
+    policyId: string;
+    tokens: PROTO.CardanoToken[];
+};
+export declare const tokenBundleToProto: (tokenBundle: CardanoAssetGroup[]) => AssetGroupWithTokens[];
+//# sourceMappingURL=cardanoTokenBundle.d.ts.map

package/lib/api/cardano/cardanoTokenBundle.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenBundleToProto = void 0;
+const paramsValidator_1 = require("../common/paramsValidator");
+const validateTokens = (tokenAmounts) => {
+    tokenAmounts.forEach(tokenAmount => {
+        (0, paramsValidator_1.validateParams)(tokenAmount, [
+            { name: 'assetNameBytes', type: 'string', required: true },
+            { name: 'amount', type: 'uint' },
+            { name: 'mintAmount', type: 'uint', allowNegative: true },
+        ]);
+    });
+};
+const validateTokenBundle = (tokenBundle) => {
+    tokenBundle.forEach(tokenGroup => {
+        (0, paramsValidator_1.validateParams)(tokenGroup, [
+            { name: 'policyId', type: 'string', required: true },
+            { name: 'tokenAmounts', type: 'array', required: true },
+        ]);
+        validateTokens(tokenGroup.tokenAmounts);
+    });
+};
+const tokenAmountsToProto = (tokenAmounts) => tokenAmounts.map(tokenAmount => ({
+    asset_name_bytes: tokenAmount.assetNameBytes,
+    amount: tokenAmount.amount,
+    mint_amount: tokenAmount.mintAmount,
+}));
+const tokenBundleToProto = (tokenBundle) => {
+    validateTokenBundle(tokenBundle);
+    return tokenBundle.map(tokenGroup => ({
+        policyId: tokenGroup.policyId,
+        tokens: tokenAmountsToProto(tokenGroup.tokenAmounts),
+    }));
+};
+exports.tokenBundleToProto = tokenBundleToProto;
+//# sourceMappingURL=cardanoTokenBundle.js.map

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

@@ -0,0 +1,5 @@
+import type { CertificateWithPoolOwnersAndRelays } from './cardanoCertificate';
+import type { CollateralInputWithPath, InputWithPath, Path } from './cardanoInputs';
+import { PROTO } from '../../constants';
+export declare const gatherWitnessPaths: (inputsWithPath: InputWithPath[], certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[], withdrawals: PROTO.CardanoTxWithdrawal[], collateralInputsWithPath: CollateralInputWithPath[], requiredSigners: PROTO.CardanoTxRequiredSigner[], additionalWitnessRequests: Path[], signingMode: PROTO.CardanoTxSigningMode) => Path[];
+//# sourceMappingURL=cardanoWitnesses.d.ts.map

package/lib/api/cardano/cardanoWitnesses.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gatherWitnessPaths = void 0;
+const constants_1 = require("../../constants");
+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 !== constants_1.PROTO.CardanoTxSigningMode.MULTISIG_TRANSACTION) {
+        inputsWithPath.forEach(({ path }) => {
+            if (path)
+                _insert(path);
+        });
+        certificatesWithPoolOwnersAndRelays.forEach(({ certificate, poolOwners }) => {
+            if (certificate.path &&
+                (certificate.type === constants_1.PROTO.CardanoCertificateType.STAKE_DELEGATION ||
+                    certificate.type === constants_1.PROTO.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 === constants_1.PROTO.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());
+};
+exports.gatherWitnessPaths = gatherWitnessPaths;
+//# sourceMappingURL=cardanoWitnesses.js.map

package/lib/api/cardanoGetAddress.d.ts

@@ -0,0 +1,23 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+declare type Params = PROTO.CardanoGetAddress & {
+    address?: string;
+};
+export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress', Params[]> {
+    hasBundle?: boolean;
+    progress: number;
+    confirmed?: boolean;
+    init(): void;
+    getButtonRequestData(code: string): {
+        type: "address";
+        serializedPath: string;
+        address: string;
+    } | undefined;
+    confirmation(): Promise<boolean>;
+    noBackupConfirmation(): Promise<boolean>;
+    _call({ address_parameters, protocol_magic, network_id, derivation_type, show_display, }: Params): Promise<PROTO.CardanoAddress>;
+    _ensureFirmwareSupportsBatch(batch: Params): void;
+    run(): Promise<import("../types/api/cardanoGetAddress").CardanoAddress | import("../types/api/cardanoGetAddress").CardanoAddress[]>;
+}
+export {};
+//# sourceMappingURL=cardanoGetAddress.d.ts.map