@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/blockchainEstimateFee.mjs

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,64 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,17 @@
+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 {};