@trezor/connect 9.0.0-beta.1

package/lib/api/bitcoin/signtxVerify.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyTicketTx = exports.verifyTx = void 0;
+const utxo_lib_1 = require("@trezor/utxo-lib");
+const constants_1 = require("../../constants");
+const pathUtils_1 = require("../../utils/pathUtils");
+const derivePubKeyHash = async (address_n, getHDNode, coinInfo) => {
+    if (address_n.length === 5) {
+        const response = await getHDNode(address_n.slice(0, 4), coinInfo);
+        const node = utxo_lib_1.bip32.fromBase58(response.xpub, coinInfo.network);
+        return node.derive(address_n[address_n.length - 1]);
+    }
+    const response = await getHDNode(address_n, coinInfo);
+    return utxo_lib_1.bip32.fromBase58(response.xpub, coinInfo.network);
+};
+const deriveOutputScript = async (getHDNode, output, coinInfo) => {
+    if ('multisig' in output)
+        return;
+    if ('op_return_data' in output) {
+        return utxo_lib_1.payments.embed({ data: [Buffer.from(output.op_return_data, 'hex')] })
+            .output;
+    }
+    if (output.address) {
+        return utxo_lib_1.address.toOutputScript(output.address, coinInfo.network);
+    }
+    if (!output.address_n) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'deriveOutputScript: Neither address or address_n is set');
+    }
+    const scriptType = (0, pathUtils_1.getOutputScriptType)(output.address_n);
+    const node = await derivePubKeyHash(output.address_n, getHDNode, coinInfo);
+    const payment = { hash: node.identifier, network: coinInfo.network };
+    if (scriptType === 'PAYTOADDRESS') {
+        return utxo_lib_1.payments.p2pkh(payment).output;
+    }
+    if (scriptType === 'PAYTOSCRIPTHASH') {
+        return utxo_lib_1.payments.p2sh(payment).output;
+    }
+    if (scriptType === 'PAYTOP2SHWITNESS') {
+        return utxo_lib_1.payments.p2sh({
+            redeem: utxo_lib_1.payments.p2wpkh(payment),
+        }).output;
+    }
+    if (scriptType === 'PAYTOWITNESS') {
+        return utxo_lib_1.payments.p2wpkh(payment).output;
+    }
+    if (scriptType === 'PAYTOTAPROOT') {
+        return utxo_lib_1.payments.p2tr({
+            pubkey: node.publicKey,
+            network: coinInfo.network,
+        }).output;
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', `deriveOutputScript: Unknown script type ${scriptType}`);
+};
+const verifyTx = async (getHDNode, inputs, outputs, serializedTx, coinInfo) => {
+    const bitcoinTx = utxo_lib_1.Transaction.fromHex(serializedTx, { network: coinInfo.network });
+    if (inputs.length !== bitcoinTx.ins.length) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction inputs invalid length');
+    }
+    if (outputs.length !== bitcoinTx.outs.length) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'verifyTx: Signed transaction outputs invalid length');
+    }
+    for (let i = 0; i < outputs.length; i++) {
+        const scriptB = bitcoinTx.outs[i].script;
+        if (outputs[i].amount) {
+            const { amount } = outputs[i];
+            if (amount.toString() !== bitcoinTx.outs[i].value) {
+                throw constants_1.ERRORS.TypedError('Runtime', `verifyTx: Wrong output amount at output ${i}. Requested: ${amount}, signed: ${bitcoinTx.outs[i].value}`);
+            }
+        }
+        const scriptA = await deriveOutputScript(getHDNode, outputs[i], coinInfo);
+        if (scriptA && scriptA.compare(scriptB) !== 0) {
+            throw constants_1.ERRORS.TypedError('Runtime', `verifyTx: Output ${i} scripts differ`);
+        }
+    }
+    return bitcoinTx;
+};
+exports.verifyTx = verifyTx;
+const verifyTicketTx = async (getHDNode, inputs, outputs, serializedTx, coinInfo) => {
+    const bitcoinTx = utxo_lib_1.Transaction.fromHex(serializedTx, { network: coinInfo.network });
+    if (inputs.length !== bitcoinTx.ins.length) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'verifyTicketTx: Signed transaction inputs invalid length');
+    }
+    if (outputs.length !== bitcoinTx.outs.length || outputs.length !== 3) {
+        throw constants_1.ERRORS.TypedError('Runtime', 'verifyTicketTx: Signed transaction outputs invalid length');
+    }
+    for (let i = 0; i < outputs.length; i++) {
+        const scriptB = bitcoinTx.outs[i].script;
+        const output = outputs[i];
+        let scriptA;
+        if (i === 0) {
+            const { amount } = output;
+            if (amount !== bitcoinTx.outs[i].value) {
+                throw constants_1.ERRORS.TypedError('Runtime', `verifyTicketTx: Wrong output amount at output ${i}. Requested: ${amount}, signed: ${bitcoinTx.outs[i].value}`);
+            }
+            scriptA = utxo_lib_1.payments.sstxpkh({
+                address: output.address,
+                network: coinInfo.network,
+            }).output;
+        }
+        else if (i === 1) {
+            if (output.address) {
+                throw constants_1.ERRORS.TypedError('Runtime', `verifyTicketTx: Output 1 should not have address.`);
+            }
+            if (!output.address_n) {
+                throw constants_1.ERRORS.TypedError('Runtime', `verifyTicketTx: Output 1 should have address_n.`);
+            }
+            const node = await derivePubKeyHash(output.address_n, getHDNode, coinInfo);
+            scriptA = utxo_lib_1.payments.sstxcommitment({
+                hash: node.identifier,
+                amount: output.amount.toString(),
+                network: coinInfo.network,
+            }).output;
+        }
+        else {
+            const { amount } = output;
+            if (amount !== bitcoinTx.outs[i].value) {
+                throw constants_1.ERRORS.TypedError('Runtime', `verifyTicketTx: Wrong output amount at output ${i}. Requested: ${amount}, signed: ${bitcoinTx.outs[i].value}`);
+            }
+            scriptA = utxo_lib_1.payments.sstxchange({
+                address: output.address,
+                network: coinInfo.network,
+            }).output;
+        }
+        if (scriptA && scriptA.compare(scriptB) !== 0) {
+            throw constants_1.ERRORS.TypedError('Runtime', `verifyTx: Output ${i} scripts differ`);
+        }
+    }
+};
+exports.verifyTicketTx = verifyTicketTx;
+//# sourceMappingURL=signtxVerify.js.map

package/lib/api/blockchainDisconnect.d.ts

@@ -0,0 +1,13 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    coinInfo: CoinInfo;
+};
+export default class BlockchainDisconnect extends AbstractMethod<'blockchainDisconnect', Params> {
+    init(): void;
+    run(): Promise<{
+        disconnected: boolean;
+    }>;
+}
+export {};
+//# sourceMappingURL=blockchainDisconnect.d.ts.map

package/lib/api/blockchainDisconnect.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainDisconnect extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = [];
+        this.info = '';
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [{ name: 'coin', type: 'string', required: true }]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            coinInfo,
+        };
+    }
+    run() {
+        const backend = (0, BlockchainLink_1.findBackend)(this.params.coinInfo.name);
+        if (backend) {
+            backend.disconnect();
+        }
+        return Promise.resolve({ disconnected: true });
+    }
+}
+exports.default = BlockchainDisconnect;
+//# sourceMappingURL=blockchainDisconnect.js.map

package/lib/api/blockchainEstimateFee.d.ts

@@ -0,0 +1,12 @@
+import { Payload, AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    coinInfo: CoinInfo;
+    request: Payload<'blockchainEstimateFee'>['request'];
+};
+export default class BlockchainEstimateFee extends AbstractMethod<'blockchainEstimateFee', Params> {
+    init(): void;
+    run(): Promise<import("../types/api/blockchainEstimateFee").BlockchainEstimatedFee | import("../types/api/blockchainEstimateFee").BlockchainEstimatedFeeLevel>;
+}
+export {};
+//# sourceMappingURL=blockchainEstimateFee.d.ts.map

package/lib/api/blockchainEstimateFee.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const Fees_1 = require("./bitcoin/Fees");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainEstimateFee extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'coin', type: 'string', required: true },
+            { name: 'request', type: 'object' },
+        ]);
+        const { request } = payload;
+        if (request) {
+            (0, paramsValidator_1.validateParams)(request, [
+                { name: 'blocks', type: 'array' },
+                { name: 'specific', type: 'object' },
+                { name: 'feeLevels', type: 'string' },
+            ]);
+            if (request.specific) {
+                (0, paramsValidator_1.validateParams)(request.specific, [
+                    { name: 'conservative', type: 'boolean' },
+                    { name: 'data', type: 'string' },
+                    { name: 'from', type: 'string' },
+                    { name: 'to', type: 'string' },
+                    { name: 'txsize', type: 'number' },
+                ]);
+            }
+        }
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            coinInfo,
+            request,
+        };
+    }
+    async run() {
+        const { coinInfo, request } = this.params;
+        const feeInfo = {
+            blockTime: coinInfo.blocktime,
+            minFee: coinInfo.minFee,
+            maxFee: coinInfo.maxFee,
+            dustLimit: coinInfo.type === 'bitcoin' ? coinInfo.dustLimit : undefined,
+            levels: [],
+        };
+        if (request && request.feeLevels) {
+            const fees = new Fees_1.FeeLevels(coinInfo);
+            if (request.feeLevels === 'smart' && coinInfo.shortcut !== 'DOGE') {
+                const backend = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage);
+                await fees.load(backend);
+            }
+            feeInfo.levels = fees.levels;
+        }
+        else {
+            const backend = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage);
+            feeInfo.levels = await backend.estimateFee(request || {});
+        }
+        return feeInfo;
+    }
+}
+exports.default = BlockchainEstimateFee;
+//# sourceMappingURL=blockchainEstimateFee.js.map

package/lib/api/blockchainGetAccountBalanceHistory.d.ts

@@ -0,0 +1,12 @@
+import { Payload, AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    coinInfo: CoinInfo;
+    request: Omit<Payload<'blockchainGetAccountBalanceHistory'>, 'method' | 'coin'>;
+};
+export default class BlockchainGetAccountBalanceHistory extends AbstractMethod<'blockchainGetAccountBalanceHistory', Params> {
+    init(): void;
+    run(): Promise<import("packages/blockchain-link/lib/types/common").AccountBalanceHistory[]>;
+}
+export {};
+//# sourceMappingURL=blockchainGetAccountBalanceHistory.d.ts.map

package/lib/api/blockchainGetAccountBalanceHistory.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainGetAccountBalanceHistory extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'coin', type: 'string', required: true },
+            { name: 'descriptor', type: 'string', required: true },
+            { name: 'from', type: 'number' },
+            { name: 'to', type: 'number' },
+            { name: 'groupBy', type: 'number' },
+        ]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            coinInfo,
+            request: {
+                descriptor: payload.descriptor,
+                from: payload.from,
+                to: payload.to,
+                groupBy: payload.groupBy,
+            },
+        };
+    }
+    async run() {
+        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        return backend.getAccountBalanceHistory(this.params.request);
+    }
+}
+exports.default = BlockchainGetAccountBalanceHistory;
+//# sourceMappingURL=blockchainGetAccountBalanceHistory.js.map

package/lib/api/blockchainGetCurrentFiatRates.d.ts

@@ -0,0 +1,15 @@
+import { Payload, AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    coinInfo: CoinInfo;
+    currencies: Payload<'blockchainGetCurrentFiatRates'>['currencies'];
+};
+export default class BlockchainGetCurrentFiatRates extends AbstractMethod<'blockchainGetCurrentFiatRates', Params> {
+    init(): void;
+    run(): Promise<{
+        ts: number;
+        rates: import("packages/blockchain-link/lib").FiatRates;
+    }>;
+}
+export {};
+//# sourceMappingURL=blockchainGetCurrentFiatRates.d.ts.map

package/lib/api/blockchainGetCurrentFiatRates.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainGetCurrentFiatRates extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'currencies', type: 'array', required: false },
+            { name: 'coin', type: 'string', required: true },
+        ]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            currencies: payload.currencies,
+            coinInfo,
+        };
+    }
+    async run() {
+        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        return backend.getCurrentFiatRates({ currencies: this.params.currencies });
+    }
+}
+exports.default = BlockchainGetCurrentFiatRates;
+//# sourceMappingURL=blockchainGetCurrentFiatRates.js.map

package/lib/api/blockchainGetFiatRatesForTimestamps.d.ts

@@ -0,0 +1,17 @@
+import { Payload, AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    coinInfo: CoinInfo;
+    timestamps: Payload<'blockchainGetFiatRatesForTimestamps'>['timestamps'];
+};
+export default class BlockchainGetFiatRatesForTimestamps extends AbstractMethod<'blockchainGetFiatRatesForTimestamps', Params> {
+    init(): void;
+    run(): Promise<{
+        tickers: {
+            ts: number;
+            rates: import("packages/blockchain-link/lib").FiatRates;
+        }[];
+    }>;
+}
+export {};
+//# sourceMappingURL=blockchainGetFiatRatesForTimestamps.d.ts.map

package/lib/api/blockchainGetFiatRatesForTimestamps.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainGetFiatRatesForTimestamps extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'timestamps', type: 'array', required: true },
+            { name: 'coin', type: 'string', required: true },
+        ]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            timestamps: payload.timestamps,
+            coinInfo,
+        };
+    }
+    async run() {
+        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        return backend.getFiatRatesForTimestamps({ timestamps: this.params.timestamps });
+    }
+}
+exports.default = BlockchainGetFiatRatesForTimestamps;
+//# sourceMappingURL=blockchainGetFiatRatesForTimestamps.js.map

package/lib/api/blockchainGetTransactions.d.ts

@@ -0,0 +1,12 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    txs: string[];
+    coinInfo: CoinInfo;
+};
+export default class BlockchainGetTransactions extends AbstractMethod<'blockchainGetTransactions', Params> {
+    init(): void;
+    run(): Promise<import("packages/blockchain-link/lib").TypedRawTransaction[]>;
+}
+export {};
+//# sourceMappingURL=blockchainGetTransactions.d.ts.map

package/lib/api/blockchainGetTransactions.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainGetTransactions extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'txs', type: 'array', required: true },
+            { name: 'coin', type: 'string', required: true },
+        ]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            txs: payload.txs,
+            coinInfo,
+        };
+    }
+    async run() {
+        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        return backend.getTransactions(this.params.txs);
+    }
+}
+exports.default = BlockchainGetTransactions;
+//# sourceMappingURL=blockchainGetTransactions.js.map

package/lib/api/blockchainSetCustomBackend.d.ts

@@ -0,0 +1,11 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    coinInfo: CoinInfo;
+};
+export default class BlockchainSetCustomBackend extends AbstractMethod<'blockchainSetCustomBackend', Params> {
+    init(): void;
+    run(): Promise<boolean>;
+}
+export {};
+//# sourceMappingURL=blockchainSetCustomBackend.d.ts.map

package/lib/api/blockchainSetCustomBackend.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainSetCustomBackend extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = [];
+        this.info = '';
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'coin', type: 'string', required: true },
+            { name: 'blockchainLink', type: 'object' },
+        ]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.setCustomBackend)(coinInfo, payload.blockchainLink);
+        this.params = {
+            coinInfo,
+        };
+    }
+    async run() {
+        const current = (0, BlockchainLink_1.findBackend)(this.params.coinInfo.name);
+        if (current) {
+            current.disconnect();
+            await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        }
+        return true;
+    }
+}
+exports.default = BlockchainSetCustomBackend;
+//# sourceMappingURL=blockchainSetCustomBackend.js.map

package/lib/api/blockchainSubscribe.d.ts

@@ -0,0 +1,14 @@
+import { Payload, AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    accounts: Payload<'blockchainSubscribe'>['accounts'];
+    coinInfo: CoinInfo;
+};
+export default class BlockchainSubscribe extends AbstractMethod<'blockchainSubscribe', Params> {
+    init(): void;
+    run(): Promise<{
+        subscribed: boolean;
+    }>;
+}
+export {};
+//# sourceMappingURL=blockchainSubscribe.d.ts.map

package/lib/api/blockchainSubscribe.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainSubscribe extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'accounts', type: 'array', allowEmpty: true },
+            { name: 'coin', type: 'string', required: true },
+        ]);
+        if (payload.accounts) {
+            payload.accounts.forEach(account => {
+                (0, paramsValidator_1.validateParams)(account, [{ name: 'descriptor', type: 'string', required: true }]);
+            });
+        }
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            accounts: payload.accounts,
+            coinInfo,
+        };
+    }
+    async run() {
+        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        return backend.subscribe(this.params.accounts);
+    }
+}
+exports.default = BlockchainSubscribe;
+//# sourceMappingURL=blockchainSubscribe.js.map

package/lib/api/blockchainSubscribeFiatRates.d.ts

@@ -0,0 +1,14 @@
+import { Payload, AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    currency: Payload<'blockchainSubscribeFiatRates'>['currency'];
+    coinInfo: CoinInfo;
+};
+export default class BlockchainSubscribeFiatRates extends AbstractMethod<'blockchainSubscribeFiatRates', Params> {
+    init(): void;
+    run(): Promise<{
+        subscribed: boolean;
+    }>;
+}
+export {};
+//# sourceMappingURL=blockchainSubscribeFiatRates.d.ts.map

package/lib/api/blockchainSubscribeFiatRates.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+const coinInfo_1 = require("../data/coinInfo");
+class BlockchainSubscribeFiatRates extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.useDevice = false;
+        this.useUi = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'currency', type: 'string', required: false },
+            { name: 'coin', type: 'string', required: true },
+        ]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        this.params = {
+            currency: payload.currency,
+            coinInfo,
+        };
+    }
+    async run() {
+        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        return backend.subscribeFiatRates(this.params.currency);
+    }
+}
+exports.default = BlockchainSubscribeFiatRates;
+//# sourceMappingURL=blockchainSubscribeFiatRates.js.map

package/lib/api/blockchainUnsubscribe.d.ts

@@ -0,0 +1,14 @@
+import { Payload, AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    accounts: Payload<'blockchainUnsubscribe'>['accounts'];
+    coinInfo: CoinInfo;
+};
+export default class BlockchainUnsubscribe extends AbstractMethod<'blockchainUnsubscribe', Params> {
+    init(): void;
+    run(): Promise<{
+        subscribed: boolean;
+    }>;
+}
+export {};
+//# sourceMappingURL=blockchainUnsubscribe.d.ts.map