@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.2

package/libESM/api/blockchainEstimateFee.mjs

@@ -1,106 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { getOrInitFeeLevels } from "../backend/fees/index.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainEstimateFee extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'request',
-      type: 'object'
-    }]);
-    const {
-      request,
-      identity
-    } = payload;
-    if (request) {
-      validateParams(request, [{
-        name: 'blocks',
-        type: 'array'
-      }, {
-        name: 'specific',
-        type: 'object'
-      }, {
-        name: 'feeLevels',
-        type: 'string'
-      }]);
-      if (request.specific) {
-        validateParams(request.specific, [{
-          name: 'conservative',
-          type: 'boolean'
-        }, {
-          name: 'data',
-          type: 'string'
-        }, {
-          name: 'from',
-          type: 'string'
-        }, {
-          name: 'to',
-          type: 'string'
-        }, {
-          name: 'txsize',
-          type: 'number'
-        }, {
-          name: 'newAccountProgramName',
-          type: 'string'
-        }]);
-      }
-    }
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity,
-      request
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const {
-      coinInfo,
-      identity,
-      request
-    } = this.params;
-    const feeInfo = {
-      blockTime: coinInfo.blockTime,
-      minFee: coinInfo.minFee,
-      maxFee: coinInfo.maxFee,
-      minPriorityFee: coinInfo.minPriorityFee,
-      dustLimit: coinInfo.type === 'bitcoin' ? coinInfo.dustLimit : undefined,
-      levels: []
-    };
-    if (request?.feeLevels) {
-      const feeLevelsInstance = getOrInitFeeLevels(coinInfo);
-      if (request.feeLevels === 'smart') {
-        const backend = await initBlockchain(coinInfo, sendCoreMessage, identity);
-        await feeLevelsInstance.load(backend, request);
-      }
-      feeInfo.levels = feeLevelsInstance.levels;
-    } else {
-      const backend = await initBlockchain(coinInfo, sendCoreMessage, identity);
-      feeInfo.levels = await backend.estimateFee(request || {});
-    }
-    return feeInfo;
-  }
-}

package/libESM/api/blockchainEvmRpcCall.d.mts

@@ -1,17 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    request: Omit<Payload<'blockchainEvmRpcCall'>, 'method' | 'coin'>;
-};
-export default class BlockchainEvmRpcCall extends AbstractMethod<'blockchainEvmRpcCall', Params> {
-    constructor(message: MethodMessage<'blockchainEvmRpcCall'>);
-    get requiredPermissions(): MethodPermission[];
-    get info(): string;
-    run({ sendCoreMessage }: MethodContext): Promise<{
-        data: string;
-    }>;
-}
-export {};

package/libESM/api/blockchainEvmRpcCall.mjs

@@ -1,61 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainEvmRpcCall extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'from',
-      type: 'string'
-    }, {
-      name: 'to',
-      type: 'string',
-      required: true
-    }, {
-      name: 'data',
-      type: 'string',
-      required: true
-    }]);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity: payload.identity,
-      request: {
-        from: payload.from,
-        to: payload.to,
-        data: payload.data
-      }
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  get info() {
-    return 'Blockchain Evm Rpc Call';
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
-    const response = await backend.rpcCall(this.params.request);
-    return response;
-  }
-}

package/libESM/api/blockchainGetAccountBalanceHistory.d.mts

@@ -1,14 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-    request: Omit<Payload<'blockchainGetAccountBalanceHistory'>, 'method' | 'coin'>;
-};
-export default class BlockchainGetAccountBalanceHistory extends AbstractMethod<'blockchainGetAccountBalanceHistory', Params> {
-    constructor(message: MethodMessage<'blockchainGetAccountBalanceHistory'>);
-    get requiredPermissions(): MethodPermission[];
-    run({ sendCoreMessage }: MethodContext): Promise<import("@trezor/blockchain-link-types").AccountBalanceHistory[]>;
-}
-export {};

package/libESM/api/blockchainGetAccountBalanceHistory.mjs

@@ -1,64 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainGetAccountBalanceHistory extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'descriptor',
-      type: 'string',
-      required: true
-    }, {
-      name: 'from',
-      type: 'number'
-    }, {
-      name: 'to',
-      type: 'number'
-    }, {
-      name: 'groupBy',
-      type: 'number'
-    }, {
-      name: 'currencies',
-      type: 'array'
-    }]);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity: payload.identity,
-      request: {
-        descriptor: payload.descriptor,
-        from: payload.from,
-        to: payload.to,
-        groupBy: payload.groupBy,
-        currencies: payload.currencies
-      }
-    };
-    super(message, params);
-    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.getAccountBalanceHistory(this.params.request);
-  }
-}

package/libESM/api/blockchainGetContractInfo.d.mts

@@ -1,14 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-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(): MethodPermission[];
-    run({ sendCoreMessage }: MethodContext): Promise<import("@trezor/blockchain-link-types/libESM/blockbook-api").ContractInfoResult>;
-}
-export {};

package/libESM/api/blockchainGetContractInfo.mjs

@@ -1,50 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-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 = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(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/libESM/api/blockchainGetCurrentFiatRates.d.mts

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

package/libESM/api/blockchainGetCurrentFiatRates.mjs

@@ -1,53 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainGetCurrentFiatRates extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'currencies',
-      type: 'array',
-      required: false
-    }, {
-      name: 'token',
-      type: 'string'
-    }, {
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }]);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(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({
-    sendCoreMessage
-  }) {
-    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
-    return backend.getCurrentFiatRates({
-      currencies: this.params.currencies,
-      token: this.params.token
-    });
-  }
-}

package/libESM/api/blockchainGetFiatRatesForTimestamps.d.mts

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

package/libESM/api/blockchainGetFiatRatesForTimestamps.mjs

@@ -1,59 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainGetFiatRatesForTimestamps extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'currencies',
-      type: 'array',
-      required: false
-    }, {
-      name: 'timestamps',
-      type: 'array',
-      required: true
-    }, {
-      name: 'token',
-      type: 'string'
-    }, {
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }]);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    const params = {
-      currencies: payload.currencies,
-      timestamps: payload.timestamps,
-      token: payload.token,
-      coinInfo,
-      identity: payload.identity
-    };
-    super(message, params);
-    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.getFiatRatesForTimestamps({
-      currencies: this.params.currencies,
-      timestamps: this.params.timestamps,
-      token: this.params.token
-    });
-  }
-}

package/libESM/api/blockchainGetInfo.d.mts

@@ -1,13 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    coinInfo: CoinInfo;
-    identity?: string;
-};
-export default class BlockchainGetInfo extends AbstractMethod<'blockchainGetInfo', Params> {
-    constructor(message: MethodMessage<'blockchainGetInfo'>);
-    get requiredPermissions(): MethodPermission[];
-    run({ sendCoreMessage }: MethodContext): Promise<import("@trezor/blockchain-link-types").ServerInfo>;
-}
-export {};

package/libESM/api/blockchainGetInfo.mjs

@@ -1,41 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainGetInfo extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }]);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      identity: payload.identity
-    };
-    super(message, params);
-    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.getNetworkInfo();
-  }
-}

package/libESM/api/blockchainGetTransactions.d.mts

@@ -1,15 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    txs: string[];
-    coinInfo: CoinInfo;
-    identity?: string;
-};
-export default class BlockchainGetTransactions extends AbstractMethod<'blockchainGetTransactions', Params> {
-    constructor(message: MethodMessage<'blockchainGetTransactions'>);
-    get requiredPermissions(): MethodPermission[];
-    init(): void;
-    run({ sendCoreMessage }: MethodContext): Promise<import("@trezor/blockchain-link-types").Transaction[]>;
-}
-export {};

package/libESM/api/blockchainGetTransactions.mjs

@@ -1,47 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainGetTransactions extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'txs',
-      type: 'array',
-      required: true
-    }, {
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }]);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    isBackendSupported(coinInfo);
-    const params = {
-      txs: payload.txs,
-      coinInfo,
-      identity: payload.identity
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  init() {}
-  async run({
-    sendCoreMessage
-  }) {
-    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
-    return backend.getTransactions(this.params.txs);
-  }
-}

package/libESM/api/blockchainSetCustomBackend.d.mts

@@ -1,13 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    coinInfo: CoinInfo;
-};
-export default class BlockchainSetCustomBackend extends AbstractMethod<'blockchainSetCustomBackend', Params> {
-    constructor(message: MethodMessage<'blockchainSetCustomBackend'>);
-    get requiredPermissions(): MethodPermission[];
-    get info(): string;
-    run(): Promise<boolean>;
-}
-export {};

package/libESM/api/blockchainSetCustomBackend.mjs

@@ -1,41 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validateParams } from "./common/paramsValidator.mjs";
-import { reconnectAllBackends, setCustomBackend } from "../backend/BlockchainLink.mjs";
-import { getCoinInfo } from "../data/coinInfo.mjs";
-export default class BlockchainSetCustomBackend extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'blockchainLink',
-      type: 'object'
-    }]);
-    const coinInfo = getCoinInfo(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    setCustomBackend(coinInfo, payload.blockchainLink);
-    const params = {
-      coinInfo
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  get info() {
-    return '';
-  }
-  async run() {
-    await reconnectAllBackends(this.params.coinInfo);
-    return true;
-  }
-}

package/libESM/api/blockchainSubscribe.d.mts

@@ -1,17 +0,0 @@
-import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage, Payload } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-type Params = {
-    accounts: Payload<'blockchainSubscribe'>['accounts'];
-    blocks: boolean;
-    coinInfo: CoinInfo;
-    identity?: string;
-};
-export default class BlockchainSubscribe extends AbstractMethod<'blockchainSubscribe', Params> {
-    constructor(message: MethodMessage<'blockchainSubscribe'>);
-    get requiredPermissions(): MethodPermission[];
-    run({ sendCoreMessage }: MethodContext): Promise<{
-        subscribed: boolean;
-    }>;
-}
-export {};