@trezor/connect 9.0.0-beta.1

package/lib/backend/BlockchainLink.d.ts

@@ -0,0 +1,75 @@
+import BlockchainLink, { ServerInfo, SubscriptionAccountInfo, BlockchainLinkParams, BlockchainLinkResponse } from '@trezor/blockchain-link';
+import { ERRORS } from '../constants';
+import type { CoinInfo, Proxy } from '../types';
+import type { CoreMessage } from '../events';
+declare type Options = {
+    coinInfo: CoinInfo;
+    postMessage: (message: CoreMessage) => void;
+    proxy?: Proxy;
+    onionDomains?: {
+        [domain: string]: string;
+    };
+    debug?: boolean;
+};
+export declare class Blockchain {
+    link: BlockchainLink;
+    serverInfo?: ServerInfo;
+    coinInfo: Options['coinInfo'];
+    onionDomains: {
+        [onion: string]: string;
+    };
+    postMessage: Options['postMessage'];
+    feeForBlock: BlockchainLinkResponse<'estimateFee'>;
+    feeTimestamp: number;
+    constructor(options: Options);
+    onError(error: ERRORS.TrezorError): void;
+    init(): Promise<void>;
+    getTransactions(txs: string[]): Promise<import("@trezor/blockchain-link").TypedRawTransaction[]>;
+    getCurrentFiatRates(params: {
+        currencies?: string[];
+    }): Promise<{
+        ts: number;
+        rates: import("@trezor/blockchain-link").FiatRates;
+    }>;
+    getFiatRatesForTimestamps(params: {
+        timestamps: number[];
+    }): Promise<{
+        tickers: {
+            ts: number;
+            rates: import("@trezor/blockchain-link").FiatRates;
+        }[];
+    }>;
+    getAccountBalanceHistory(params: BlockchainLinkParams<'getAccountBalanceHistory'>): Promise<import("@trezor/blockchain-link").AccountBalanceHistory[]>;
+    getNetworkInfo(): Promise<ServerInfo>;
+    getAccountInfo(request: BlockchainLinkParams<'getAccountInfo'>): Promise<import("@trezor/blockchain-link").AccountInfo>;
+    getAccountUtxo(descriptor: string): Promise<import("@trezor/blockchain-link").Utxo[]>;
+    estimateFee(request: {
+        blocks?: number[];
+    }): Promise<{
+        feePerUnit: string;
+        feePerTx?: string | undefined;
+        feeLimit?: string | undefined;
+    }[]>;
+    subscribe(accounts?: SubscriptionAccountInfo[]): Promise<{
+        subscribed: boolean;
+    }>;
+    subscribeFiatRates(_currency?: string): Promise<{
+        subscribed: boolean;
+    }>;
+    unsubscribe(accounts?: SubscriptionAccountInfo[]): Promise<{
+        subscribed: boolean;
+    }>;
+    unsubscribeFiatRates(): Promise<{
+        subscribed: boolean;
+    }>;
+    pushTransaction(tx: string): Promise<string>;
+    disconnect(): void;
+}
+export declare const findBackend: (name: string) => Blockchain | null;
+export declare const setCustomBackend: (coinInfo: CoinInfo, blockchainLink: CoinInfo['blockchainLink']) => void;
+export declare const isBackendSupported: (coinInfo: CoinInfo) => void;
+export declare const initBlockchain: (coinInfo: CoinInfo, postMessage: Options['postMessage']) => Promise<Blockchain>;
+export declare const reconnectAllBackends: () => Promise<Blockchain[]>;
+export declare const dispose: () => void;
+export {};
+//# sourceMappingURL=BlockchainLink.d.ts.map

package/lib/backend/BlockchainLink.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dispose = exports.reconnectAllBackends = exports.initBlockchain = exports.isBackendSupported = exports.setCustomBackend = exports.findBackend = exports.Blockchain = void 0;
+const tslib_1 = require("tslib");
+const blockchain_link_1 = (0, tslib_1.__importDefault)(require("@trezor/blockchain-link"));
+const config_1 = require("../data/config");
+const DataManager_1 = require("../data/DataManager");
+const events_1 = require("../events");
+const constants_1 = require("../constants");
+const urlUtils_1 = require("../utils/urlUtils");
+const workers_1 = require("../workers/workers");
+const getWorker = (type) => {
+    switch (type) {
+        case 'blockbook':
+            return workers_1.BlockbookWorker;
+        case 'ripple':
+            return workers_1.RippleWorker;
+        case 'blockfrost':
+            return workers_1.BlockfrostWorker;
+        case 'electrum':
+            return workers_1.ElectrumWorker;
+        default:
+            return null;
+    }
+};
+class Blockchain {
+    constructor(options) {
+        this.feeForBlock = [];
+        this.feeTimestamp = 0;
+        this.coinInfo = options.coinInfo;
+        this.postMessage = options.postMessage;
+        const { blockchainLink } = options.coinInfo;
+        if (!blockchainLink) {
+            throw constants_1.ERRORS.TypedError('Backend_NotSupported');
+        }
+        const worker = getWorker(blockchainLink.type);
+        if (!worker) {
+            throw constants_1.ERRORS.TypedError('Backend_WorkerMissing', `BlockchainLink worker not found ${blockchainLink.type}`);
+        }
+        const { onionDomains } = options;
+        this.onionDomains = onionDomains
+            ? blockchainLink.url.reduce((a, url) => {
+                const onion = (0, urlUtils_1.getOnionDomain)(url, onionDomains);
+                if (onion !== url) {
+                    a[onion] = url;
+                }
+                return a;
+            }, {})
+            : {};
+        const server = Object.keys(this.onionDomains).length
+            ? Object.keys(this.onionDomains)
+            : blockchainLink.url;
+        this.link = new blockchain_link_1.default({
+            name: this.coinInfo.shortcut,
+            worker,
+            server,
+            debug: options.debug,
+            proxy: options.proxy,
+        });
+    }
+    onError(error) {
+        this.link.dispose();
+        this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.ERROR, {
+            coin: this.coinInfo,
+            error: error.message,
+            code: error.code,
+        }));
+        removeBackend(this);
+    }
+    async init() {
+        this.link.on('connected', async () => {
+            const info = await this.link.getInfo();
+            this.serverInfo = info;
+            const shortcut = this.coinInfo.shortcut === 'tXRP' ? 'XRP' : this.coinInfo.shortcut;
+            if (info.shortcut.toLowerCase() !== shortcut.toLowerCase()) {
+                this.onError(constants_1.ERRORS.TypedError('Backend_Invalid'));
+                return;
+            }
+            const cleanUrl = this.onionDomains[info.url];
+            setPreferredBacked(this.coinInfo, cleanUrl || info.url);
+            this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.CONNECT, {
+                coin: this.coinInfo,
+                ...info,
+                cleanUrl,
+            }));
+        });
+        this.link.on('disconnected', () => {
+            this.onError(constants_1.ERRORS.TypedError('Backend_Disconnected'));
+        });
+        this.link.on('error', error => {
+            this.onError(constants_1.ERRORS.TypedError('Backend_Error', error.message));
+        });
+        try {
+            await this.link.connect();
+        }
+        catch (error) {
+            this.onError(constants_1.ERRORS.TypedError('Backend_Error', error.message));
+            throw error;
+        }
+    }
+    getTransactions(txs) {
+        return Promise.all(txs.map(id => this.link.getTransaction(id)));
+    }
+    getCurrentFiatRates(params) {
+        return this.link.getCurrentFiatRates(params);
+    }
+    getFiatRatesForTimestamps(params) {
+        return this.link.getFiatRatesForTimestamps(params);
+    }
+    getAccountBalanceHistory(params) {
+        return this.link.getAccountBalanceHistory(params);
+    }
+    getNetworkInfo() {
+        return this.link.getInfo();
+    }
+    getAccountInfo(request) {
+        return this.link.getAccountInfo(request);
+    }
+    getAccountUtxo(descriptor) {
+        return this.link.getAccountUtxo(descriptor);
+    }
+    async estimateFee(request) {
+        const { blocks } = request;
+        if (blocks) {
+            const now = Date.now();
+            const outdated = now - this.feeTimestamp > 20 * 60 * 1000;
+            const unknownBlocks = blocks.filter(() => typeof this.feeForBlock !== 'string');
+            if (!outdated && unknownBlocks.length < 1) {
+            }
+            const fees = await this.link.estimateFee(request);
+            blocks.forEach((block, index) => {
+                this.feeForBlock[block] = fees[index];
+            });
+            this.feeTimestamp = now;
+            return fees;
+        }
+        return this.link.estimateFee(request);
+    }
+    async subscribe(accounts) {
+        if (this.link.listenerCount('block') === 0) {
+            this.link.on('block', block => {
+                this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.BLOCK, {
+                    coin: this.coinInfo,
+                    ...block,
+                }));
+            });
+        }
+        if (this.link.listenerCount('notification') === 0) {
+            this.link.on('notification', notification => {
+                this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.NOTIFICATION, {
+                    coin: this.coinInfo,
+                    notification,
+                }));
+            });
+        }
+        const blockSubscription = await this.link.subscribe({ type: 'block' });
+        if (!accounts) {
+            return blockSubscription;
+        }
+        return this.link.subscribe({
+            type: 'accounts',
+            accounts,
+        });
+    }
+    subscribeFiatRates(_currency) {
+        if (this.link.listenerCount('fiatRates') === 0) {
+            this.link.on('fiatRates', ({ rates }) => {
+                this.postMessage((0, events_1.createBlockchainMessage)(events_1.BLOCKCHAIN.FIAT_RATES_UPDATE, {
+                    coin: this.coinInfo,
+                    rates,
+                }));
+            });
+        }
+        return this.link.subscribe({
+            type: 'fiatRates',
+        });
+    }
+    async unsubscribe(accounts) {
+        if (!accounts) {
+            this.link.removeAllListeners('block');
+            this.link.removeAllListeners('fiatRates');
+            this.link.removeAllListeners('notification');
+            await this.link.unsubscribe({ type: 'fiatRates' });
+            return this.link.unsubscribe({ type: 'block' });
+        }
+        return this.link.unsubscribe({ type: 'accounts', accounts });
+    }
+    unsubscribeFiatRates() {
+        this.link.removeAllListeners('fiatRates');
+        return this.link.unsubscribe({ type: 'fiatRates' });
+    }
+    pushTransaction(tx) {
+        return this.link.pushTransaction(tx);
+    }
+    disconnect() {
+        this.link.removeAllListeners();
+        this.link.disconnect();
+        this.onError(constants_1.ERRORS.TypedError('Backend_Disconnected'));
+    }
+}
+exports.Blockchain = Blockchain;
+const instances = [];
+const customBackends = {};
+const preferredBackends = {};
+const removeBackend = (backend) => {
+    const index = instances.indexOf(backend);
+    if (index >= 0) {
+        instances.splice(index, 1);
+    }
+};
+const findBackend = (name) => {
+    for (let i = 0; i < instances.length; i++) {
+        if (instances[i].coinInfo.name === name) {
+            return instances[i];
+        }
+    }
+    return null;
+};
+exports.findBackend = findBackend;
+const setPreferredBacked = (coinInfo, url) => {
+    if (!url) {
+        delete preferredBackends[coinInfo.shortcut];
+    }
+    else if (coinInfo.blockchainLink) {
+        preferredBackends[coinInfo.shortcut] = {
+            ...coinInfo,
+            blockchainLink: {
+                ...coinInfo.blockchainLink,
+                url: [url],
+            },
+        };
+    }
+};
+const setCustomBackend = (coinInfo, blockchainLink) => {
+    setPreferredBacked(coinInfo);
+    if (!blockchainLink || blockchainLink.url.length === 0) {
+        delete customBackends[coinInfo.shortcut];
+    }
+    else {
+        customBackends[coinInfo.shortcut] = {
+            ...coinInfo,
+            blockchainLink,
+        };
+    }
+};
+exports.setCustomBackend = setCustomBackend;
+const isBackendSupported = (coinInfo) => {
+    const info = customBackends[coinInfo.shortcut] || coinInfo;
+    if (!info.blockchainLink) {
+        throw constants_1.ERRORS.TypedError('Backend_NotSupported');
+    }
+};
+exports.isBackendSupported = isBackendSupported;
+const initBlockchain = async (coinInfo, postMessage) => {
+    let backend = (0, exports.findBackend)(coinInfo.name);
+    if (!backend) {
+        backend = new Blockchain({
+            coinInfo: preferredBackends[coinInfo.shortcut] ||
+                customBackends[coinInfo.shortcut] ||
+                coinInfo,
+            postMessage,
+            debug: DataManager_1.DataManager.getSettings('debug'),
+            proxy: DataManager_1.DataManager.getSettings('proxy'),
+            onionDomains: DataManager_1.DataManager.getSettings('useOnionLinks') && !customBackends[coinInfo.shortcut]
+                ? config_1.config.onionDomains
+                : undefined,
+        });
+        instances.push(backend);
+        try {
+            await backend.init();
+        }
+        catch (error) {
+            removeBackend(backend);
+            setPreferredBacked(coinInfo);
+            throw error;
+        }
+    }
+    return backend;
+};
+exports.initBlockchain = initBlockchain;
+const reconnectAllBackends = () => {
+    const params = instances.map(i => [
+        i.coinInfo,
+        i.postMessage,
+    ]);
+    while (instances.length > 0) {
+        instances[0].disconnect();
+    }
+    return Promise.all(params.map(p => (0, exports.initBlockchain)(...p)));
+};
+exports.reconnectAllBackends = reconnectAllBackends;
+const dispose = () => {
+    while (instances.length > 0) {
+        instances[0].disconnect();
+    }
+};
+exports.dispose = dispose;
+//# sourceMappingURL=BlockchainLink.js.map

package/lib/constants/cardano.d.ts

@@ -0,0 +1,9 @@
+export declare enum PROTOCOL_MAGICS {
+    mainnet = 764824073,
+    testnet = 1097911063
+}
+export declare enum NETWORK_IDS {
+    mainnet = 1,
+    testnet = 0
+}
+//# sourceMappingURL=cardano.d.ts.map

package/lib/constants/cardano.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NETWORK_IDS = exports.PROTOCOL_MAGICS = void 0;
+var PROTOCOL_MAGICS;
+(function (PROTOCOL_MAGICS) {
+    PROTOCOL_MAGICS[PROTOCOL_MAGICS["mainnet"] = 764824073] = "mainnet";
+    PROTOCOL_MAGICS[PROTOCOL_MAGICS["testnet"] = 1097911063] = "testnet";
+})(PROTOCOL_MAGICS = exports.PROTOCOL_MAGICS || (exports.PROTOCOL_MAGICS = {}));
+var NETWORK_IDS;
+(function (NETWORK_IDS) {
+    NETWORK_IDS[NETWORK_IDS["mainnet"] = 1] = "mainnet";
+    NETWORK_IDS[NETWORK_IDS["testnet"] = 0] = "testnet";
+})(NETWORK_IDS = exports.NETWORK_IDS || (exports.NETWORK_IDS = {}));
+//# sourceMappingURL=cardano.js.map

package/lib/constants/errors.d.ts

@@ -0,0 +1,49 @@
+export declare const ERROR_CODES: {
+    Init_NotInitialized: string;
+    Init_AlreadyInitialized: string;
+    Init_IframeBlocked: string;
+    Init_IframeTimeout: string;
+    Init_ManifestMissing: string;
+    Popup_ConnectionMissing: string;
+    Transport_Missing: string;
+    Transport_InvalidProtobuf: string;
+    Method_InvalidPackage: string;
+    Method_InvalidParameter: string;
+    Method_NotAllowed: string;
+    Method_PermissionsNotGranted: string;
+    Method_Cancel: string;
+    Method_Interrupted: string;
+    Method_UnknownCoin: string;
+    Method_AddressNotMatch: string;
+    Method_FirmwareUpdate_DownloadFailed: string;
+    Method_CustomMessage_Callback: string;
+    Method_Discovery_BundleException: string;
+    Method_Override: string;
+    Method_NoResponse: string;
+    Backend_NotSupported: string;
+    Backend_WorkerMissing: string;
+    Backend_Disconnected: string;
+    Backend_Invalid: string;
+    Backend_Error: string;
+    Runtime: string;
+    Device_NotFound: string;
+    Device_InitializeFailed: string;
+    Device_FwException: string;
+    Device_ModeException: string;
+    Device_Disconnected: string;
+    Device_UsedElsewhere: string;
+    Device_InvalidState: string;
+    Device_CallInProgress: string;
+};
+export declare class TrezorError extends Error {
+    code: string;
+    message: string;
+    constructor(code: string, message: string);
+}
+export declare const TypedError: (id: keyof typeof ERROR_CODES, message?: string | undefined) => TrezorError;
+export declare const serializeError: (payload: any) => any;
+export declare const WRONG_PREVIOUS_SESSION_ERROR_MESSAGE = "wrong previous session";
+export declare const INVALID_PIN_ERROR_MESSAGE = "PIN invalid";
+export declare const WEBUSB_ERROR_MESSAGE = "NetworkError: Unable to claim interface.";
+export declare const LIBUSB_ERROR_MESSAGE = "LIBUSB_ERROR";
+//# sourceMappingURL=errors.d.ts.map

package/lib/constants/errors.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIBUSB_ERROR_MESSAGE = exports.WEBUSB_ERROR_MESSAGE = exports.INVALID_PIN_ERROR_MESSAGE = exports.WRONG_PREVIOUS_SESSION_ERROR_MESSAGE = exports.serializeError = exports.TypedError = exports.TrezorError = exports.ERROR_CODES = void 0;
+exports.ERROR_CODES = {
+    Init_NotInitialized: 'TrezorConnect not initialized',
+    Init_AlreadyInitialized: 'TrezorConnect has been already initialized',
+    Init_IframeBlocked: 'Iframe blocked',
+    Init_IframeTimeout: 'Iframe timeout',
+    Init_ManifestMissing: 'Manifest not set. Read more at https://github.com/trezor/connect/blob/develop/docs/index.md',
+    Popup_ConnectionMissing: 'Unable to establish connection with iframe',
+    Transport_Missing: 'Transport is missing',
+    Transport_InvalidProtobuf: '',
+    Method_InvalidPackage: 'This package is not suitable to work with browser. Use @trezor/connect-web package instead',
+    Method_InvalidParameter: '',
+    Method_NotAllowed: 'Method not allowed for this configuration',
+    Method_PermissionsNotGranted: 'Permissions not granted',
+    Method_Cancel: 'Cancelled',
+    Method_Interrupted: 'Popup closed',
+    Method_UnknownCoin: 'Coin not found',
+    Method_AddressNotMatch: 'Addresses do not match',
+    Method_FirmwareUpdate_DownloadFailed: 'Failed to download firmware binary',
+    Method_CustomMessage_Callback: 'Parameter "callback" is not a function',
+    Method_Discovery_BundleException: '',
+    Method_Override: 'override',
+    Method_NoResponse: 'Call resolved without response',
+    Backend_NotSupported: 'BlockchainLink settings not found in coins.json',
+    Backend_WorkerMissing: '',
+    Backend_Disconnected: 'Backend disconnected',
+    Backend_Invalid: 'Invalid backend',
+    Backend_Error: '',
+    Runtime: '',
+    Device_NotFound: 'Device not found',
+    Device_InitializeFailed: '',
+    Device_FwException: '',
+    Device_ModeException: '',
+    Device_Disconnected: 'Device disconnected',
+    Device_UsedElsewhere: 'Device is used in another window',
+    Device_InvalidState: 'Passphrase is incorrect',
+    Device_CallInProgress: 'Device call in progress',
+};
+class TrezorError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.message = message;
+    }
+}
+exports.TrezorError = TrezorError;
+const TypedError = (id, message) => new TrezorError(id, message || exports.ERROR_CODES[id]);
+exports.TypedError = TypedError;
+const serializeError = (payload) => {
+    if (payload && payload.error instanceof Error) {
+        return { error: payload.error.message, code: payload.error.code };
+    }
+    return payload;
+};
+exports.serializeError = serializeError;
+exports.WRONG_PREVIOUS_SESSION_ERROR_MESSAGE = 'wrong previous session';
+exports.INVALID_PIN_ERROR_MESSAGE = 'PIN invalid';
+exports.WEBUSB_ERROR_MESSAGE = 'NetworkError: Unable to claim interface.';
+exports.LIBUSB_ERROR_MESSAGE = 'LIBUSB_ERROR';
+//# sourceMappingURL=errors.js.map

package/lib/constants/index.d.ts

@@ -0,0 +1,6 @@
+export * as ERRORS from './errors';
+export * as NETWORK from './network';
+export * as CARDANO from './cardano';
+export * as NEM from './nem';
+export * as PROTO from '@trezor/transport/lib/types/messages';
+//# sourceMappingURL=index.d.ts.map

package/lib/constants/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTO = exports.NEM = exports.CARDANO = exports.NETWORK = exports.ERRORS = void 0;
+const tslib_1 = require("tslib");
+exports.ERRORS = (0, tslib_1.__importStar)(require("./errors"));
+exports.NETWORK = (0, tslib_1.__importStar)(require("./network"));
+exports.CARDANO = (0, tslib_1.__importStar)(require("./cardano"));
+exports.NEM = (0, tslib_1.__importStar)(require("./nem"));
+exports.PROTO = (0, tslib_1.__importStar)(require("@trezor/transport/lib/types/messages"));
+//# sourceMappingURL=index.js.map

package/lib/constants/nem.d.ts

@@ -0,0 +1,22 @@
+export declare enum Networks {
+    mainnet = 104,
+    testnet = 152,
+    mijin = 96
+}
+export declare enum TxType {
+    TRANSFER = 257,
+    COSIGNING = 258,
+    IMPORTANCE_TRANSFER = 2049,
+    AGGREGATE_MODIFICATION = 4097,
+    MULTISIG_SIGNATURE = 4098,
+    MULTISIG = 4100,
+    PROVISION_NAMESPACE = 8193,
+    MOSAIC_CREATION = 16385,
+    SUPPLY_CHANGE = 16386
+}
+export declare enum TxVersion {
+    mainnet = 1744830464,
+    testnet = -1744830464,
+    mijin = 1610612736
+}
+//# sourceMappingURL=nem.d.ts.map

package/lib/constants/nem.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TxVersion = exports.TxType = exports.Networks = void 0;
+var Networks;
+(function (Networks) {
+    Networks[Networks["mainnet"] = 104] = "mainnet";
+    Networks[Networks["testnet"] = 152] = "testnet";
+    Networks[Networks["mijin"] = 96] = "mijin";
+})(Networks = exports.Networks || (exports.Networks = {}));
+var TxType;
+(function (TxType) {
+    TxType[TxType["TRANSFER"] = 257] = "TRANSFER";
+    TxType[TxType["COSIGNING"] = 258] = "COSIGNING";
+    TxType[TxType["IMPORTANCE_TRANSFER"] = 2049] = "IMPORTANCE_TRANSFER";
+    TxType[TxType["AGGREGATE_MODIFICATION"] = 4097] = "AGGREGATE_MODIFICATION";
+    TxType[TxType["MULTISIG_SIGNATURE"] = 4098] = "MULTISIG_SIGNATURE";
+    TxType[TxType["MULTISIG"] = 4100] = "MULTISIG";
+    TxType[TxType["PROVISION_NAMESPACE"] = 8193] = "PROVISION_NAMESPACE";
+    TxType[TxType["MOSAIC_CREATION"] = 16385] = "MOSAIC_CREATION";
+    TxType[TxType["SUPPLY_CHANGE"] = 16386] = "SUPPLY_CHANGE";
+})(TxType = exports.TxType || (exports.TxType = {}));
+var TxVersion;
+(function (TxVersion) {
+    TxVersion[TxVersion["mainnet"] = 1744830464] = "mainnet";
+    TxVersion[TxVersion["testnet"] = -1744830464] = "testnet";
+    TxVersion[TxVersion["mijin"] = 1610612736] = "mijin";
+})(TxVersion = exports.TxVersion || (exports.TxVersion = {}));
+//# sourceMappingURL=nem.js.map

package/lib/constants/network.d.ts

@@ -0,0 +1,13 @@
+export declare const TYPES: {
+    readonly bitcoin: "Bitcoin";
+    readonly ethereum: "Ethereum";
+    readonly eos: "Eos";
+    readonly nem: "NEM";
+    readonly stellar: "Stellar";
+    readonly cardano: "Cardano";
+    readonly ripple: "Ripple";
+    readonly tezos: "Tezos";
+    readonly binance: "Binance";
+};
+export declare type NetworkType = keyof typeof TYPES;
+//# sourceMappingURL=network.d.ts.map

package/lib/constants/network.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TYPES = void 0;
+exports.TYPES = {
+    bitcoin: 'Bitcoin',
+    ethereum: 'Ethereum',
+    eos: 'Eos',
+    nem: 'NEM',
+    stellar: 'Stellar',
+    cardano: 'Cardano',
+    ripple: 'Ripple',
+    tezos: 'Tezos',
+    binance: 'Binance',
+};
+//# sourceMappingURL=network.js.map

package/lib/core/AbstractMethod.d.ts

@@ -0,0 +1,59 @@
+import { NETWORK } from '../constants';
+import { CallMethodPayload, CallMethodResponse, CoreMessage, UiRequestButtonData, UiPromise, UiPromiseResponse } from '../events';
+import { Deferred } from '../utils/deferred';
+import type { Device } from '../device/Device';
+import type { FirmwareRange } from '../types';
+export declare type Payload<M> = Extract<CallMethodPayload, {
+    method: M;
+}> & {
+    override?: boolean;
+};
+export declare type MethodReturnType<M extends CallMethodPayload['method']> = CallMethodResponse<M>;
+export declare abstract class AbstractMethod<Name extends CallMethodPayload['method'], Params = undefined> {
+    responseID: number;
+    device: Device;
+    params: Params;
+    devicePath?: string;
+    deviceState?: string;
+    hasExpectedDeviceState: boolean;
+    keepSession: boolean;
+    skipFinalReload: boolean;
+    skipFirmwareCheck: boolean;
+    overridePreviousCall: boolean;
+    overridden: boolean;
+    name: Name;
+    payload: Payload<Name>;
+    info: string;
+    useUi: boolean;
+    useDevice: boolean;
+    useDeviceState: boolean;
+    useEmptyPassphrase: boolean;
+    allowSeedlessDevice: boolean;
+    firmwareRange: FirmwareRange;
+    requiredPermissions: string[];
+    allowDeviceMode: string[];
+    requireDeviceMode: string[];
+    network: NETWORK.NetworkType;
+    useCardanoDerivation: boolean;
+    confirmation?(): Promise<boolean | undefined>;
+    noBackupConfirmation?(): Promise<boolean>;
+    getButtonRequestData?(code: string): UiRequestButtonData | undefined;
+    postMessage: (message: CoreMessage) => void;
+    getPopupPromise: () => Deferred<void>;
+    createUiPromise: <T extends UiPromiseResponse['type']>(promiseId: T, device?: Device) => UiPromise<T>;
+    removeUiPromise: (promise: Deferred<any>) => void;
+    constructor(message: {
+        id?: number;
+        payload: Payload<Name>;
+    });
+    setDevice(device: Device): void;
+    requestPermissions(): Promise<boolean>;
+    checkPermissions(): void;
+    savePermissions(temporary?: boolean): void;
+    checkFirmwareRange(isUsingPopup?: boolean): Promise<"ui-device_firmware_old" | "ui-device_firmware_unsupported" | "ui-device_firmware_not_compatible" | "ui-device_firmware_not_installed" | undefined>;
+    abstract init(): void;
+    abstract run(): Promise<MethodReturnType<Name>>;
+    getCustomMessages(): void;
+    dispose(): void;
+}
+//# sourceMappingURL=AbstractMethod.d.ts.map