@trezor/connect 9.0.0-beta.5 → 9.0.0-beta.6

package/README.md

@@ -1,4 +1,4 @@
-# @trezor/connect API version 9.0.0-beta.5
+# @trezor/connect API version 9.0.0-beta.6
 
 [![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)

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/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/refTx.d.ts

@@ -1,6 +1,6 @@
 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 getReferencedTransactions: (inputs: PROTO.TxInputType[]) => string[];

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/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/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

@@ -3,7 +3,7 @@ import type { CertificateWithPoolOwnersAndRelays } from './cardano/cardanoCertif
 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[];

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/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;

package/lib/api/eosGetPublicKey.d.ts

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

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

@@ -1,5 +1,5 @@
 import type { TypedCall } from '../../device/DeviceCommands';
-import type { EthereumAccessList } from '../../types/api/ethereumSignTransaction';
+import type { EthereumAccessList } from '../../types/api/ethereum';
 export declare const ethereumSignTx: (typedCall: TypedCall, address_n: number[], to: string, value: string, gas_limit: string, gas_price: string, nonce: string, chain_id: number, data?: string | undefined, tx_type?: number | undefined) => Promise<{
     v: string;
     r: string;

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

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
-import type { EthereumSignTypedDataTypes } from '../../types/api/ethereumSignTypedData';
+import type { EthereumSignTypedDataTypes } from '../../types/api/ethereum';
 export declare function parseArrayType(arrayTypeName: string): {
     entryTypeName: string;
     arraySize: number | null;

package/lib/api/ethereumSignTransaction.d.ts

@@ -1,5 +1,5 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { EthereumTransaction, EthereumTransactionEIP1559 } from '../types/api/ethereumSignTransaction';
+import type { EthereumTransaction, EthereumTransactionEIP1559 } from '../types/api/ethereum';
 declare type Params = {
     path: number[];
     tx: ({

package/lib/api/ethereumSignTypedData.d.ts

@@ -1,5 +1,5 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import type { EthereumSignTypedDataTypes, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from '../types/api/ethereumSignTypedData';
+import type { EthereumSignTypedDataTypes, EthereumSignTypedData as EthereumSignTypedDataParams, EthereumSignTypedHash as EthereumSignTypedHashParams } from '../types/api/ethereum';
 declare type Params = (Omit<EthereumSignTypedDataParams<EthereumSignTypedDataTypes>, 'path'> | Omit<EthereumSignTypedHashParams<EthereumSignTypedDataTypes>, 'path'>) & {
     address_n: number[];
 };

package/lib/api/nem/nemSignTx.d.ts

@@ -1,4 +1,4 @@
 import { PROTO } from '../../constants';
-import * as $T from '../../types/api/nemSignTransaction';
+import * as $T from '../../types/api/nem';
 export declare const createTx: (tx: $T.NEMTransaction, address_n: number[]) => PROTO.NEMSignTx;
 //# sourceMappingURL=nemSignTx.d.ts.map

package/lib/api/signTransaction.d.ts

@@ -1,7 +1,7 @@
 import { AbstractMethod } from '../core/AbstractMethod';
 import { PROTO } from '../constants';
 import type { BitcoinNetworkInfo, AccountAddresses } from '../types';
-import type { RefTransaction, TransactionOptions } from '../types/api/signTransaction';
+import type { RefTransaction, TransactionOptions } from '../types/api/bitcoin';
 declare type Params = {
     inputs: PROTO.TxInputType[];
     outputs: PROTO.TxOutputType[];
@@ -15,7 +15,7 @@ declare type Params = {
 };
 export default class SignTransaction extends AbstractMethod<'signTransaction', Params> {
     init(): void;
-    run(): Promise<import("../types/api/signTransaction").SignedTransaction>;
+    run(): Promise<import("../types").SignedTransaction>;
 }
 export {};
 //# sourceMappingURL=signTransaction.d.ts.map

package/lib/api/stellar/stellarSignTx.d.ts

@@ -1,5 +1,5 @@
 import { PROTO } from '../../constants';
 import type { TypedCall } from '../../device/DeviceCommands';
-import type { StellarTransaction } from '../../types/api/stellarSignTransaction';
+import type { StellarTransaction } from '../../types/api/stellar';
 export declare const stellarSignTx: (typedCall: TypedCall, address_n: number[], networkPassphrase: string, tx: StellarTransaction) => Promise<PROTO.StellarSignedTx>;
 //# sourceMappingURL=stellarSignTx.d.ts.map

package/lib/api/stellarSignTransaction.d.ts

@@ -1,5 +1,5 @@
 import { AbstractMethod } from '../core/AbstractMethod';
-import { StellarTransaction } from '../types/api/stellarSignTransaction';
+import { StellarTransaction } from '../types/api/stellar';
 declare type Params = {
     path: number[];
     networkPassphrase: string;

package/lib/api/tezos/tezosSignTx.d.ts

@@ -1,4 +1,4 @@
 import { PROTO } from '../../constants';
-import type { TezosOperation } from '../../types/api/tezosSignTransaction';
+import type { TezosOperation } from '../../types/api/tezos';
 export declare const createTx: (address_n: number[], branch: string, operation: TezosOperation) => PROTO.TezosSignTx;
 //# sourceMappingURL=tezosSignTx.d.ts.map

package/lib/data/version.d.ts

@@ -1,3 +1,3 @@
-export declare const VERSION = "9.0.0-beta.5";
+export declare const VERSION = "9.0.0-beta.6";
 export declare const DEFAULT_DOMAIN: string;
 //# sourceMappingURL=version.d.ts.map

package/lib/data/version.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_DOMAIN = exports.VERSION = void 0;
-exports.VERSION = '9.0.0-beta.5';
+exports.VERSION = '9.0.0-beta.6';
 const versionN = exports.VERSION.split('.').map(s => parseInt(s, 10));
 exports.DEFAULT_DOMAIN = `https://connect.trezor.io/${versionN[0]}/`;
 //# sourceMappingURL=version.js.map

package/lib/device/DeviceList.js

@@ -19,6 +19,7 @@ const { BridgeV2, Fallback } = transport_1.default;
 const _log = (0, debug_1.initLog)('DeviceList');
 class DeviceList extends events_1.default {
     constructor() {
+        var _a, _b;
         super();
         this.devices = {};
         this.creatingDevicesDescriptors = {};
@@ -37,7 +38,8 @@ class DeviceList extends events_1.default {
             this.fetchController = (0, AbortController_1.getAbortController)();
             const { signal } = this.fetchController;
             const fetchWithSignal = (args, options = {}) => (0, cross_fetch_1.default)(args, { ...options, signal });
-            BridgeV2.setFetch(fetchWithSignal, typeof window === 'undefined');
+            const isNode = ((_b = (_a = process === null || process === void 0 ? void 0 : process.release) === null || _a === void 0 ? void 0 : _a.name) === null || _b === void 0 ? void 0 : _b.search(/node|io\.js/)) !== -1;
+            BridgeV2.setFetch(fetchWithSignal, isNode);
             transports.push(bridge);
         }
         if (webusb && typeof workers_1.WebUsbPlugin !== 'undefined') {

package/lib/types/api/binance/index.d.ts

@@ -0,0 +1,29 @@
+import type { PROTO } from '../../../constants';
+export interface BinanceSDKTransaction {
+    chain_id: string;
+    account_number?: number;
+    memo?: string;
+    sequence?: number;
+    source?: number;
+    transfer?: PROTO.BinanceTransferMsg;
+    placeOrder?: PROTO.BinanceOrderMsg;
+    cancelOrder?: PROTO.BinanceCancelMsg;
+}
+export declare type BinancePreparedMessage = (PROTO.BinanceTransferMsg & {
+    type: 'BinanceTransferMsg';
+}) | (PROTO.BinanceOrderMsg & {
+    type: 'BinanceOrderMsg';
+}) | (PROTO.BinanceCancelMsg & {
+    type: 'BinanceCancelMsg';
+});
+export interface BinancePreparedTransaction extends BinanceSDKTransaction {
+    messages: BinancePreparedMessage[];
+    account_number: number;
+    sequence: number;
+    source: number;
+}
+export interface BinanceSignTransaction {
+    path: string | number[];
+    transaction: BinanceSDKTransaction;
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/types/api/binance/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

package/lib/types/api/binanceSignTransaction.d.ts

@@ -1,31 +1,5 @@
 import type { PROTO } from '../../constants';
 import type { Params, Response } from '../params';
-export interface BinanceSDKTransaction {
-    chain_id: string;
-    account_number?: number;
-    memo?: string;
-    sequence?: number;
-    source?: number;
-    transfer?: PROTO.BinanceTransferMsg;
-    placeOrder?: PROTO.BinanceOrderMsg;
-    cancelOrder?: PROTO.BinanceCancelMsg;
-}
-export declare type BinancePreparedMessage = (PROTO.BinanceTransferMsg & {
-    type: 'BinanceTransferMsg';
-}) | (PROTO.BinanceOrderMsg & {
-    type: 'BinanceOrderMsg';
-}) | (PROTO.BinanceCancelMsg & {
-    type: 'BinanceCancelMsg';
-});
-export interface BinancePreparedTransaction extends BinanceSDKTransaction {
-    messages: BinancePreparedMessage[];
-    account_number: number;
-    sequence: number;
-    source: number;
-}
-export interface BinanceSignTransaction {
-    path: string | number[];
-    transaction: BinanceSDKTransaction;
-}
+import type { BinanceSignTransaction } from './binance';
 export declare function binanceSignTransaction(params: Params<BinanceSignTransaction>): Response<PROTO.BinanceSignedTx>;
 //# sourceMappingURL=binanceSignTransaction.d.ts.map

package/lib/types/api/bitcoin/index.d.ts

@@ -0,0 +1,82 @@
+import type { PROTO } from '../../../constants';
+import type { AccountAddresses } from '@trezor/blockchain-link';
+export interface SignMessage {
+    path: string | number[];
+    coin: string;
+    message: string;
+    hex?: boolean;
+    no_script_type?: boolean;
+}
+export declare type RefTransaction = {
+    hash: string;
+    version: number;
+    inputs: PROTO.PrevInput[];
+    bin_outputs: PROTO.TxOutputBinType[];
+    outputs?: typeof undefined;
+    lock_time: number;
+    extra_data?: string;
+    expiry?: number;
+    overwintered?: boolean;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+} | {
+    hash: string;
+    version: number;
+    inputs: PROTO.TxInput[];
+    bin_outputs?: typeof undefined;
+    outputs: PROTO.TxOutputType[];
+    lock_time: number;
+    extra_data?: string;
+    expiry?: number;
+    overwintered?: boolean;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+};
+export interface TransactionOptions {
+    version?: number;
+    lock_time?: number;
+    expiry?: number;
+    overwintered?: boolean;
+    version_group_id?: number;
+    timestamp?: number;
+    branch_id?: number;
+    decred_staking_ticket?: boolean;
+    amount_unit?: PROTO.AmountUnit;
+}
+export interface SignTransaction {
+    inputs: PROTO.TxInputType[];
+    outputs: PROTO.TxOutputType[];
+    paymentRequests?: PROTO.TxAckPaymentRequest[];
+    refTxs?: RefTransaction[];
+    account?: {
+        addresses: AccountAddresses;
+    };
+    coin: string;
+    locktime?: number;
+    timestamp?: number;
+    version?: number;
+    expiry?: number;
+    overwintered?: boolean;
+    versionGroupId?: number;
+    branchId?: number;
+    decredStakingTicket?: boolean;
+    push?: boolean;
+    preauthorized?: boolean;
+    amountUnit?: PROTO.AmountUnit;
+}
+export declare type SignedTransaction = {
+    signatures: string[];
+    serializedTx: string;
+    witnesses?: (string | undefined)[];
+    txid?: string;
+};
+export interface VerifyMessage {
+    address: string;
+    signature: string;
+    message: string;
+    coin: string;
+    hex?: boolean;
+}
+//# sourceMappingURL=index.d.ts.map

package/lib/types/api/bitcoin/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,193 @@
+import type { PROTO } from '../../../constants';
+export interface CardanoCertificatePointer {
+    blockIndex: number;
+    txIndex: number;
+    certificateIndex: number;
+}
+export interface CardanoAddressParameters {
+    addressType: PROTO.CardanoAddressType;
+    path?: string | number[];
+    stakingPath?: string | number[];
+    stakingKeyHash?: string;
+    certificatePointer?: CardanoCertificatePointer;
+    paymentScriptHash?: string;
+    stakingScriptHash?: string;
+}
+export interface CardanoGetAddress {
+    addressParameters: CardanoAddressParameters;
+    protocolMagic: number;
+    networkId: number;
+    address?: string;
+    showOnTrezor?: boolean;
+    derivationType?: PROTO.CardanoDerivationType;
+}
+export interface CardanoAddress {
+    addressParameters: CardanoAddressParameters;
+    protocolMagic: number;
+    networkId: number;
+    serializedPath: string;
+    serializedStakingPath: string;
+    address: string;
+}
+export interface CardanoNativeScript {
+    type: PROTO.CardanoNativeScriptType;
+    scripts?: CardanoNativeScript[];
+    keyHash?: string;
+    keyPath?: string | number[];
+    requiredSignaturesCount?: number;
+    invalidBefore?: string;
+    invalidHereafter?: string;
+}
+export interface CardanoGetNativeScriptHash {
+    script: CardanoNativeScript;
+    displayFormat: PROTO.CardanoNativeScriptHashDisplayFormat;
+    derivationType?: PROTO.CardanoDerivationType;
+}
+export interface CardanoNativeScriptHash {
+    scriptHash: string;
+}
+export interface CardanoGetPublicKey {
+    path: string | number[];
+    showOnTrezor?: boolean;
+    derivationType?: PROTO.CardanoDerivationType;
+}
+export interface CardanoPublicKey {
+    path: number[];
+    serializedPath: string;
+    publicKey: string;
+    node: PROTO.HDNodeType;
+}
+export interface CardanoInput {
+    path?: string | number[];
+    prev_hash: string;
+    prev_index: number;
+}
+export interface CardanoToken {
+    assetNameBytes: string;
+    amount?: string;
+    mintAmount?: string;
+}
+export interface CardanoAssetGroup {
+    policyId: string;
+    tokenAmounts: CardanoToken[];
+}
+export declare type CardanoOutput = ({
+    addressParameters: CardanoAddressParameters;
+} | {
+    address: string;
+}) & {
+    amount: string;
+    tokenBundle?: CardanoAssetGroup[];
+    datumHash?: string;
+    format?: PROTO.CardanoTxOutputSerializationFormat;
+    inlineDatum?: string;
+    referenceScript?: string;
+};
+export interface CardanoPoolOwner {
+    stakingKeyPath?: string | number[];
+    stakingKeyHash?: string;
+}
+export interface CardanoPoolRelay {
+    type: PROTO.CardanoPoolRelayType;
+    ipv4Address?: string;
+    ipv6Address?: string;
+    port?: number;
+    hostName?: string;
+}
+export interface CardanoPoolMetadata {
+    url: string;
+    hash: string;
+}
+export interface CardanoPoolMargin {
+    numerator: string;
+    denominator: string;
+}
+export interface CardanoPoolParameters {
+    poolId: string;
+    vrfKeyHash: string;
+    pledge: string;
+    cost: string;
+    margin: CardanoPoolMargin;
+    rewardAccount: string;
+    owners: CardanoPoolOwner[];
+    relays: CardanoPoolRelay[];
+    metadata: CardanoPoolMetadata;
+}
+export interface CardanoCertificate {
+    type: PROTO.CardanoCertificateType;
+    path?: string | number[];
+    pool?: string;
+    poolParameters?: CardanoPoolParameters;
+    scriptHash?: string;
+    keyHash?: string;
+}
+export interface CardanoWithdrawal {
+    path?: string | number[];
+    amount: string;
+    scriptHash?: string;
+    keyHash?: string;
+}
+export declare type CardanoMint = CardanoAssetGroup[];
+export interface CardanoCollateralInput {
+    path?: string | number[];
+    prev_hash: string;
+    prev_index: number;
+}
+export interface CardanoRequiredSigner {
+    keyPath?: string | number[];
+    keyHash?: string;
+}
+export interface CardanoReferenceInput {
+    prev_hash: string;
+    prev_index: number;
+}
+export interface CardanoCatalystRegistrationParameters {
+    votingPublicKey: string;
+    stakingPath: string | number[];
+    rewardAddressParameters: CardanoAddressParameters;
+    nonce: string;
+}
+export interface CardanoAuxiliaryData {
+    hash?: string;
+    catalystRegistrationParameters?: CardanoCatalystRegistrationParameters;
+}
+export interface CardanoSignTransaction {
+    inputs: CardanoInput[];
+    outputs: CardanoOutput[];
+    fee: string;
+    ttl?: string;
+    certificates?: CardanoCertificate[];
+    withdrawals?: CardanoWithdrawal[];
+    validityIntervalStart?: string;
+    auxiliaryData?: CardanoAuxiliaryData;
+    mint?: CardanoMint;
+    scriptDataHash?: string;
+    collateralInputs?: CardanoCollateralInput[];
+    requiredSigners?: CardanoRequiredSigner[];
+    collateralReturn?: CardanoOutput;
+    totalCollateral?: string;
+    referenceInputs?: CardanoReferenceInput[];
+    additionalWitnessRequests?: (string | number[])[];
+    protocolMagic: number;
+    networkId: number;
+    signingMode: PROTO.CardanoTxSigningMode;
+    derivationType?: PROTO.CardanoDerivationType;
+    includeNetworkId?: boolean;
+}
+export interface CardanoSignedTxWitness {
+    type: PROTO.CardanoTxWitnessType;
+    pubKey: string;
+    signature: string;
+    chainCode?: string;
+}
+export interface CardanoAuxiliaryDataSupplement {
+    type: PROTO.CardanoTxAuxiliaryDataSupplementType;
+    auxiliaryDataHash: string;
+    catalystSignature?: string;
+}
+export interface CardanoSignedTxData {
+    hash: string;
+    witnesses: CardanoSignedTxWitness[];
+    auxiliaryDataSupplement?: CardanoAuxiliaryDataSupplement;
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=index.js.map