@trezor/connect 9.4.7 → 9.4.8-beta.1

package/lib/api/solana/solanaUtils.js

@@ -0,0 +1,213 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAccountOwnerAndTokenInfoForAddress = exports.buildTokenTransferTransaction = exports.getMinimumRequiredTokenAccountsForTransfer = exports.buildCreateAssociatedTokenAccountInstruction = exports.getAssociatedTokenAccountAddress = exports.buildTokenTransferInstruction = exports.buildTransferTransaction = exports.dummyPriorityFeesForFeeEstimation = exports.getLamportsFromSol = void 0;
+exports.createTransactionShim = createTransactionShim;
+exports.createTransactionShimFromHex = createTransactionShimFromHex;
+const ts_belt_1 = require("@mobily/ts-belt");
+const blockchain_link_utils_1 = require("@trezor/blockchain-link-utils");
+const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
+const { SYSTEM_PROGRAM_PUBLIC_KEY, tokenProgramsInfo } = blockchain_link_utils_1.solanaUtils;
+const loadSolanaLib = async () => await Promise.resolve().then(() => __importStar(require('@solana/web3.js')));
+const loadSolanaComputeBudgetProgramLib = async () => await Promise.resolve().then(() => __importStar(require('@solana-program/compute-budget')));
+const loadSolanaSystemProgramLib = async () => await Promise.resolve().then(() => __importStar(require('@solana-program/system')));
+const loadSolanaTokenProgramLib = async (tokenProgramName) => {
+    switch (tokenProgramName) {
+        case 'spl-token':
+            return await Promise.resolve().then(() => __importStar(require('@solana-program/token')));
+        case 'spl-token-2022':
+            return await Promise.resolve().then(() => __importStar(require('@solana-program/token-2022')));
+        default:
+            throw new Error(`Unsupported token program: ${tokenProgramName}`);
+    }
+};
+const getLamportsFromSol = (amountInSol) => BigInt(new bigNumber_1.BigNumber(amountInSol).times(10 ** 9).toString());
+exports.getLamportsFromSol = getLamportsFromSol;
+exports.dummyPriorityFeesForFeeEstimation = {
+    computeUnitPrice: '100000',
+    computeUnitLimit: '200000',
+};
+async function createTransactionShimCommon(transaction) {
+    const { getBase16Codec, getTransactionEncoder } = await loadSolanaLib();
+    return {
+        addSignature(signerPubKey, signatureHex) {
+            if (signerPubKey in transaction.signatures) {
+                const signatureBytes = getBase16Codec().encode(signatureHex);
+                transaction = Object.freeze({
+                    ...transaction,
+                    signatures: Object.freeze({
+                        ...transaction.signatures,
+                        [signerPubKey]: signatureBytes,
+                    }),
+                });
+            }
+        },
+        serializeMessage() {
+            return getBase16Codec().decode(transaction.messageBytes);
+        },
+        serialize() {
+            return (0, ts_belt_1.pipe)(transaction, getTransactionEncoder().encode, getBase16Codec().decode);
+        },
+    };
+}
+async function createTransactionShim(message) {
+    const { compileTransaction } = await loadSolanaLib();
+    const transaction = compileTransaction(message);
+    return createTransactionShimCommon(transaction);
+}
+async function createTransactionShimFromHex(rawTx) {
+    const { getBase16Encoder, getTransactionDecoder } = await loadSolanaLib();
+    const txByteArray = getBase16Encoder().encode(rawTx);
+    const transaction = getTransactionDecoder().decode(txByteArray);
+    return createTransactionShimCommon(transaction);
+}
+const addPriorityFees = async (message, priorityFees) => {
+    const [{ prependTransactionMessageInstructions }, { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction },] = await Promise.all([loadSolanaLib(), loadSolanaComputeBudgetProgramLib()]);
+    return (0, ts_belt_1.pipe)(message, m => prependTransactionMessageInstructions([
+        getSetComputeUnitLimitInstruction({
+            units: parseInt(priorityFees.computeUnitLimit, 10),
+        }),
+        getSetComputeUnitPriceInstruction({
+            microLamports: parseInt(priorityFees.computeUnitPrice, 10),
+        }),
+    ], m));
+};
+const buildTransferTransaction = async (fromAddress, toAddress, amountInSol, blockhash, lastValidBlockHeight, priorityFees) => {
+    const [{ address, appendTransactionMessageInstruction, createTransactionMessage, lamports, setTransactionMessageLifetimeUsingBlockhash, setTransactionMessageFeePayer, createNoopSigner, }, { getTransferSolInstruction },] = await Promise.all([loadSolanaLib(), loadSolanaSystemProgramLib()]);
+    const message = await (0, ts_belt_1.pipe)(createTransactionMessage({ version: 'legacy' }), m => setTransactionMessageFeePayer(address(fromAddress), m), m => setTransactionMessageLifetimeUsingBlockhash({
+        blockhash: blockhash,
+        lastValidBlockHeight: BigInt(lastValidBlockHeight !== null && lastValidBlockHeight !== void 0 ? lastValidBlockHeight : '0xFFFFFFFFFFFFFFFF'),
+    }, m), m => appendTransactionMessageInstruction(getTransferSolInstruction({
+        amount: lamports((0, exports.getLamportsFromSol)(amountInSol)),
+        destination: address(toAddress),
+        source: createNoopSigner(address(fromAddress)),
+    }), m), m => addPriorityFees(m, priorityFees));
+    return await createTransactionShim(message);
+};
+exports.buildTransferTransaction = buildTransferTransaction;
+const buildTokenTransferInstruction = async (from, to, owner, amount, mint, decimals, tokenProgramName) => {
+    const [{ address, createNoopSigner }, { getTransferCheckedInstruction },] = await Promise.all([loadSolanaLib(), loadSolanaTokenProgramLib(tokenProgramName)]);
+    return getTransferCheckedInstruction({
+        amount: BigInt(amount.toString()),
+        authority: createNoopSigner(address(owner)),
+        decimals,
+        destination: address(to),
+        mint: address(mint),
+        source: address(from),
+    });
+};
+exports.buildTokenTransferInstruction = buildTokenTransferInstruction;
+const getAssociatedTokenAccountAddress = async (baseAddress, tokenMintAddress, tokenProgramName) => {
+    const [{ address }, { findAssociatedTokenPda },] = await Promise.all([loadSolanaLib(), loadSolanaTokenProgramLib(tokenProgramName)]);
+    const [pdaAddress] = await findAssociatedTokenPda({
+        mint: address(tokenMintAddress),
+        owner: address(baseAddress),
+        tokenProgram: address(tokenProgramsInfo[tokenProgramName].publicKey),
+    });
+    return pdaAddress;
+};
+exports.getAssociatedTokenAccountAddress = getAssociatedTokenAccountAddress;
+const buildCreateAssociatedTokenAccountInstruction = async (funderAddress, newOwnerAddress, tokenMintAddress, tokenProgramName) => {
+    const [{ address, createNoopSigner }, { getCreateAssociatedTokenInstruction },] = await Promise.all([loadSolanaLib(), loadSolanaTokenProgramLib(tokenProgramName)]);
+    const associatedTokenAccountAddress = await (0, exports.getAssociatedTokenAccountAddress)(newOwnerAddress, tokenMintAddress, tokenProgramName);
+    const txInstruction = getCreateAssociatedTokenInstruction({
+        ata: associatedTokenAccountAddress,
+        mint: address(tokenMintAddress),
+        owner: address(newOwnerAddress),
+        payer: createNoopSigner(address(funderAddress)),
+    });
+    txInstruction.data = new Uint8Array([]);
+    return [txInstruction, associatedTokenAccountAddress];
+};
+exports.buildCreateAssociatedTokenAccountInstruction = buildCreateAssociatedTokenAccountInstruction;
+const getMinimumRequiredTokenAccountsForTransfer = (tokenAccounts, requiredAmount) => {
+    let accumulatedBalance = new bigNumber_1.BigNumber('0');
+    const requiredAccounts = ts_belt_1.F.toMutable((0, ts_belt_1.pipe)(tokenAccounts, ts_belt_1.A.sort((a, b) => new bigNumber_1.BigNumber(b.balance).comparedTo(new bigNumber_1.BigNumber(a.balance))), ts_belt_1.A.takeWhile(tokenAccount => {
+        const needMoreAccounts = accumulatedBalance.lt(requiredAmount);
+        accumulatedBalance = accumulatedBalance.plus(tokenAccount.balance);
+        return needMoreAccounts;
+    })));
+    return requiredAccounts;
+};
+exports.getMinimumRequiredTokenAccountsForTransfer = getMinimumRequiredTokenAccountsForTransfer;
+const buildTokenTransferTransaction = async (fromAddress, toAddress, toAddressOwner, tokenMint, tokenUiAmount, tokenDecimals, fromTokenAccounts, toTokenAccount, blockhash, lastValidBlockHeight, priorityFees, tokenProgramName) => {
+    const { address, appendTransactionMessageInstruction, appendTransactionMessageInstructions, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, } = await loadSolanaLib();
+    let message = await (0, ts_belt_1.pipe)(createTransactionMessage({ version: 'legacy' }), m => setTransactionMessageFeePayer(address(fromAddress), m), m => setTransactionMessageLifetimeUsingBlockhash({
+        blockhash: blockhash,
+        lastValidBlockHeight: BigInt(lastValidBlockHeight !== null && lastValidBlockHeight !== void 0 ? lastValidBlockHeight : '0xFFFFFFFFFFFFFFFF'),
+    }, m), m => addPriorityFees(m, priorityFees));
+    const tokenAmount = new bigNumber_1.BigNumber(tokenUiAmount).times(10 ** tokenDecimals);
+    const requiredAccounts = (0, exports.getMinimumRequiredTokenAccountsForTransfer)(fromTokenAccounts, tokenAmount.toString());
+    const isReceiverAddressSystemAccount = toAddressOwner === SYSTEM_PROGRAM_PUBLIC_KEY;
+    let finalReceiverAddress = toAddress;
+    if (isReceiverAddressSystemAccount) {
+        if (toTokenAccount) {
+            finalReceiverAddress = toTokenAccount.publicKey;
+        }
+        else {
+            const [createAccountInstruction, associatedTokenAccountAddress] = await (0, exports.buildCreateAssociatedTokenAccountInstruction)(fromAddress, toAddress, tokenMint, tokenProgramName);
+            message = appendTransactionMessageInstruction(createAccountInstruction, message);
+            finalReceiverAddress = associatedTokenAccountAddress;
+        }
+    }
+    let remainingAmount = tokenAmount;
+    const instructionPromises = requiredAccounts.map(async (tokenAccount) => {
+        const transferAmount = bigNumber_1.BigNumber.min(remainingAmount, new bigNumber_1.BigNumber(tokenAccount.balance));
+        const transferInstruction = await (0, exports.buildTokenTransferInstruction)(tokenAccount.publicKey, finalReceiverAddress, fromAddress, transferAmount, tokenMint, tokenDecimals, tokenProgramName);
+        remainingAmount = remainingAmount.minus(transferAmount);
+        return transferInstruction;
+    });
+    message = appendTransactionMessageInstructions(await Promise.all(instructionPromises), message);
+    return {
+        transaction: await createTransactionShim(message),
+        destinationAddress: finalReceiverAddress,
+        tokenAccountInfo: isReceiverAddressSystemAccount
+            ? {
+                baseAddress: toAddress,
+                tokenProgram: tokenProgramsInfo[tokenProgramName].publicKey,
+                tokenMint,
+                tokenAccount: finalReceiverAddress,
+            }
+            : undefined,
+    };
+};
+exports.buildTokenTransferTransaction = buildTokenTransferTransaction;
+const fetchAccountOwnerAndTokenInfoForAddress = async (blockchain, address, mint, tokenProgram) => {
+    var _a, _b, _c, _d;
+    let accountOwner;
+    let tokenInfo;
+    const accountInfoResponse = await blockchain.getAccountInfo({
+        descriptor: address,
+        details: 'tokens',
+    });
+    if (accountInfoResponse) {
+        const associatedTokenAccount = await (0, exports.getAssociatedTokenAccountAddress)(address, mint, tokenProgram);
+        accountOwner = (_a = accountInfoResponse === null || accountInfoResponse === void 0 ? void 0 : accountInfoResponse.misc) === null || _a === void 0 ? void 0 : _a.owner;
+        tokenInfo = (_d = (_c = (_b = accountInfoResponse === null || accountInfoResponse === void 0 ? void 0 : accountInfoResponse.tokens) === null || _b === void 0 ? void 0 : _b.find(token => token.contract === mint)) === null || _c === void 0 ? void 0 : _c.accounts) === null || _d === void 0 ? void 0 : _d.find(account => associatedTokenAccount.toString() === account.publicKey);
+    }
+    return [accountOwner, tokenInfo];
+};
+exports.fetchAccountOwnerAndTokenInfoForAddress = fetchAccountOwnerAndTokenInfoForAddress;
+//# sourceMappingURL=solanaUtils.js.map

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

@@ -1,5 +1,5 @@
-import { AbstractMethod } from '../../../core/AbstractMethod';
 import { PROTO } from '../../../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
 type Params = PROTO.StellarGetAddress & {
     address?: string;
 };

package/lib/api/stellar/api/stellarGetAddress.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../../../constants");
 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 constants_1 = require("../../../constants");
 const events_1 = require("../../../events");
 const types_1 = require("../../../types");
 const getAddress_1 = require("../../../types/api/getAddress");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const paramsValidator_1 = require("../../common/paramsValidator");
 class StellarGetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);

package/lib/api/stellar/api/stellarSignTransaction.js

@@ -2,13 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../../../constants");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
+const stellar_1 = require("../../../types/api/stellar");
 const pathUtils_1 = require("../../../utils/pathUtils");
+const paramsValidator_1 = require("../../common/paramsValidator");
 const helper = tslib_1.__importStar(require("../stellarSignTx"));
-const constants_1 = require("../../../constants");
-const stellar_1 = require("../../../types/api/stellar");
 const StellarSignTransactionFeatures = Object.freeze({
     manageBuyOffer: ['1.10.4', '2.4.3'],
     pathPaymentStrictSend: ['1.10.4', '2.4.3'],

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

@@ -1,5 +1,5 @@
-import { AbstractMethod } from '../../../core/AbstractMethod';
 import { PROTO } from '../../../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
 type Params = PROTO.TezosGetAddress & {
     address?: string;
 };

package/lib/api/tezos/api/tezosGetAddress.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../../../constants");
 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 constants_1 = require("../../../constants");
 const events_1 = require("../../../events");
 const types_1 = require("../../../types");
 const getAddress_1 = require("../../../types/api/getAddress");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const paramsValidator_1 = require("../../common/paramsValidator");
 class TezosGetAddress extends AbstractMethod_1.AbstractMethod {
     constructor() {
         super(...arguments);

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

@@ -1,5 +1,5 @@
-import { AbstractMethod } from '../../../core/AbstractMethod';
 import type { PROTO } from '../../../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
 export default class TezosGetPublicKey extends AbstractMethod<'tezosGetPublicKey', PROTO.TezosGetPublicKey[]> {
     hasBundle?: boolean;
     init(): void;

package/lib/api/tezos/api/tezosGetPublicKey.js

@@ -2,11 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const schema_utils_1 = require("@trezor/schema-utils");
 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 events_1 = require("../../../events");
 const types_1 = require("../../../types");
+const pathUtils_1 = require("../../../utils/pathUtils");
+const paramsValidator_1 = require("../../common/paramsValidator");
 class TezosGetPublicKey extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read'];

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

@@ -1,5 +1,5 @@
-import { AbstractMethod } from '../../../core/AbstractMethod';
 import type { PROTO } from '../../../constants';
+import { AbstractMethod } from '../../../core/AbstractMethod';
 export default class TezosSignTransaction extends AbstractMethod<'tezosSignTransaction', PROTO.TezosSignTx> {
     init(): void;
     get info(): string;

package/lib/api/tezos/api/tezosSignTransaction.js

@@ -3,11 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
 const schema_utils_1 = require("@trezor/schema-utils");
 const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const paramsValidator_1 = require("../../common/paramsValidator");
 const coinInfo_1 = require("../../../data/coinInfo");
+const tezos_1 = require("../../../types/api/tezos");
 const pathUtils_1 = require("../../../utils/pathUtils");
+const paramsValidator_1 = require("../../common/paramsValidator");
 const helper = tslib_1.__importStar(require("../tezosSignTx"));
-const tezos_1 = require("../../../types/api/tezos");
 class TezosSignTransaction extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];

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

@@ -18,31 +18,20 @@ export declare const createTx: (address_n: number[], branch: string, operation:
         source: Uint8Array;
         amount: string | number;
         fee: string | number;
-        gas_limit: number;
         destination: {
             hash: Uint8Array;
             tag: number;
         };
         counter: number;
+        gas_limit: number;
         storage_limit: number;
     } | undefined;
-    proposal?: {
-        source: string;
-        period: number;
-        proposals: string[];
-    } | undefined;
-    ballot?: {
-        source: string;
-        period: number;
-        proposal: string;
-        ballot: PROTO.TezosBallotType;
-    } | undefined;
     reveal?: {
         source: Uint8Array;
         public_key: Uint8Array;
         fee: string | number;
-        gas_limit: number;
         counter: number;
+        gas_limit: number;
         storage_limit: number;
     } | undefined;
     origination?: {
@@ -53,18 +42,29 @@ export declare const createTx: (address_n: number[], branch: string, operation:
         source: Uint8Array;
         fee: string | number;
         script: string | number[];
-        gas_limit: number;
+        balance: number;
         counter: number;
+        gas_limit: number;
         storage_limit: number;
-        balance: number;
     } | undefined;
     delegation?: {
         source: Uint8Array;
         fee: string | number;
-        delegate: Uint8Array;
-        gas_limit: number;
         counter: number;
+        gas_limit: number;
         storage_limit: number;
+        delegate: Uint8Array;
+    } | undefined;
+    proposal?: {
+        source: string;
+        period: number;
+        proposals: string[];
+    } | undefined;
+    ballot?: {
+        source: string;
+        period: number;
+        proposal: string;
+        ballot: PROTO.TezosBallotType;
     } | undefined;
     address_n: number[];
     branch: Uint8Array;

package/lib/api/unlockPath.d.ts

@@ -1,5 +1,5 @@
-import { AbstractMethod } from '../core/AbstractMethod';
 import { PROTO } from '../constants';
+import { AbstractMethod } from '../core/AbstractMethod';
 export default class UnlockPath extends AbstractMethod<'unlockPath', PROTO.UnlockPath> {
     init(): void;
     run(): Promise<{

package/lib/api/verifyMessage.d.ts

@@ -1,5 +1,5 @@
-import { AbstractMethod } from '../core/AbstractMethod';
 import { PROTO } from '../constants';
+import { AbstractMethod } from '../core/AbstractMethod';
 export default class VerifyMessage extends AbstractMethod<'verifyMessage', PROTO.VerifyMessage> {
     init(): void;
     get info(): string;

package/lib/api/verifyMessage.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const schema_utils_1 = require("@trezor/schema-utils");
+const constants_1 = require("../constants");
 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 formatUtils_1 = require("../utils/formatUtils");
-const constants_1 = require("../constants");
 const types_1 = require("../types");
+const formatUtils_1 = require("../utils/formatUtils");
+const pathUtils_1 = require("../utils/pathUtils");
 class VerifyMessage extends AbstractMethod_1.AbstractMethod {
     init() {
         this.requiredPermissions = ['read', 'write'];

package/lib/backend/BackendManager.d.ts

@@ -1,5 +1,5 @@
 import { Blockchain, BlockchainOptions } from './Blockchain';
-import type { CoinInfo, BlockchainLink } from '../types';
+import type { BlockchainLink, CoinInfo } from '../types';
 type CoinShortcut = CoinInfo['shortcut'];
 type BackendParams = Pick<BlockchainOptions, 'coinInfo' | 'postMessage' | 'identity'>;
 export declare class BackendManager {

package/lib/backend/BackendManager.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackendManager = void 0;
-const DataManager_1 = require("../data/DataManager");
 const constants_1 = require("../constants");
 const Blockchain_1 = require("./Blockchain");
+const DataManager_1 = require("../data/DataManager");
 const events_1 = require("../events");
 const DEFAULT_IDENTITY = 'default';
 class BackendManager {

package/lib/backend/Blockchain.d.ts

@@ -1,6 +1,6 @@
-import BlockchainLink, { ServerInfo, SubscriptionAccountInfo, BlockchainLinkParams, BlockchainLinkResponse } from '@trezor/blockchain-link';
-import { CoreEventMessage } from '../events';
+import BlockchainLink, { BlockchainLinkParams, BlockchainLinkResponse, ServerInfo, SubscriptionAccountInfo } from '@trezor/blockchain-link';
 import { ERRORS } from '../constants';
+import { CoreEventMessage } from '../events';
 import type { CoinInfo, Proxy } from '../types';
 export type BlockchainOptions = {
     coinInfo: CoinInfo;

package/lib/backend/Blockchain.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Blockchain = void 0;
 const tslib_1 = require("tslib");
 const blockchain_link_1 = tslib_1.__importDefault(require("@trezor/blockchain-link"));
-const events_1 = require("../events");
 const constants_1 = require("../constants");
+const events_1 = require("../events");
 const workers_1 = require("../workers/workers");
 const getWorker = (type) => {
     switch (type) {
@@ -26,9 +26,6 @@ const getNormalizedTrezorShortcut = (shortcut) => {
     if (shortcut === 'tXRP') {
         return 'XRP';
     }
-    if (['OP', 'BASE'].includes(shortcut)) {
-        return 'ETH';
-    }
     return shortcut;
 };
 class Blockchain {
@@ -81,9 +78,9 @@ class Blockchain {
             throw constants_1.ERRORS.TypedError('Backend_Error', error.message);
         }
         this.serverInfo = info;
-        const trezorShortcut = getNormalizedTrezorShortcut(this.coinInfo.shortcut);
-        const backendShortcut = this.serverInfo.shortcut;
-        if (trezorShortcut.toLowerCase() !== backendShortcut.toLowerCase()) {
+        const trezorNetworkShortcut = getNormalizedTrezorShortcut(this.coinInfo.shortcut);
+        const backendNetworkShortcut = this.serverInfo.network;
+        if (backendNetworkShortcut.toLowerCase() !== trezorNetworkShortcut.toLowerCase()) {
             throw constants_1.ERRORS.TypedError('Backend_Invalid');
         }
         this.link.on('disconnected', () => {

package/lib/constants/errors.d.ts

@@ -43,6 +43,7 @@ export declare const ERROR_CODES: {
     readonly Failure_PinInvalid: "PIN invalid";
     readonly Failure_PinMismatch: "PIN mismatch";
     readonly Failure_WipeCodeMismatch: "Wipe code mismatch";
+    readonly Failure_EntropyCheck: "";
     readonly Deeplink_VersionMismatch: "Not compatible with current version of the app";
 };
 export type ErrorCode = keyof typeof ERROR_CODES;
@@ -50,6 +51,7 @@ export declare class TrezorError extends Error {
     code: ErrorCode;
     message: string;
     constructor(code: ErrorCode, message: string);
+    toString(): string;
 }
 export declare const TypedError: (id: ErrorCode, message?: string) => TrezorError;
 export declare const serializeError: (payload: any) => any;

package/lib/constants/errors.js

@@ -46,6 +46,7 @@ exports.ERROR_CODES = {
     Failure_PinInvalid: 'PIN invalid',
     Failure_PinMismatch: 'PIN mismatch',
     Failure_WipeCodeMismatch: 'Wipe code mismatch',
+    Failure_EntropyCheck: '',
     Deeplink_VersionMismatch: 'Not compatible with current version of the app',
 };
 class TrezorError extends Error {
@@ -54,6 +55,9 @@ class TrezorError extends Error {
         this.code = code;
         this.message = message;
     }
+    toString() {
+        return `${this.name} (code: ${this.code}): ${this.message}`;
+    }
 }
 exports.TrezorError = TrezorError;
 const TypedError = (id, message) => new TrezorError(id, message || exports.ERROR_CODES[id]);

package/lib/core/AbstractMethod.d.ts

@@ -1,8 +1,8 @@
 import { Capability } from '@trezor/protobuf/lib/messages';
 import { NETWORK } from '../constants';
-import { UI, CallMethodPayload, CallMethodResponse, UiRequestButtonData, UiPromiseCreator, CoreEventMessage, UiRequestConfirmation } from '../events';
 import type { Device } from '../device/Device';
-import type { FirmwareRange, DeviceState, ConnectSettings } from '../types';
+import { CallMethodPayload, CallMethodResponse, CoreEventMessage, UI, UiPromiseCreator, UiRequestButtonData, UiRequestConfirmation } from '../events';
+import type { ConnectSettings, DeviceState, FirmwareRange } from '../types';
 export type Payload<M> = Extract<CallMethodPayload, {
     method: M;
 }> & {

package/lib/core/AbstractMethod.js

@@ -4,10 +4,11 @@ exports.AbstractMethod = exports.DEFAULT_FIRMWARE_RANGE = void 0;
 const connect_common_1 = require("@trezor/connect-common");
 const utils_1 = require("@trezor/utils");
 const constants_1 = require("../constants");
+const config_1 = require("../data/config");
 const events_1 = require("../events");
 const urlUtils_1 = require("../utils/urlUtils");
-const config_1 = require("../data/config");
 exports.DEFAULT_FIRMWARE_RANGE = {
+    UNKNOWN: { min: '1.0.0', max: '0' },
     T1B1: { min: '1.0.0', max: '0' },
     T2T1: { min: '2.0.0', max: '0' },
     T2B1: { min: '2.6.1', max: '0' },

package/lib/core/index.d.ts

@@ -1,8 +1,8 @@
 import EventEmitter from 'events';
-import { TransportInfo, CoreRequestMessage, CoreEventMessage } from '../events';
 import { AbstractMethod } from './AbstractMethod';
-import { LogWriter } from '../utils/debug';
+import { CoreEventMessage, CoreRequestMessage, TransportInfo } from '../events';
 import type { ConnectSettings } from '../types';
+import { LogWriter } from '../utils/debug';
 export declare class Core extends EventEmitter {
     private abortController;
     private callMethods;
@@ -20,7 +20,7 @@ export declare class Core extends EventEmitter {
     handleMessage(message: CoreRequestMessage): void;
     dispose(): void;
     getCurrentMethod(): Promise<AbstractMethod<any, undefined>>;
-    getTransportInfo(): TransportInfo | undefined;
+    getActiveTransports(): TransportInfo[] | undefined;
     enumerate(): void;
     init(settings: ConnectSettings, onCoreEvent: (message: CoreEventMessage) => void, logWriterFactory?: () => LogWriter | undefined): Promise<void>;
 }