@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/blockchainDisconnect.d.ts

@@ -1,15 +1,16 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-import { CoinInfo } from '../types';
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
+  coinInfo: CoinInfo;
+  identity?: string;
 };
 export default class BlockchainDisconnect extends AbstractMethod<'blockchainDisconnect', Params> {
-    init(): void;
-    get info(): string;
-    run(): Promise<{
-        disconnected: boolean;
-    }>;
+  constructor(message: MethodMessage<'blockchainDisconnect'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    disconnected: boolean;
+  }>;
 }
-export {};
-//# sourceMappingURL=blockchainDisconnect.d.ts.map
+export {};

package/lib/api/blockchainDisconnect.js

@@ -1,43 +1,37 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const coinInfo_1 = require("../data/coinInfo");
-const types_1 = require("../types");
-class BlockchainDisconnect extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = [];
-    this.useDevice = false;
-    this.useUi = false;
+import { CoinObj } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { assertBackendSupported, findBackend } from "../backend/BlockchainLink.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class BlockchainDisconnect extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.Assert)(types_1.CoinObj, payload);
-    const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
-    if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    this.params = {
+    } = message;
+    Assert(CoinObj, payload);
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(coinInfo);
+    const params = {
       coinInfo,
       identity: payload.identity
     };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'internal'
+    }];
   }
   get info() {
     return '';
   }
   run() {
-    const backend = (0, BlockchainLink_1.findBackend)(this.params.coinInfo.shortcut, this.params.identity);
+    const backend = findBackend(this.params.coinInfo.shortcut, this.params.identity);
     backend?.disconnect();
     return Promise.resolve({
       disconnected: true
     });
   }
-}
-exports.default = BlockchainDisconnect;
-//# sourceMappingURL=blockchainDisconnect.js.map
+}

package/lib/api/blockchainEstimateFee.d.ts

@@ -1,13 +1,16 @@
-import { AbstractMethod, MethodReturnType, Payload } from '../core/AbstractMethod';
-import type { CoinInfo } from '../types';
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, MethodReturnType, Payload } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    request: Payload<'blockchainEstimateFee'>['request'];
+  coinInfo: CoinInfo;
+  identity?: string;
+  request: Payload<'blockchainEstimateFee'>['request'];
 };
 export default class BlockchainEstimateFee extends AbstractMethod<'blockchainEstimateFee', Params> {
-    init(): void;
-    run(): Promise<MethodReturnType<"blockchainEstimateFee">>;
+  constructor(message: MethodMessage<'blockchainEstimateFee'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<MethodReturnType<"blockchainEstimateFee">>;
 }
-export {};
-//# sourceMappingURL=blockchainEstimateFee.d.ts.map
+export {};

package/lib/api/blockchainEstimateFee.js

@@ -1,22 +1,14 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const fees_1 = require("../backend/fees");
-const coinInfo_1 = require("../data/coinInfo");
-class BlockchainEstimateFee extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.useDevice = false;
-    this.useUi = false;
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validateParams } from "./common/paramsValidator.js";
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { getOrInitFeeLevels } from "../backend/fees/index.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class BlockchainEstimateFee extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    validateParams(payload, [{
       name: 'coin',
       type: 'string',
       required: true
@@ -32,7 +24,7 @@ class BlockchainEstimateFee extends AbstractMethod_1.AbstractMethod {
       identity
     } = payload;
     if (request) {
-      (0, paramsValidator_1.validateParams)(request, [{
+      validateParams(request, [{
         name: 'blocks',
         type: 'array'
       }, {
@@ -43,7 +35,7 @@ class BlockchainEstimateFee extends AbstractMethod_1.AbstractMethod {
         type: 'string'
       }]);
       if (request.specific) {
-        (0, paramsValidator_1.validateParams)(request.specific, [{
+        validateParams(request.specific, [{
           name: 'conservative',
           type: 'boolean'
         }, {
@@ -64,18 +56,23 @@ class BlockchainEstimateFee extends AbstractMethod_1.AbstractMethod {
         }]);
       }
     }
-    const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
-    if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    this.params = {
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(coinInfo);
+    const params = {
       coinInfo,
       identity,
       request
     };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
   }
-  async run() {
+  async run({
+    sendCoreMessage
+  }) {
     const {
       coinInfo,
       identity,
@@ -90,18 +87,16 @@ class BlockchainEstimateFee extends AbstractMethod_1.AbstractMethod {
       levels: []
     };
     if (request?.feeLevels) {
-      const feeLevelsInstance = (0, fees_1.getOrInitFeeLevels)(coinInfo);
+      const feeLevelsInstance = getOrInitFeeLevels(coinInfo);
       if (request.feeLevels === 'smart') {
-        const backend = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage, identity);
+        const backend = await initBlockchain(coinInfo, sendCoreMessage, identity);
         await feeLevelsInstance.load(backend, request);
       }
       feeInfo.levels = feeLevelsInstance.levels;
     } else {
-      const backend = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage, identity);
+      const backend = await initBlockchain(coinInfo, sendCoreMessage, identity);
       feeInfo.levels = await backend.estimateFee(request || {});
     }
     return feeInfo;
   }
-}
-exports.default = BlockchainEstimateFee;
-//# sourceMappingURL=blockchainEstimateFee.js.map
+}

package/lib/api/blockchainEvmRpcCall.d.ts

@@ -1,16 +1,19 @@
-import { AbstractMethod, Payload } from '../core/AbstractMethod';
-import { CoinInfo } from '../types';
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    request: Omit<Payload<'blockchainEvmRpcCall'>, 'method' | 'coin'>;
+  coinInfo: CoinInfo;
+  identity?: string;
+  request: Omit<Payload<'blockchainEvmRpcCall'>, 'method' | 'coin'>;
 };
 export default class BlockchainEvmRpcCall extends AbstractMethod<'blockchainEvmRpcCall', Params> {
-    init(): void;
-    get info(): string;
-    run(): Promise<{
-        data: string;
-    }>;
+  constructor(message: MethodMessage<'blockchainEvmRpcCall'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    data: string;
+  }>;
 }
-export {};
-//# sourceMappingURL=blockchainEvmRpcCall.d.ts.map
+export {};

package/lib/api/blockchainEvmRpcCall.js

@@ -1,21 +1,13 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const coinInfo_1 = require("../data/coinInfo");
-class BlockchainEvmRpcCall extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.useDevice = false;
-    this.useUi = false;
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validateParams } from "./common/paramsValidator.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class BlockchainEvmRpcCall extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    validateParams(payload, [{
       name: 'coin',
       type: 'string',
       required: true
@@ -34,12 +26,9 @@ class BlockchainEvmRpcCall extends AbstractMethod_1.AbstractMethod {
       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 = {
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(coinInfo);
+    const params = {
       coinInfo,
       identity: payload.identity,
       request: {
@@ -48,15 +37,21 @@ class BlockchainEvmRpcCall extends AbstractMethod_1.AbstractMethod {
         data: payload.data
       }
     };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
   }
   get info() {
     return 'Blockchain Evm Rpc Call';
   }
-  async run() {
-    const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
     const response = await backend.rpcCall(this.params.request);
     return response;
   }
-}
-exports.default = BlockchainEvmRpcCall;
-//# sourceMappingURL=blockchainEvmRpcCall.js.map
+}

package/lib/api/blockchainGetAccountBalanceHistory.d.ts

@@ -1,13 +1,16 @@
-import { AbstractMethod, Payload } from '../core/AbstractMethod';
-import type { CoinInfo } from '../types';
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    request: Omit<Payload<'blockchainGetAccountBalanceHistory'>, 'method' | 'coin'>;
+  coinInfo: CoinInfo;
+  identity?: string;
+  request: Omit<Payload<'blockchainGetAccountBalanceHistory'>, 'method' | 'coin'>;
 };
 export default class BlockchainGetAccountBalanceHistory extends AbstractMethod<'blockchainGetAccountBalanceHistory', Params> {
-    init(): void;
-    run(): Promise<import("@trezor/blockchain-link-types/lib/common").AccountBalanceHistory[]>;
+  constructor(message: MethodMessage<'blockchainGetAccountBalanceHistory'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<import("@trezor/blockchain-link-types").AccountBalanceHistory[]>;
 }
-export {};
-//# sourceMappingURL=blockchainGetAccountBalanceHistory.d.ts.map
+export {};

package/lib/api/blockchainGetAccountBalanceHistory.js

@@ -1,21 +1,13 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-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;
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validateParams } from "./common/paramsValidator.js";
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class BlockchainGetAccountBalanceHistory extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    validateParams(payload, [{
       name: 'coin',
       type: 'string',
       required: true
@@ -35,27 +27,34 @@ class BlockchainGetAccountBalanceHistory extends AbstractMethod_1.AbstractMethod
     }, {
       name: 'groupBy',
       type: 'number'
+    }, {
+      name: 'currencies',
+      type: 'array'
     }]);
-    const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
-    if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    this.params = {
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(coinInfo);
+    const params = {
       coinInfo,
       identity: payload.identity,
       request: {
         descriptor: payload.descriptor,
         from: payload.from,
         to: payload.to,
-        groupBy: payload.groupBy
+        groupBy: payload.groupBy,
+        currencies: payload.currencies
       }
     };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
   }
-  async run() {
-    const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
     return backend.getAccountBalanceHistory(this.params.request);
   }
-}
-exports.default = BlockchainGetAccountBalanceHistory;
-//# sourceMappingURL=blockchainGetAccountBalanceHistory.js.map
+}

package/lib/api/blockchainGetContractInfo.d.ts

@@ -0,0 +1,16 @@
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type Params = {
+  coinInfo: CoinInfo;
+  identity?: string;
+  request: Pick<Payload<'blockchainGetContractInfo'>, 'contract' | 'currency' | 'protocols'>;
+};
+export default class BlockchainGetContractInfo extends AbstractMethod<'blockchainGetContractInfo', Params> {
+  constructor(message: MethodMessage<'blockchainGetContractInfo'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<import("@trezor/blockchain-link-types/lib/blockbook-api").ContractInfoResult>;
+}
+export {};

package/lib/api/blockchainGetContractInfo.js

@@ -0,0 +1,46 @@
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+import { validateParams } from "./common/paramsValidator.js";
+export default class BlockchainGetContractInfo extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    validateParams(payload, [{
+      name: 'coin',
+      type: 'string',
+      required: true
+    }, {
+      name: 'contract',
+      type: 'string',
+      required: true
+    }, {
+      name: 'identity',
+      type: 'string'
+    }]);
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(coinInfo);
+    const request = {
+      contract: payload.contract,
+      currency: payload.currency,
+      protocols: payload.protocols
+    };
+    super(message, {
+      coinInfo,
+      identity: payload.identity,
+      request
+    });
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
+    return backend.getContractInfo(this.params.request);
+  }
+}

package/lib/api/blockchainGetCurrentFiatRates.d.ts

@@ -1,17 +1,20 @@
-import { AbstractMethod, Payload } from '../core/AbstractMethod';
-import type { CoinInfo } from '../types';
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    currencies: Payload<'blockchainGetCurrentFiatRates'>['currencies'];
-    token: Payload<'blockchainGetCurrentFiatRates'>['token'];
+  coinInfo: CoinInfo;
+  identity?: string;
+  currencies: Payload<'blockchainGetCurrentFiatRates'>['currencies'];
+  token: Payload<'blockchainGetCurrentFiatRates'>['token'];
 };
 export default class BlockchainGetCurrentFiatRates extends AbstractMethod<'blockchainGetCurrentFiatRates', Params> {
-    init(): void;
-    run(): Promise<{
-        ts: number;
-        rates: import("@trezor/blockchain-link-types/lib/common").FiatRatesBySymbol;
-    }>;
+  constructor(message: MethodMessage<'blockchainGetCurrentFiatRates'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    ts: number;
+    rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
+  }>;
 }
-export {};
-//# sourceMappingURL=blockchainGetCurrentFiatRates.d.ts.map
+export {};

package/lib/api/blockchainGetCurrentFiatRates.js

@@ -1,21 +1,13 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-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;
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import { validateParams } from "./common/paramsValidator.js";
+import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
+import { getCoinInfoOrThrow } from "../data/coinInfo.js";
+export default class BlockchainGetCurrentFiatRates extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    validateParams(payload, [{
       name: 'currencies',
       type: 'array',
       required: false
@@ -30,25 +22,28 @@ class BlockchainGetCurrentFiatRates extends AbstractMethod_1.AbstractMethod {
       name: 'identity',
       type: 'string'
     }]);
-    const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
-    if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    this.params = {
+    const coinInfo = getCoinInfoOrThrow(payload.coin);
+    assertBackendSupported(coinInfo);
+    const params = {
       currencies: payload.currencies,
       token: payload.token,
       coinInfo,
       identity: payload.identity
     };
+    super(message, params);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
   }
-  async run() {
-    const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
     return backend.getCurrentFiatRates({
       currencies: this.params.currencies,
       token: this.params.token
     });
   }
-}
-exports.default = BlockchainGetCurrentFiatRates;
-//# sourceMappingURL=blockchainGetCurrentFiatRates.js.map
+}

package/lib/api/blockchainGetFiatRatesForTimestamps.d.ts

@@ -1,20 +1,23 @@
-import { AbstractMethod, Payload } from '../core/AbstractMethod';
-import type { CoinInfo } from '../types';
+import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage, Payload } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    currencies: Payload<'blockchainGetFiatRatesForTimestamps'>['currencies'];
-    timestamps: Payload<'blockchainGetFiatRatesForTimestamps'>['timestamps'];
-    token: Payload<'blockchainGetFiatRatesForTimestamps'>['token'];
+  coinInfo: CoinInfo;
+  identity?: string;
+  currencies: Payload<'blockchainGetFiatRatesForTimestamps'>['currencies'];
+  timestamps: Payload<'blockchainGetFiatRatesForTimestamps'>['timestamps'];
+  token: Payload<'blockchainGetFiatRatesForTimestamps'>['token'];
 };
 export default class BlockchainGetFiatRatesForTimestamps extends AbstractMethod<'blockchainGetFiatRatesForTimestamps', Params> {
-    init(): void;
-    run(): Promise<{
-        tickers: {
-            ts: number;
-            rates: import("@trezor/blockchain-link-types/lib/common").FiatRatesBySymbol;
-        }[];
-    }>;
+  constructor(message: MethodMessage<'blockchainGetFiatRatesForTimestamps'>);
+  get requiredPermissions(): PermissionRequest[];
+  run({
+    sendCoreMessage
+  }: MethodContext): Promise<{
+    tickers: {
+      ts: number;
+      rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
+    }[];
+  }>;
 }
-export {};
-//# sourceMappingURL=blockchainGetFiatRatesForTimestamps.d.ts.map
+export {};