@trezor/connect 9.0.0-beta.1

package/lib/exports.d.ts

@@ -0,0 +1,5 @@
+export * from './constants';
+export * from './events';
+export * from './types';
+export { parseConnectSettings } from './data/connectSettings';
+//# sourceMappingURL=exports.d.ts.map

package/lib/exports.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseConnectSettings = void 0;
+const tslib_1 = require("tslib");
+(0, tslib_1.__exportStar)(require("./constants"), exports);
+(0, tslib_1.__exportStar)(require("./events"), exports);
+(0, tslib_1.__exportStar)(require("./types"), exports);
+var connectSettings_1 = require("./data/connectSettings");
+Object.defineProperty(exports, "parseConnectSettings", { enumerable: true, get: function () { return connectSettings_1.parseConnectSettings; } });
+//# sourceMappingURL=exports.js.map

package/lib/factory.d.ts

@@ -0,0 +1,20 @@
+/// <reference types="node" />
+import type { EventEmitter } from 'events';
+import type { TrezorConnect } from './types';
+import type { CallMethod } from './events/call';
+interface Dependencies {
+    call: CallMethod;
+    eventEmitter: EventEmitter;
+    manifest: TrezorConnect['manifest'];
+    init: TrezorConnect['init'];
+    customMessage: TrezorConnect['customMessage'];
+    requestLogin: TrezorConnect['requestLogin'];
+    uiResponse: TrezorConnect['uiResponse'];
+    renderWebUSBButton: TrezorConnect['renderWebUSBButton'];
+    disableWebUSB: TrezorConnect['disableWebUSB'];
+    cancel: TrezorConnect['cancel'];
+    dispose: TrezorConnect['dispose'];
+}
+export declare const factory: ({ eventEmitter, manifest, init, call, customMessage, requestLogin, uiResponse, renderWebUSBButton, disableWebUSB, cancel, dispose, }: Dependencies) => TrezorConnect;
+export {};
+//# sourceMappingURL=factory.d.ts.map

package/lib/factory.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factory = void 0;
+const events_1 = require("./events");
+const factory = ({ eventEmitter, manifest, init, call, customMessage, requestLogin, uiResponse, renderWebUSBButton, disableWebUSB, cancel, dispose, }) => {
+    const api = {
+        manifest,
+        init,
+        getSettings: () => call({ method: 'getSettings' }),
+        on: (type, fn) => {
+            eventEmitter.on(type, fn);
+        },
+        off: (type, fn) => {
+            eventEmitter.removeListener(type, fn);
+        },
+        removeAllListeners: type => {
+            eventEmitter.removeAllListeners(type);
+        },
+        uiResponse,
+        blockchainGetAccountBalanceHistory: params => call({ ...params, method: 'blockchainGetAccountBalanceHistory' }),
+        blockchainGetCurrentFiatRates: params => call({ ...params, method: 'blockchainGetCurrentFiatRates' }),
+        blockchainGetFiatRatesForTimestamps: params => call({ ...params, method: 'blockchainGetFiatRatesForTimestamps' }),
+        blockchainDisconnect: params => call({ ...params, method: 'blockchainDisconnect' }),
+        blockchainEstimateFee: params => call({ ...params, method: 'blockchainEstimateFee' }),
+        blockchainGetTransactions: params => call({ ...params, method: 'blockchainGetTransactions' }),
+        blockchainSetCustomBackend: params => call({ ...params, method: 'blockchainSetCustomBackend' }),
+        blockchainSubscribe: params => call({ ...params, method: 'blockchainSubscribe' }),
+        blockchainSubscribeFiatRates: params => call({ ...params, method: 'blockchainSubscribeFiatRates' }),
+        blockchainUnsubscribe: params => call({ ...params, method: 'blockchainUnsubscribe' }),
+        blockchainUnsubscribeFiatRates: params => call({ ...params, method: 'blockchainUnsubscribeFiatRates' }),
+        customMessage: params => customMessage(params),
+        requestLogin: params => requestLogin(params),
+        cardanoGetAddress: params => call({
+            ...params,
+            method: 'cardanoGetAddress',
+            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+        }),
+        cardanoGetNativeScriptHash: params => call({ ...params, method: 'cardanoGetNativeScriptHash' }),
+        cardanoGetPublicKey: params => call({ ...params, method: 'cardanoGetPublicKey' }),
+        cardanoSignTransaction: params => call({ ...params, method: 'cardanoSignTransaction' }),
+        cipherKeyValue: params => call({ ...params, method: 'cipherKeyValue' }),
+        composeTransaction: params => call({ ...params, method: 'composeTransaction' }),
+        ethereumGetAddress: params => call({
+            ...params,
+            method: 'ethereumGetAddress',
+            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+        }),
+        ethereumGetPublicKey: params => call({ ...params, method: 'ethereumGetPublicKey' }),
+        ethereumSignMessage: params => call({ ...params, method: 'ethereumSignMessage' }),
+        ethereumSignTransaction: params => call({ ...params, method: 'ethereumSignTransaction' }),
+        ethereumSignTypedData: params => call({ ...params, method: 'ethereumSignTypedData' }),
+        ethereumVerifyMessage: params => call({ ...params, method: 'ethereumVerifyMessage' }),
+        getAccountInfo: params => call({ ...params, method: 'getAccountInfo' }),
+        getAddress: params => call({
+            ...params,
+            method: 'getAddress',
+            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+        }),
+        getDeviceState: params => call({ ...params, method: 'getDeviceState' }),
+        getFeatures: params => call({ ...params, method: 'getFeatures' }),
+        getOwnershipId: params => call({ ...params, method: 'getOwnershipId' }),
+        getOwnershipProof: params => call({ ...params, method: 'getOwnershipProof' }),
+        getPublicKey: params => call({ ...params, method: 'getPublicKey' }),
+        nemGetAddress: params => call({
+            ...params,
+            method: 'nemGetAddress',
+            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+        }),
+        nemSignTransaction: params => call({ ...params, method: 'nemSignTransaction' }),
+        pushTransaction: params => call({ ...params, method: 'pushTransaction' }),
+        rippleGetAddress: params => call({
+            ...params,
+            method: 'rippleGetAddress',
+            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+        }),
+        rippleSignTransaction: params => call({ ...params, method: 'rippleSignTransaction' }),
+        signMessage: params => call({ ...params, method: 'signMessage' }),
+        signTransaction: params => call({ ...params, method: 'signTransaction' }),
+        stellarGetAddress: params => call({
+            ...params,
+            method: 'stellarGetAddress',
+            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+        }),
+        stellarSignTransaction: params => call({ ...params, method: 'stellarSignTransaction' }),
+        tezosGetAddress: params => call({
+            ...params,
+            method: 'tezosGetAddress',
+            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+        }),
+        tezosGetPublicKey: params => call({ ...params, method: 'tezosGetPublicKey' }),
+        tezosSignTransaction: params => call({ ...params, method: 'tezosSignTransaction' }),
+        eosGetPublicKey: params => call({ ...params, method: 'eosGetPublicKey' }),
+        eosSignTransaction: params => call({ ...params, method: 'eosSignTransaction' }),
+        binanceGetAddress: params => call({
+            ...params,
+            method: 'binanceGetAddress',
+            useEventListener: eventEmitter.listenerCount(events_1.UI.ADDRESS_VALIDATION) > 0,
+        }),
+        binanceGetPublicKey: params => call({ ...params, method: 'binanceGetPublicKey' }),
+        binanceSignTransaction: params => call({ ...params, method: 'binanceSignTransaction' }),
+        verifyMessage: params => call({ ...params, method: 'verifyMessage' }),
+        resetDevice: params => call({ ...params, method: 'resetDevice' }),
+        wipeDevice: params => call({ ...params, method: 'wipeDevice' }),
+        applyFlags: params => call({ ...params, method: 'applyFlags' }),
+        applySettings: params => call({ ...params, method: 'applySettings' }),
+        authorizeCoinJoin: params => call({ ...params, method: 'authorizeCoinJoin' }),
+        backupDevice: params => call({ ...params, method: 'backupDevice' }),
+        changePin: params => call({ ...params, method: 'changePin' }),
+        firmwareUpdate: params => call({ ...params, method: 'firmwareUpdate' }),
+        recoveryDevice: params => call({ ...params, method: 'recoveryDevice' }),
+        getCoinInfo: params => call({ ...params, method: 'getCoinInfo' }),
+        rebootToBootloader: params => call({ ...params, method: 'rebootToBootloader' }),
+        setProxy: params => call({ ...params, method: 'setProxy' }),
+        dispose,
+        cancel,
+        renderWebUSBButton,
+        disableWebUSB,
+    };
+    return api;
+};
+exports.factory = factory;
+//# sourceMappingURL=factory.js.map

package/lib/index-browser.d.ts

@@ -0,0 +1,4 @@
+declare const TrezorConnect: import("./exports").TrezorConnect;
+export default TrezorConnect;
+export * from './exports';
+//# sourceMappingURL=index-browser.d.ts.map

package/lib/index-browser.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const errors_1 = require("./constants/errors");
+const factory_1 = require("./factory");
+const fallback = () => {
+    throw (0, errors_1.TypedError)('Method_InvalidPackage');
+};
+const TrezorConnect = (0, factory_1.factory)({
+    eventEmitter: {
+        on: fallback,
+        off: fallback,
+        removeAllListeners: fallback,
+        listenerCount: fallback,
+    },
+    manifest: fallback,
+    init: fallback,
+    call: fallback,
+    customMessage: fallback,
+    requestLogin: fallback,
+    uiResponse: fallback,
+    renderWebUSBButton: fallback,
+    disableWebUSB: fallback,
+    cancel: fallback,
+    dispose: fallback,
+});
+exports.default = TrezorConnect;
+(0, tslib_1.__exportStar)(require("./exports"), exports);
+//# sourceMappingURL=index-browser.js.map

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { Deferred } from '@trezor/utils';
+export declare const eventEmitter: EventEmitter;
+export declare const messagePromises: {
+    [key: number]: Deferred<any>;
+};
+declare const TrezorConnect: import("./types").TrezorConnect;
+export default TrezorConnect;
+export * from './exports';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.messagePromises = exports.eventEmitter = void 0;
+const tslib_1 = require("tslib");
+const events_1 = (0, tslib_1.__importDefault)(require("events"));
+const utils_1 = require("@trezor/utils");
+const core_1 = require("./core");
+const factory_1 = require("./factory");
+const connectSettings_1 = require("./data/connectSettings");
+const debug_1 = require("./utils/debug");
+const events_2 = require("./events");
+const constants_1 = require("./constants");
+exports.eventEmitter = new events_1.default();
+const _log = (0, debug_1.initLog)('@trezor/connect');
+let _settings = (0, connectSettings_1.parseConnectSettings)();
+let _core = null;
+let _messageID = 0;
+exports.messagePromises = {};
+const manifest = (data) => {
+    _settings = (0, connectSettings_1.parseConnectSettings)({
+        ..._settings,
+        manifest: data,
+    });
+};
+const dispose = () => {
+    exports.eventEmitter.removeAllListeners();
+    _settings = (0, connectSettings_1.parseConnectSettings)();
+    if (_core) {
+        _core.dispose();
+        _core = null;
+    }
+};
+const handleMessage = (message) => {
+    const { event, type, payload } = message;
+    const id = message.id || 0;
+    if (!_core)
+        return;
+    if (type === events_2.UI.REQUEST_UI_WINDOW) {
+        _core.handleMessage({ event: events_2.UI_EVENT, type: events_2.POPUP.HANDSHAKE }, true);
+        return;
+    }
+    if (type === events_2.POPUP.CANCEL_POPUP_REQUEST)
+        return;
+    _log.debug('handleMessage', message);
+    switch (event) {
+        case events_2.RESPONSE_EVENT:
+            if (exports.messagePromises[id]) {
+                exports.messagePromises[id].resolve({
+                    id,
+                    success: message.success,
+                    payload,
+                });
+                delete exports.messagePromises[id];
+            }
+            else {
+                _log.warn(`Unknown message id ${id}`);
+            }
+            break;
+        case events_2.DEVICE_EVENT:
+            exports.eventEmitter.emit(event, message);
+            exports.eventEmitter.emit(type, payload);
+            break;
+        case events_2.TRANSPORT_EVENT:
+            exports.eventEmitter.emit(event, message);
+            exports.eventEmitter.emit(type, payload);
+            break;
+        case events_2.BLOCKCHAIN_EVENT:
+            exports.eventEmitter.emit(event, message);
+            exports.eventEmitter.emit(type, payload);
+            break;
+        case events_2.UI_EVENT:
+            exports.eventEmitter.emit(event, message);
+            exports.eventEmitter.emit(type, payload);
+            break;
+        default:
+            _log.warn('Undefined message', event, message);
+    }
+};
+function postMessage(message, usePromise = true) {
+    if (!_core) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'postMessage: _core not found');
+    }
+    if (usePromise) {
+        _messageID++;
+        exports.messagePromises[_messageID] = (0, utils_1.createDeferred)();
+        const { promise } = exports.messagePromises[_messageID];
+        _core.handleMessage({ ...message, id: _messageID }, true);
+        return promise;
+    }
+    _core.handleMessage(message, true);
+}
+const init = async (settings = {}) => {
+    if (_core) {
+        throw constants_1.ERRORS.TypedError('Init_AlreadyInitialized');
+    }
+    _settings = (0, connectSettings_1.parseConnectSettings)({ ..._settings, ...settings });
+    _settings.origin = 'http://node.trezor.io/';
+    _settings.popup = false;
+    _settings.env = 'node';
+    if (!_settings.manifest) {
+        throw constants_1.ERRORS.TypedError('Init_ManifestMissing');
+    }
+    if (_settings.lazyLoad) {
+        _settings.lazyLoad = false;
+        return;
+    }
+    _core = await (0, core_1.init)(_settings);
+    _core.on(events_2.CORE_EVENT, handleMessage);
+    await (0, core_1.initTransport)(_settings);
+};
+const call = async (params) => {
+    if (!_core) {
+        try {
+            await init(_settings);
+        }
+        catch (error) {
+            return (0, events_2.createErrorMessage)(error);
+        }
+    }
+    try {
+        const response = await postMessage({
+            type: events_2.IFRAME.CALL,
+            payload: params,
+        });
+        if (response) {
+            return response;
+        }
+        return (0, events_2.createErrorMessage)(constants_1.ERRORS.TypedError('Method_NoResponse'));
+    }
+    catch (error) {
+        _log.error('call', error);
+        return (0, events_2.createErrorMessage)(error);
+    }
+};
+const customMessageResponse = (payload) => {
+    if (!_core) {
+        return Promise.resolve((0, events_2.createErrorMessage)(constants_1.ERRORS.TypedError('Init_NotInitialized')));
+    }
+    _core.handleMessage({
+        event: events_2.UI_EVENT,
+        type: events_2.UI.CUSTOM_MESSAGE_RESPONSE,
+        payload,
+    }, true);
+};
+const uiResponse = (response) => {
+    if (!_core) {
+        throw constants_1.ERRORS.TypedError('Init_NotInitialized');
+    }
+    const { type, payload } = response;
+    _core.handleMessage({ event: events_2.UI_EVENT, type, payload }, true);
+};
+const customMessage = async (params) => {
+    if (typeof params.callback !== 'function') {
+        return (0, events_2.createErrorMessage)(constants_1.ERRORS.TypedError('Method_CustomMessage_Callback'));
+    }
+    const { callback } = params;
+    const customMessageListener = async (event) => {
+        const { data } = event;
+        if (data && data.type === events_2.UI.CUSTOM_MESSAGE_REQUEST) {
+            const payload = await callback(data.payload);
+            if (payload) {
+                customMessageResponse(payload);
+            }
+            else {
+                customMessageResponse({ message: 'release' });
+            }
+        }
+    };
+    _core === null || _core === void 0 ? void 0 : _core.on(events_2.CORE_EVENT, customMessageListener);
+    const response = await call({ method: 'customMessage', ...params, callback: null });
+    _core === null || _core === void 0 ? void 0 : _core.removeListener(events_2.CORE_EVENT, customMessageListener);
+    return response;
+};
+const requestLogin = async (params) => {
+    if (typeof params.callback === 'function') {
+        const { callback } = params;
+        const loginChallengeListener = async (event) => {
+            const { data } = event;
+            if (data && data.type === events_2.UI.LOGIN_CHALLENGE_REQUEST) {
+                try {
+                    const payload = await callback();
+                    _core === null || _core === void 0 ? void 0 : _core.handleMessage({
+                        event: events_2.UI_EVENT,
+                        type: events_2.UI.LOGIN_CHALLENGE_RESPONSE,
+                        payload,
+                    }, true);
+                }
+                catch (error) {
+                    _core === null || _core === void 0 ? void 0 : _core.handleMessage({
+                        event: events_2.UI_EVENT,
+                        type: events_2.UI.LOGIN_CHALLENGE_RESPONSE,
+                        payload: error.message,
+                    }, true);
+                }
+            }
+        };
+        _core === null || _core === void 0 ? void 0 : _core.on(events_2.CORE_EVENT, loginChallengeListener);
+        const response = await call({
+            method: 'requestLogin',
+            ...params,
+            asyncChallenge: true,
+            callback: null,
+        });
+        _core === null || _core === void 0 ? void 0 : _core.removeListener(events_2.CORE_EVENT, loginChallengeListener);
+        return response;
+    }
+    return call({ method: 'requestLogin', ...params });
+};
+const cancel = (error) => {
+    postMessage({
+        type: events_2.POPUP.CLOSED,
+        payload: error ? { error } : null,
+    }, false);
+};
+const renderWebUSBButton = (_className) => {
+    throw constants_1.ERRORS.TypedError('Method_InvalidPackage');
+};
+const disableWebUSB = () => {
+    throw constants_1.ERRORS.TypedError('Method_InvalidPackage');
+};
+const TrezorConnect = (0, factory_1.factory)({
+    eventEmitter: exports.eventEmitter,
+    manifest,
+    init,
+    call,
+    customMessage,
+    requestLogin,
+    uiResponse,
+    renderWebUSBButton,
+    disableWebUSB,
+    cancel,
+    dispose,
+});
+exports.default = TrezorConnect;
+(0, tslib_1.__exportStar)(require("./exports"), exports);
+//# sourceMappingURL=index.js.map

package/lib/types/account.d.ts

@@ -0,0 +1,37 @@
+import type { AccountInfo as AccountInfoBase, AccountAddresses, Utxo as AccountUtxo } from '@trezor/blockchain-link';
+export type { AccountAddresses, Utxo as AccountUtxo, Address as AccountAddress, } from '@trezor/blockchain-link';
+export declare type DiscoveryAccountType = 'p2pkh' | 'p2sh' | 'p2tr' | 'p2wpkh';
+export interface AccountInfo extends AccountInfoBase {
+    path?: string;
+    legacyXpub?: string;
+    utxo?: AccountUtxo[];
+}
+export interface DiscoveryAccount {
+    type: DiscoveryAccountType;
+    label: string;
+    descriptor: string;
+    address_n: number[];
+    empty?: boolean;
+    balance?: string;
+    addresses?: AccountAddresses;
+}
+export interface FeeLevel {
+    label: 'high' | 'normal' | 'economy' | 'low' | 'custom';
+    feePerUnit: string;
+    blocks: number;
+    feeLimit?: string;
+    feePerTx?: string;
+}
+export declare type SelectFeeLevel = {
+    name: string;
+    fee: '0';
+    feePerByte?: undefined;
+    disabled: true;
+} | {
+    name: string;
+    fee: string;
+    feePerByte: string;
+    minutes: number;
+    total: string;
+};
+//# sourceMappingURL=account.d.ts.map

package/lib/types/account.js

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

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

@@ -0,0 +1,4 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export declare function applyFlags(params: Params<PROTO.ApplyFlags>): Response<PROTO.Success>;
+//# sourceMappingURL=applyFlags.d.ts.map

package/lib/types/api/applyFlags.js

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

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

@@ -0,0 +1,4 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export declare function applySettings(params: Params<PROTO.ApplySettings>): Response<PROTO.Success>;
+//# sourceMappingURL=applySettings.d.ts.map

package/lib/types/api/applySettings.js

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

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

@@ -0,0 +1,14 @@
+import type { PROTO } from '../../constants';
+import type { Params, Response } from '../params';
+export interface AuthorizeCoinJoin {
+    path: string | number[];
+    coordinator: string;
+    maxRounds: number;
+    maxCoordinatorFeeRate: number;
+    maxFeePerKvbyte: number;
+    coin?: string;
+    scriptType?: PROTO.InternalInputScriptType;
+    amountUnit?: PROTO.AmountUnit;
+}
+export declare function authorizeCoinJoin(params: Params<AuthorizeCoinJoin>): Response<PROTO.Success>;
+//# sourceMappingURL=authorizeCoinJoin.d.ts.map

package/lib/types/api/authorizeCoinJoin.js

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

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

@@ -0,0 +1,4 @@
+import type { PROTO } from '../../constants';
+import type { CommonParams, Response } from '../params';
+export declare function backupDevice(params?: CommonParams): Response<PROTO.Success>;
+//# sourceMappingURL=backupDevice.d.ts.map

package/lib/types/api/backupDevice.js

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

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

@@ -0,0 +1,4 @@
+import type { GetAddress, Address, Params, BundledParams, Response } from '../params';
+export declare function binanceGetAddress(params: Params<GetAddress>): Response<Address>;
+export declare function binanceGetAddress(params: BundledParams<GetAddress>): Response<Address[]>;
+//# sourceMappingURL=binanceGetAddress.d.ts.map

package/lib/types/api/binanceGetAddress.js

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

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

@@ -0,0 +1,4 @@
+import type { GetPublicKey, PublicKey, Params, BundledParams, Response } from '../params';
+export declare function binanceGetPublicKey(params: Params<GetPublicKey>): Response<PublicKey>;
+export declare function binanceGetPublicKey(params: BundledParams<GetPublicKey>): Response<PublicKey[]>;
+//# sourceMappingURL=binanceGetPublicKey.d.ts.map

package/lib/types/api/binanceGetPublicKey.js

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

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

@@ -0,0 +1,31 @@
+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;
+}
+export declare function binanceSignTransaction(params: Params<BinanceSignTransaction>): Response<PROTO.BinanceSignedTx>;
+//# sourceMappingURL=binanceSignTransaction.d.ts.map

package/lib/types/api/binanceSignTransaction.js

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

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

@@ -0,0 +1,5 @@
+import type { CommonParamsWithCoin, Response } from '../params';
+export declare function blockchainDisconnect(params: CommonParamsWithCoin): Response<{
+    disconnected: boolean;
+}>;
+//# sourceMappingURL=blockchainDisconnect.d.ts.map

package/lib/types/api/blockchainDisconnect.js

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

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

@@ -0,0 +1,29 @@
+import type { BlockchainLinkParams, BlockchainLinkResponse } from '@trezor/blockchain-link';
+import type { FeeLevel } from '../account';
+import type { CommonParamsWithCoin, Response } from '../params';
+export interface BlockchainEstimateFee {
+    request?: BlockchainLinkParams<'estimateFee'> & {
+        feeLevels?: undefined;
+    };
+}
+export interface BlockchainEstimateFeeLevel {
+    request: BlockchainLinkParams<'estimateFee'> & {
+        feeLevels: 'preloaded' | 'smart';
+    };
+}
+interface EstimatedFee {
+    blockTime: number;
+    minFee: number;
+    maxFee: number;
+    dustLimit?: number;
+}
+export interface BlockchainEstimatedFee extends EstimatedFee {
+    levels: BlockchainLinkResponse<'estimateFee'>;
+}
+export interface BlockchainEstimatedFeeLevel extends EstimatedFee {
+    levels: FeeLevel[];
+}
+export declare function blockchainEstimateFee(params: CommonParamsWithCoin & BlockchainEstimateFee): Response<BlockchainEstimatedFee>;
+export declare function blockchainEstimateFee(params: CommonParamsWithCoin & BlockchainEstimateFeeLevel): Response<BlockchainEstimatedFeeLevel>;
+export {};
+//# sourceMappingURL=blockchainEstimateFee.d.ts.map

package/lib/types/api/blockchainEstimateFee.js

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

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

@@ -0,0 +1,4 @@
+import type { BlockchainLinkParams, BlockchainLinkResponse } from '@trezor/blockchain-link';
+import type { CommonParamsWithCoin, Response } from '../params';
+export declare function blockchainGetAccountBalanceHistory(params: CommonParamsWithCoin & BlockchainLinkParams<'getAccountBalanceHistory'>): Response<BlockchainLinkResponse<'getAccountBalanceHistory'>>;
+//# sourceMappingURL=blockchainGetAccountBalanceHistory.d.ts.map