@trezor/connect 9.0.0-beta.4 → 9.0.0-beta.7

package/README.md

@@ -1,4 +1,6 @@
-# @trezor/connect API version 9.0.0-beta.4
+# @trezor/connect
+
+API version 9.0.0-beta.7
 
 [![Build Status](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml/badge.svg)](https://github.com/trezor/trezor-suite/actions/workflows/connect-test.yml)
 [![NPM](https://img.shields.io/npm/v/@trezor/connect.svg)](https://www.npmjs.org/package/@trezor/connect)
@@ -6,9 +8,31 @@
 
 Trezor Connect is a platform for easy integration of Trezor into 3rd party services, as well as into Trezor Suite. It provides an API with functionality to access public keys, sign transactions and authenticate users.
 
-User interface is presented in a secure popup window served from `connect.trezor.io/<version>/popup.html`. To try it out, use [@trezor/connect-explorer](../connect-explorer) hosted [here](https://trezor.github.io/trezor-suite/connect-explorer).
+This package is intended to be used in node.js environment. If you wan't to build a web application please refer to [@trezor/connect-web package](../connect-web/README.md).
+
+## Installation
+
+Install library as npm module:
+
+```javascript
+npm install @trezor/connect
+```
+
+or
+
+```javascript
+yarn add @trezor/connect
+```
+
+## Initialization
+
+ES6
 
--   [Integration](https://github.com/trezor/trezor-suite/blob/develop/docs/packages/connect/index.md)
+```javascript
+import TrezorConnect from '@trezor/connect';
+```
+
+For more instructions [refer to this document](../../docs/packages/connect/index.md)
 
 ## Version 9+ (experimental)
 
@@ -19,17 +43,6 @@ Since version 9 we are adopting a new versioning strategy. With every release, w
 
 Version 9+ will be available as `@trezor/connect` and `@trezor/connect-web` npm packages.
 
-## Step by step release process
-
--   Make sure you have released all [npm dependencies](../../releases/npm-packages.md).
--   Optional: if unsure run `node ./ci/scripts/check-npm-dependencies.js connect`. Please note that this script will report unreleased dependencies even for changes that do not affect runtime (READMEs etc.)
--   bump version in all @trezor/connect\* packages (except plugin packages). `yarn workspace @trezor/connect version:<beta|patch|minor|major>`
--   make sure CHANGELOG files have been updated
--   merge into develop branch
--   from develop branch create a pull requests into branch `release/connect-v9`
--   gitlab: click manual release `@trezor/connect-web` and `@trezor/connect` into npm
--   gitlab: click manual deploy job to connect.trezor.io/9
-
 ## Version 8 (stable)
 
 Currently, we are at version 8, which has an url https://connect.trezor.io/8/trezor-connect.js.
@@ -44,6 +57,16 @@ With regards to this repo - All updates should go to current version branch, the
 
 For deployment process of trezor-connect v8 refer to [trezor/connect repository](https://github.com/trezor/connect/blob/develop/docs/deployment/index.md)
 
+## Docs
+
+Interactive API explorer is available on https://connect.trezor.io/9/#/
+
+Documentation is available [docs/packages/connect](../../docs/packages/connect/index.md)
+
+## Examples
+
+A collection of examples on how to implement @trezor/connect in various environments is available in [packages/connect-examples](../connect-examples/README.md)
+
 ## Tests
 
 For integration testing against trezord and emulator refer to [this document](https://github.com/trezor/trezor-suite/blob/develop/packages/integration-tests/projects/connect/README.md).

package/lib/api/binance/binanceSignTx.d.ts

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
-import type { BinanceSDKTransaction, BinancePreparedTransaction } from '../../types/api/binanceSignTransaction';
+import type { BinanceSDKTransaction, BinancePreparedTransaction } from '../../types/api/binance';
 import type { TypedCall } from '../../device/DeviceCommands';
 export declare const validate: (tx: BinanceSDKTransaction) => BinancePreparedTransaction;
 export declare const signTx: (typedCall: TypedCall, address_n: number[], tx: BinancePreparedTransaction) => Promise<PROTO.BinanceSignedTx>;

package/lib/api/binanceSignTransaction.d.ts

@@ -1,5 +1,5 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { BinancePreparedTransaction } from '../types/api/binanceSignTransaction';
+import type { BinancePreparedTransaction } from '../types/api/binance';
 declare type Params = {
     path: number[];
     transaction: BinancePreparedTransaction;

package/lib/api/binanceSignTransaction.js

@@ -5,7 +5,7 @@ const AbstractMethod_1 = require("../core/AbstractMethod");
 const paramsValidator_1 = require("./common/paramsValidator");
 const coinInfo_1 = require("../data/coinInfo");
 const pathUtils_1 = require("../utils/pathUtils");
-const helper = (0, tslib_1.__importStar)(require("./binance/binanceSignTx"));
+const helper = tslib_1.__importStar(require("./binance/binanceSignTx"));
 class BinanceSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];

package/lib/api/bitcoin/Fees.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FeeLevels = void 0;
 const tslib_1 = require("tslib");
-const bignumber_js_1 = (0, tslib_1.__importDefault)(require("bignumber.js"));
+const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
 const BLOCKS = {
     btc: {
         high: 1,

package/lib/api/bitcoin/TransactionComposer.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TransactionComposer = void 0;
 const tslib_1 = require("tslib");
-const bignumber_js_1 = (0, tslib_1.__importDefault)(require("bignumber.js"));
+const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
 const utxo_lib_1 = require("@trezor/utxo-lib");
 const Fees_1 = require("./Fees");
 const pathUtils_1 = require("../../utils/pathUtils");

package/lib/api/bitcoin/enhanceSignTx.d.ts

@@ -1,4 +1,4 @@
 import type { BitcoinNetworkInfo } from '../../types';
-import type { TransactionOptions } from '../../types/api/signTransaction';
+import type { TransactionOptions } from '../../types/api/bitcoin';
 export declare const enhanceSignTx: (options: TransactionOptions, coinInfo: BitcoinNetworkInfo) => TransactionOptions;
 //# sourceMappingURL=enhanceSignTx.d.ts.map

package/lib/api/bitcoin/index.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./enhanceSignTx"), exports);
-(0, tslib_1.__exportStar)(require("./Fees"), exports);
-(0, tslib_1.__exportStar)(require("./inputs"), exports);
-(0, tslib_1.__exportStar)(require("./outputs"), exports);
-(0, tslib_1.__exportStar)(require("./refTx"), exports);
-(0, tslib_1.__exportStar)(require("./signtx"), exports);
-(0, tslib_1.__exportStar)(require("./signtxLegacy"), exports);
-(0, tslib_1.__exportStar)(require("./signtxVerify"), exports);
-(0, tslib_1.__exportStar)(require("./TransactionComposer"), exports);
+tslib_1.__exportStar(require("./enhanceSignTx"), exports);
+tslib_1.__exportStar(require("./Fees"), exports);
+tslib_1.__exportStar(require("./inputs"), exports);
+tslib_1.__exportStar(require("./outputs"), exports);
+tslib_1.__exportStar(require("./refTx"), exports);
+tslib_1.__exportStar(require("./signtx"), exports);
+tslib_1.__exportStar(require("./signtxLegacy"), exports);
+tslib_1.__exportStar(require("./signtxVerify"), exports);
+tslib_1.__exportStar(require("./TransactionComposer"), exports);
 //# sourceMappingURL=index.js.map

package/lib/api/bitcoin/refTx.d.ts

@@ -1,11 +1,11 @@
 import type { TypedRawTransaction } from '@trezor/blockchain-link';
 import type { CoinInfo, AccountAddresses } from '../../types';
-import type { RefTransaction, TransactionOptions } from '../../types/api/signTransaction';
+import type { RefTransaction, TransactionOptions } from '../../types/api/bitcoin';
 import type { PROTO } from '../../constants';
-export declare const requireReferencedTransactions: (inputs: PROTO.TxInputType[], options?: TransactionOptions, coinInfo?: CoinInfo | undefined) => boolean;
+export declare const requireReferencedTransactions: (inputs: PROTO.TxInputType[], options?: TransactionOptions, coinInfo?: CoinInfo) => boolean;
 export declare const getReferencedTransactions: (inputs: PROTO.TxInputType[]) => string[];
 export declare const getOrigTransactions: (inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[]) => string[];
-export declare const transformOrigTransactions: (txs: TypedRawTransaction[], coinInfo: CoinInfo, addresses?: AccountAddresses | undefined) => RefTransaction[];
+export declare const transformOrigTransactions: (txs: TypedRawTransaction[], coinInfo: CoinInfo, addresses?: AccountAddresses) => RefTransaction[];
 export declare const transformReferencedTransactions: (txs: TypedRawTransaction[], coinInfo: CoinInfo) => RefTransaction[];
 export declare const validateReferencedTransactions: (txs: RefTransaction[] | typeof undefined, inputs: PROTO.TxInputType[], outputs: PROTO.TxOutputType[]) => RefTransaction[] | undefined;
 //# sourceMappingURL=refTx.d.ts.map

package/lib/api/bitcoin/signtx.d.ts

@@ -1,7 +1,7 @@
 import { PROTO } from '../../constants';
 import type { BitcoinNetworkInfo } from '../../types';
 import type { TypedCall } from '../../device/DeviceCommands';
-import type { RefTransaction, TransactionOptions, SignedTransaction } from '../../types/api/signTransaction';
+import type { RefTransaction, TransactionOptions, SignedTransaction } from '../../types/api/bitcoin';
 export interface SignTxHelperProps {
     typedCall: TypedCall;
     txRequest: PROTO.TxRequest;

package/lib/api/bitcoin/signtxLegacy.d.ts

@@ -1,4 +1,4 @@
-import type { SignedTransaction } from '../../types/api/signTransaction';
+import type { SignedTransaction } from '../../types/api/bitcoin';
 import type { SignTxHelperParams } from './signtx';
 export declare const signTxLegacy: ({ typedCall, inputs, outputs, refTxs, options, coinInfo, }: SignTxHelperParams) => Promise<SignedTransaction>;
 //# sourceMappingURL=signtxLegacy.d.ts.map

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

@@ -1,6 +1,6 @@
 import { PROTO } from '../../constants';
 import type { Device } from '../../device/Device';
-import type { CardanoAddressParameters } from '../../types/api/cardanoGetAddress';
+import type { CardanoAddressParameters } from '../../types/api/cardano';
 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;

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

@@ -1,6 +1,6 @@
 import type { Device } from '../../device/Device';
 import type { PROTO } from '../../constants';
-import type { CardanoAuxiliaryData } from '../../types/api/cardanoSignTransaction';
+import type { CardanoAuxiliaryData } from '../../types/api/cardano';
 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/cardanoCertificate.d.ts

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
-import type { CardanoCertificate } from '../../types/api/cardanoSignTransaction';
+import type { CardanoCertificate } from '../../types/api/cardano';
 export declare type CertificateWithPoolOwnersAndRelays = {
     certificate: PROTO.CardanoTxCertificate;
     poolOwners: PROTO.CardanoPoolOwner[];

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

@@ -10,4 +10,5 @@ export declare type CollateralInputWithPath = {
 };
 export declare const transformInput: (input: any) => InputWithPath;
 export declare const transformCollateralInput: (collateralInput: any) => CollateralInputWithPath;
+export declare const transformReferenceInput: (referenceInput: any) => PROTO.CardanoTxReferenceInput;
 //# sourceMappingURL=cardanoInputs.d.ts.map

package/lib/api/cardano/cardanoInputs.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformCollateralInput = exports.transformInput = void 0;
+exports.transformReferenceInput = exports.transformCollateralInput = exports.transformInput = void 0;
 const paramsValidator_1 = require("../common/paramsValidator");
 const pathUtils_1 = require("../../utils/pathUtils");
 const transformInput = (input) => {
@@ -31,4 +31,15 @@ const transformCollateralInput = (collateralInput) => {
     };
 };
 exports.transformCollateralInput = transformCollateralInput;
+const transformReferenceInput = (referenceInput) => {
+    (0, paramsValidator_1.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,
+    };
+};
+exports.transformReferenceInput = transformReferenceInput;
 //# sourceMappingURL=cardanoInputs.js.map

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

@@ -1,8 +1,11 @@
 import type { AssetGroupWithTokens } from './cardanoTokenBundle';
-import type { PROTO } from '../../constants';
-export declare type OutputWithTokens = {
+import { PROTO } from '../../constants';
+export declare type OutputWithData = {
     output: PROTO.CardanoTxOutput;
     tokenBundle?: AssetGroupWithTokens[];
+    inlineDatum?: string;
+    referenceScript?: string;
 };
-export declare const transformOutput: (output: any) => OutputWithTokens;
+export declare const transformOutput: (output: any) => OutputWithData;
+export declare const sendOutput: (typedCall: any, outputWithData: OutputWithData) => Promise<void>;
 //# sourceMappingURL=cardanoOutputs.d.ts.map

package/lib/api/cardano/cardanoOutputs.js

@@ -1,22 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformOutput = void 0;
+exports.sendOutput = exports.transformOutput = void 0;
 const paramsValidator_1 = require("../common/paramsValidator");
 const cardanoAddressParameters_1 = require("./cardanoAddressParameters");
 const cardanoTokenBundle_1 = require("./cardanoTokenBundle");
+const cardanoUtils_1 = require("./cardanoUtils");
 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' },
+        { 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
+                ? (0, cardanoUtils_1.hexStringByteLength)(output.inlineDatum)
+                : undefined,
+            reference_script_size: output.referenceScript
+                ? (0, cardanoUtils_1.hexStringByteLength)(output.referenceScript)
+                : undefined,
         },
+        inlineDatum: output.inlineDatum,
+        referenceScript: output.referenceScript,
     };
     if (output.addressParameters) {
         (0, cardanoAddressParameters_1.validateAddressParameters)(output.addressParameters);
@@ -35,4 +48,27 @@ const transformOutput = (output) => {
     return result;
 };
 exports.transformOutput = transformOutput;
+const sendOutput = async (typedCall, outputWithData) => {
+    const MAX_CHUNK_SIZE = 1024 * 2;
+    const { output, tokenBundle, inlineDatum, referenceScript } = outputWithData;
+    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);
+            }
+        }
+    }
+    if (inlineDatum) {
+        await (0, cardanoUtils_1.sendChunkedHexString)(typedCall, inlineDatum, MAX_CHUNK_SIZE, 'CardanoTxInlineDatumChunk');
+    }
+    if (referenceScript) {
+        await (0, cardanoUtils_1.sendChunkedHexString)(typedCall, referenceScript, MAX_CHUNK_SIZE, 'CardanoTxReferenceScriptChunk');
+    }
+};
+exports.sendOutput = sendOutput;
 //# sourceMappingURL=cardanoOutputs.js.map

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

@@ -1,5 +1,5 @@
 import type { PROTO } from '../../constants';
-import type { CardanoAssetGroup } from '../../types/api/cardanoSignTransaction';
+import type { CardanoAssetGroup } from '../../types/api/cardano';
 export declare type AssetGroupWithTokens = {
     policyId: string;
     tokens: PROTO.CardanoToken[];

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

@@ -0,0 +1,3 @@
+export declare const hexStringByteLength: (s: string) => number;
+export declare const sendChunkedHexString: (typedCall: any, data: string, chunkSize: number, messageType: string) => Promise<void>;
+//# sourceMappingURL=cardanoUtils.d.ts.map

package/lib/api/cardano/cardanoUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendChunkedHexString = exports.hexStringByteLength = void 0;
+const hexStringByteLength = (s) => s.length / 2;
+exports.hexStringByteLength = hexStringByteLength;
+const sendChunkedHexString = async (typedCall, data, chunkSize, messageType) => {
+    let processedSize = 0;
+    while (processedSize < data.length) {
+        const chunk = data.slice(processedSize, processedSize + chunkSize);
+        await typedCall(messageType, 'CardanoTxItemAck', {
+            data: chunk,
+        });
+        processedSize += chunkSize;
+    }
+};
+exports.sendChunkedHexString = sendChunkedHexString;
+//# sourceMappingURL=cardanoUtils.js.map

package/lib/api/cardano/cardanoWitnesses.js

@@ -34,11 +34,11 @@ const gatherWitnessPaths = (inputsWithPath, certificatesWithPoolOwnersAndRelays,
             if (path)
                 _insert(path);
         });
-        requiredSigners.forEach(({ key_path }) => {
-            if (key_path)
-                _insert(key_path);
-        });
     }
+    requiredSigners.forEach(({ key_path }) => {
+        if (key_path)
+            _insert(key_path);
+    });
     additionalWitnessRequests.forEach(path => {
         _insert(path);
     });

package/lib/api/cardanoGetAddress.d.ts

@@ -17,7 +17,7 @@ export default class CardanoGetAddress extends AbstractMethod<'cardanoGetAddress
     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[]>;
+    run(): Promise<import("..").CardanoAddress | import("..").CardanoAddress[]>;
 }
 export {};
 //# sourceMappingURL=cardanoGetAddress.d.ts.map

package/lib/api/cardanoGetNativeScriptHash.d.ts

@@ -1,6 +1,6 @@
 import { PROTO } from '../constants';
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { CardanoNativeScript } from '../types/api/cardanoGetNativeScriptHash';
+import type { CardanoNativeScript } from '../types/api/cardano';
 export default class CardanoGetNativeScriptHash extends AbstractMethod<'cardanoGetNativeScriptHash', PROTO.CardanoGetNativeScriptHash> {
     init(): void;
     validateScript(script: CardanoNativeScript): void;

package/lib/api/cardanoGetPublicKey.d.ts

@@ -5,6 +5,6 @@ export default class CardanoGetPublicKey extends AbstractMethod<'cardanoGetPubli
     confirmed?: boolean;
     init(): void;
     confirmation(): Promise<boolean>;
-    run(): Promise<import("../types/api/cardanoGetPublicKey").CardanoPublicKey | import("../types/api/cardanoGetPublicKey").CardanoPublicKey[]>;
+    run(): Promise<import("..").CardanoPublicKey | import("..").CardanoPublicKey[]>;
 }
 //# sourceMappingURL=cardanoGetPublicKey.d.ts.map

package/lib/api/cardanoSignTransaction.d.ts

@@ -1,9 +1,9 @@
 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 { Path, InputWithPath, CollateralInputWithPath } from './cardano/cardanoInputs';
+import type { OutputWithData } from './cardano/cardanoOutputs';
 import { PROTO } from '../constants';
-import type { CardanoSignedTxData } from '../types/api/cardanoSignTransaction';
+import type { CardanoSignedTxData } from '../types/api/cardano';
 import type { AssetGroupWithTokens } from './cardano/cardanoTokenBundle';
 declare const CardanoSignTransactionFeatures: Readonly<{
     TransactionStreaming: string[];
@@ -14,11 +14,12 @@ declare const CardanoSignTransactionFeatures: Readonly<{
     ScriptDataHash: string[];
     Plutus: string[];
     KeyHashStakeCredential: string[];
+    Babbage: string[];
 }>;
 export declare type CardanoSignTransactionParams = {
     signingMode: PROTO.CardanoTxSigningMode;
     inputsWithPath: InputWithPath[];
-    outputsWithTokens: OutputWithTokens[];
+    outputsWithData: OutputWithData[];
     fee: PROTO.UintType;
     ttl?: PROTO.UintType;
     certificatesWithPoolOwnersAndRelays: CertificateWithPoolOwnersAndRelays[];
@@ -29,6 +30,9 @@ export declare type CardanoSignTransactionParams = {
     scriptDataHash?: string;
     collateralInputsWithPath: CollateralInputWithPath[];
     requiredSigners: PROTO.CardanoTxRequiredSigner[];
+    collateralReturnWithData?: OutputWithData;
+    totalCollateral?: PROTO.UintType;
+    referenceInputs: PROTO.CardanoTxReferenceInput[];
     protocolMagic: number;
     networkId: number;
     witnessPaths: Path[];

package/lib/api/cardanoSignTransaction.js

@@ -20,6 +20,7 @@ const CardanoSignTransactionFeatures = Object.freeze({
     ScriptDataHash: ['0', '2.4.4'],
     Plutus: ['0', '2.4.4'],
     KeyHashStakeCredential: ['0', '2.4.4'],
+    Babbage: ['0', '2.5.2'],
 });
 class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
@@ -46,6 +47,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             { 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 },
@@ -53,7 +56,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             { name: 'includeNetworkId', type: 'boolean' },
         ]);
         const inputsWithPath = payload.inputs.map(cardanoInputs_1.transformInput);
-        const outputsWithTokens = payload.outputs.map(cardanoOutputs_1.transformOutput);
+        const outputsWithData = payload.outputs.map(cardanoOutputs_1.transformOutput);
         let certificatesWithPoolOwnersAndRelays = [];
         if (payload.certificates) {
             certificatesWithPoolOwnersAndRelays = payload.certificates.map(cardanoCertificate_1.transformCertificate);
@@ -102,10 +105,17 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
                 };
             });
         }
+        const collateralReturnWithData = payload.collateralReturn
+            ? (0, cardanoOutputs_1.transformOutput)(payload.collateralReturn)
+            : undefined;
+        let referenceInputs = [];
+        if (payload.referenceInputs) {
+            referenceInputs = payload.referenceInputs.map(cardanoInputs_1.transformReferenceInput);
+        }
         this.params = {
             signingMode: payload.signingMode,
             inputsWithPath,
-            outputsWithTokens,
+            outputsWithData,
             fee: payload.fee,
             ttl: payload.ttl,
             certificatesWithPoolOwnersAndRelays,
@@ -116,6 +126,9 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             scriptDataHash: payload.scriptDataHash,
             collateralInputsWithPath,
             requiredSigners,
+            collateralReturnWithData,
+            totalCollateral: payload.totalCollateral,
+            referenceInputs,
             protocolMagic: payload.protocolMagic,
             networkId: payload.networkId,
             witnessPaths: (0, cardanoWitnesses_1.gatherWitnessPaths)(inputsWithPath, certificatesWithPoolOwnersAndRelays, withdrawals, collateralInputsWithPath, requiredSigners, additionalWitnessRequests, payload.signingMode),
@@ -142,7 +155,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
                 this._ensureFeatureIsSupported('KeyHashStakeCredential');
             }
         });
-        params.outputsWithTokens.forEach(({ output }) => {
+        params.outputsWithData.forEach(({ output }) => {
             if (output.datum_hash) {
                 this._ensureFeatureIsSupported('OutputDatumHash');
             }
@@ -168,6 +181,18 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         if (params.signingMode === constants_1.PROTO.CardanoTxSigningMode.PLUTUS_TRANSACTION) {
             this._ensureFeatureIsSupported('Plutus');
         }
+        params.outputsWithData.forEach(({ output, inlineDatum, referenceScript }) => {
+            if (output.format === constants_1.PROTO.CardanoTxOutputSerializationFormat.MAP_BABBAGE ||
+                inlineDatum ||
+                referenceScript) {
+                this._ensureFeatureIsSupported('Babbage');
+            }
+        });
+        if (params.collateralReturnWithData ||
+            params.totalCollateral != null ||
+            params.referenceInputs.length > 0) {
+            this._ensureFeatureIsSupported('Babbage');
+        }
     }
     async _sign_tx() {
         const typedCall = this.device.getCommands().typedCall.bind(this.device.getCommands());
@@ -177,7 +202,7 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             protocol_magic: this.params.protocolMagic,
             network_id: this.params.networkId,
             inputs_count: this.params.inputsWithPath.length,
-            outputs_count: this.params.outputsWithTokens.length,
+            outputs_count: this.params.outputsWithData.length,
             fee: this.params.fee,
             ttl: this.params.ttl,
             certificates_count: this.params.certificatesWithPoolOwnersAndRelays.length,
@@ -189,6 +214,9 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
             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,
         };
@@ -196,19 +224,8 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         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 outputWithData of this.params.outputsWithData) {
+            await (0, cardanoOutputs_1.sendOutput)(typedCall, outputWithData);
         }
         for (const { certificate, poolOwners, poolRelays } of this.params
             .certificatesWithPoolOwnersAndRelays) {
@@ -260,6 +277,12 @@ class CardanoSignTransaction extends AbstractMethod_1.AbstractMethod {
         for (const requiredSigner of this.params.requiredSigners) {
             await typedCall('CardanoTxRequiredSigner', 'CardanoTxItemAck', requiredSigner);
         }
+        if (this.params.collateralReturnWithData) {
+            await (0, cardanoOutputs_1.sendOutput)(typedCall, this.params.collateralReturnWithData);
+        }
+        for (const referenceInput of this.params.referenceInputs) {
+            await typedCall('CardanoTxReferenceInput', 'CardanoTxItemAck', referenceInput);
+        }
         const witnesses = [];
         for (const path of this.params.witnessPaths) {
             const { message } = await typedCall('CardanoTxWitnessRequest', 'CardanoTxWitnessResponse', { path });

package/lib/api/common/Discovery.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Discovery = void 0;
 const tslib_1 = require("tslib");
-const events_1 = (0, tslib_1.__importDefault)(require("events"));
+const events_1 = tslib_1.__importDefault(require("events"));
 const constants_1 = require("../../constants");
 const accountUtils_1 = require("../../utils/accountUtils");
 const formatUtils_1 = require("../../utils/formatUtils");

package/lib/api/common/paramsValidator.d.ts

@@ -8,7 +8,7 @@ declare type Param = {
     allowNegative?: boolean;
 };
 export declare function validateParams<P extends Record<string, any>>(params: P, schema: Param[]): P;
-export declare const validateCoinPath: (path: number[], coinInfo?: CoinInfo | undefined) => void;
+export declare const validateCoinPath: (path: number[], coinInfo?: CoinInfo) => void;
 export declare const getFirmwareRange: (method: string, coinInfo: CoinInfo | null | undefined, currentRange: FirmwareRange) => FirmwareRange;
 export {};
 //# sourceMappingURL=paramsValidator.d.ts.map

package/lib/api/composeTransaction.d.ts

@@ -26,7 +26,7 @@ export default class ComposeTransaction extends AbstractMethod<'composeTransacti
     }>;
     selectFee(account: DiscoveryAccount, utxo: AccountUtxo[]): Promise<SignedTransaction | "change-account">;
     _selectFeeUiResponse(composer: TransactionComposer): Promise<SignedTransaction | 'change-account'>;
-    _sign(tx: ComposeResult): Promise<import("../types/api/signTransaction").SignedTransaction>;
+    _sign(tx: ComposeResult): Promise<import("../types").SignedTransaction>;
     dispose(): void;
 }
 export {};

package/lib/api/composeTransaction.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const bignumber_js_1 = (0, tslib_1.__importDefault)(require("bignumber.js"));
+const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
 const AbstractMethod_1 = require("../core/AbstractMethod");
 const constants_1 = require("../constants");
 const events_1 = require("../events");
 const Discovery_1 = require("./common/Discovery");
 const paramsValidator_1 = require("./common/paramsValidator");
-const pathUtils = (0, tslib_1.__importStar)(require("../utils/pathUtils"));
+const pathUtils = tslib_1.__importStar(require("../utils/pathUtils"));
 const promiseUtils_1 = require("../utils/promiseUtils");
 const formatUtils_1 = require("../utils/formatUtils");
 const coinInfo_1 = require("../data/coinInfo");

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

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
-import type { EosSDKTransaction } from '../../types/api/eosSignTransaction';
+import type { EosSDKTransaction } from '../../types/api/eos';
 import type { TypedCall } from '../../device/DeviceCommands';
 export declare const validate: (tx: EosSDKTransaction) => {
     chain_id: string;