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

package/libESM/api/tron/api/tronSignTransaction.mjs

@@ -1,129 +0,0 @@
-import { bytesToHex } from "@noble/hashes/utils.js";
-import { TronSignTransaction as TronSignTransactionSchema } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
-import { validatePath } from "../../../utils/pathUtils.mjs";
-import { encodeTronContractRawData } from "../tronEncode.mjs";
-import { encodeBroadcastTransaction } from "../tronProtobuf.mjs";
-const transformContract = input => {
-  switch (input.type) {
-    case 'FreezeBalanceV2Contract':
-      {
-        const {
-          value
-        } = input.parameter;
-        return {
-          type: 'FreezeBalanceV2Contract',
-          parameter: {
-            value: {
-              owner_address: value.owner_address,
-              balance: 'frozen_balance' in value ? value.frozen_balance : value.balance,
-              resource: value.resource
-            }
-          }
-        };
-      }
-    case 'UnfreezeBalanceV2Contract':
-      {
-        const {
-          value
-        } = input.parameter;
-        return {
-          type: 'UnfreezeBalanceV2Contract',
-          parameter: {
-            value: {
-              owner_address: value.owner_address,
-              balance: 'unfreeze_balance' in value ? value.unfreeze_balance : value.balance,
-              resource: value.resource
-            }
-          }
-        };
-      }
-    case 'VoteWitnessContract':
-      {
-        const {
-          value
-        } = input.parameter;
-        return {
-          type: 'VoteWitnessContract',
-          parameter: {
-            value: {
-              owner_address: value.owner_address,
-              votes: value.votes.map(vote => ({
-                address: 'vote_address' in vote ? vote.vote_address : vote.address,
-                count: 'vote_count' in vote ? vote.vote_count : vote.count
-              }))
-            }
-          }
-        };
-      }
-    case 'TransferContract':
-    case 'TriggerSmartContract':
-    case 'WithdrawExpireUnfreezeContract':
-      return input;
-  }
-};
-const contractMapping = {
-  TransferContract: 'TronTransferContract',
-  TriggerSmartContract: 'TronTriggerSmartContract',
-  FreezeBalanceV2Contract: 'TronFreezeBalanceV2Contract',
-  UnfreezeBalanceV2Contract: 'TronUnfreezeBalanceV2Contract',
-  WithdrawExpireUnfreezeContract: 'TronWithdrawUnfreeze',
-  VoteWitnessContract: 'TronVoteWitnessContract'
-};
-export default class TronSignTransaction extends AbstractMethod {
-  hasBundle;
-  progress = 0;
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    const contractType = payload.contract?.[0]?.type;
-    if (!contractType || !(contractType in contractMapping)) {
-      throw ERRORS.TypedError('Method_InvalidParameter', `Unsupported Tron contract type: ${contractType ?? 'undefined'}`);
-    }
-    Assert(TronSignTransactionSchema, payload);
-    const path = validatePath(payload.path, 3);
-    const contract = transformContract(payload.contract[0]);
-    const params = {
-      tx: {
-        address_n: path,
-        ref_block_bytes: payload.ref_block_bytes,
-        ref_block_hash: payload.ref_block_hash,
-        expiration: payload.expiration,
-        timestamp: payload.timestamp,
-        fee_limit: payload.fee_limit,
-        data: payload.data
-      },
-      contract
-    };
-    super(message, params);
-    this.requiredDeviceCapabilities = ['Capability_Tron'];
-  }
-  get requiredPermissions() {
-    return ['read', 'write'];
-  }
-  get info() {
-    return 'Sign Tron transaction';
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    await cmd.typedCall('TronSignTx', 'TronContractRequest', this.params.tx);
-    const {
-      message
-    } = await cmd.typedCall(contractMapping[this.params.contract.type], 'TronSignature', this.params.contract.parameter.value);
-    const {
-      signature
-    } = message;
-    let serializedTx;
-    try {
-      const rawData = encodeTronContractRawData(this.params.contract, this.params.tx);
-      serializedTx = encodeBroadcastTransaction(bytesToHex(rawData), signature);
-    } catch {}
-    return {
-      signature,
-      serializedTx
-    };
-  }
-}

package/libESM/api/tron/tronEncode.d.mts

@@ -1,12 +0,0 @@
-import type { TronContracts } from '@trezor/connect-common/libESM/types/api/tron';
-export declare const TRON_BANDWIDTH_FORMULA_OVERHEAD: number;
-type BlockParams = {
-    ref_block_bytes: string;
-    ref_block_hash: string;
-    expiration: number;
-    timestamp: number;
-    fee_limit?: number;
-    data?: string;
-};
-export declare const encodeTronContractRawData: (contract: TronContracts, blockParams: BlockParams) => Uint8Array;
-export {};

package/libESM/api/tron/tronEncode.mjs

@@ -1,77 +0,0 @@
-import { create, toBinary } from "@bufbuild/protobuf";
-import { hexToBytes } from "@noble/hashes/utils.js";
-import { protobufManager } from "@trezor/protobuf";
-import { TronRawContractType } from "@trezor/protobuf/libESM/definitions/messages-tron.mjs";
-export const TRON_BANDWIDTH_FORMULA_OVERHEAD = 3 + 64 + 67;
-const contractTypeUrl = name => `type.googleapis.com/protocol.${name}`;
-const getSchema = name => protobufManager.findSchema(name).schema;
-const encodeInnerContract = contract => {
-  switch (contract.type) {
-    case 'TransferContract':
-      {
-        const {
-          owner_address,
-          to_address,
-          amount
-        } = contract.parameter.value;
-        const schema = getSchema('TronTransferContract');
-        return {
-          type: TronRawContractType.TransferContract,
-          bytes: toBinary(schema, create(schema, {
-            ownerAddress: hexToBytes(owner_address ?? ''),
-            toAddress: hexToBytes(to_address ?? ''),
-            amount: BigInt(amount ?? 0)
-          }))
-        };
-      }
-    case 'TriggerSmartContract':
-      {
-        const {
-          owner_address,
-          contract_address,
-          data
-        } = contract.parameter.value;
-        const schema = getSchema('TronTriggerSmartContract');
-        return {
-          type: TronRawContractType.TriggerSmartContract,
-          bytes: toBinary(schema, create(schema, {
-            ownerAddress: hexToBytes(owner_address ?? ''),
-            contractAddress: hexToBytes(contract_address ?? ''),
-            data: hexToBytes(data ?? '')
-          }))
-        };
-      }
-    default:
-      throw new Error(`Unsupported contract type for encoding: ${contract.type}`);
-  }
-};
-export const encodeTronContractRawData = (contract, blockParams) => {
-  const {
-    type,
-    bytes
-  } = encodeInnerContract(contract);
-  const {
-    ref_block_bytes,
-    ref_block_hash,
-    expiration,
-    timestamp,
-    fee_limit,
-    data
-  } = blockParams;
-  const schema = getSchema('TronRawTransaction');
-  return toBinary(schema, create(schema, {
-    refBlockBytes: hexToBytes(ref_block_bytes),
-    refBlockHash: hexToBytes(ref_block_hash),
-    expiration: BigInt(expiration),
-    timestamp: BigInt(timestamp),
-    feeLimit: contract.type === 'TriggerSmartContract' ? BigInt(fee_limit ?? 0) : undefined,
-    data: data ? hexToBytes(data) : undefined,
-    contract: [{
-      type,
-      parameter: {
-        typeUrl: contractTypeUrl(contract.type),
-        value: bytes
-      }
-    }]
-  }));
-};

package/libESM/api/tron/tronProtobuf.d.mts

@@ -1,5 +0,0 @@
-export declare const encodeBroadcastTransaction: (rawDataHex: string, signatureHex: string) => string;
-export declare const decodeBroadcastTransaction: (hex: string) => {
-    rawData: Uint8Array<ArrayBufferLike>;
-    signature: Uint8Array<ArrayBufferLike>[];
-};

package/libESM/api/unlockPath.d.mts

@@ -1,12 +0,0 @@
-import { type MethodPermission } from '@trezor/connect-common';
-import type { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class UnlockPath extends AbstractMethod<'unlockPath', PROTO.UnlockPath> {
-    constructor(message: MethodMessage<'unlockPath'>);
-    get requiredPermissions(): MethodPermission[];
-    run(): Promise<{
-        address_n: number[];
-        mac: string;
-    }>;
-}

package/libESM/api/unlockPath.mjs

@@ -1,31 +0,0 @@
-import { UnlockPathParams } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { validatePath } from "../utils/pathUtils.mjs";
-export default class UnlockPath extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(UnlockPathParams, payload);
-    const path = validatePath(payload.path, 1);
-    const params = {
-      address_n: path,
-      mac: payload.mac
-    };
-    super(message, params);
-  }
-  get requiredPermissions() {
-    return ['read'];
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const {
-      message
-    } = await cmd.unlockPath(this.params);
-    return {
-      address_n: this.params.address_n,
-      mac: message.mac
-    };
-  }
-}

package/libESM/api/verifyMessage.d.mts

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

package/libESM/api/verifyMessage.mjs

@@ -1,46 +0,0 @@
-import { VerifyMessage as VerifyMessageSchema } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-import { getBitcoinNetwork } from "../data/coinInfo.mjs";
-import { validateModelOneMessageSize } from "../device/validateMessageSize.mjs";
-import { messageToHex } from "../utils/formatUtils.mjs";
-import { getLabel } from "../utils/pathUtils.mjs";
-export default class VerifyMessage extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(VerifyMessageSchema, payload);
-    const coinInfo = getBitcoinNetwork(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    const messageHex = payload.hex ? messageToHex(payload.message) : Buffer.from(payload.message, 'utf8').toString('hex');
-    const signatureHex = Buffer.from(payload.signature, 'base64').toString('hex');
-    const proto = {
-      address: payload.address,
-      signature: signatureHex,
-      message: messageHex,
-      coin_name: coinInfo.name
-    };
-    const params = {
-      proto,
-      coinInfo
-    };
-    super(message, params);
-    this.requiredFirmwareCoins = [coinInfo];
-  }
-  get requiredPermissions() {
-    return ['read', 'write'];
-  }
-  get info() {
-    return getLabel('Verify #NETWORK message', this.params.coinInfo);
-  }
-  async run() {
-    validateModelOneMessageSize(this.getDevice(), this.params.proto.message);
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('VerifyMessage', 'Success', this.params.proto);
-    return response.message;
-  }
-}

package/libESM/api/wipeDevice.d.mts

@@ -1,21 +0,0 @@
-import { type MethodPermission } from '@trezor/connect-common';
-import type { MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-import type { Device } from '../device/Device';
-export default class WipeDevice extends AbstractMethod<'wipeDevice'> {
-    constructor(message: MethodMessage<'wipeDevice'>);
-    get requiredPermissions(): MethodPermission[];
-    get confirmation(): {
-        view: "device-management";
-        customConfirmButton: {
-            className: string;
-            label: string;
-        };
-        label: string;
-    };
-    get info(): string;
-    setDevice(device: Device): void;
-    run(): Promise<{
-        message: string;
-    }>;
-}

package/libESM/api/wipeDevice.mjs

@@ -1,47 +0,0 @@
-import { DEVICE, UI_REQUEST } from "@trezor/connect-common";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-export default class WipeDevice extends AbstractMethod {
-  constructor(message) {
-    super(message, undefined);
-    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS, UI_REQUEST.BOOTLOADER];
-    this.useDeviceState = false;
-    this.skipFinalReload = false;
-  }
-  get requiredPermissions() {
-    return ['management'];
-  }
-  get confirmation() {
-    return {
-      view: 'device-management',
-      customConfirmButton: {
-        className: 'wipe',
-        label: `Wipe`
-      },
-      label: 'Are you sure you want to wipe your device?'
-    };
-  }
-  get info() {
-    return 'Wipe device';
-  }
-  setDevice(device) {
-    super.setDevice(device);
-    this.skipFinalReload = device.features?.bootloader_mode || !!device.getThpState();
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    if (this.getDevice().isBootloader()) {
-      this.getDevice().emit(DEVICE.BUTTON, {
-        device: this.getDevice(),
-        payload: {
-          code: 'ButtonRequest_WipeDevice'
-        }
-      });
-    }
-    const response = await cmd.typedCall('WipeDevice', 'Success');
-    const thpState = this.getDevice().getThpState();
-    if (thpState) {
-      thpState.resetState();
-    }
-    return response.message;
-  }
-}

package/libESM/backend/BackendManager.d.mts

@@ -1,24 +0,0 @@
-import type { BlockchainLink, CoinInfo } from '@trezor/connect-common';
-import type { BlockchainOptions } from './Blockchain';
-import { Blockchain } from './Blockchain';
-type CoinShortcut = CoinInfo['shortcut'];
-type BackendParams = Pick<BlockchainOptions, 'coinInfo' | 'postMessage' | 'identity'>;
-export declare class BackendManager {
-    private readonly instances;
-    private readonly reconnect;
-    private readonly custom;
-    private readonly preferred;
-    get(shortcut: CoinShortcut, identity?: string): Blockchain | null;
-    getOrConnect({ coinInfo, postMessage, identity }: BackendParams): Promise<Blockchain>;
-    dispose(): void;
-    reconnectAll(coin?: CoinInfo): Promise<Blockchain[]>;
-    isSupported(coinInfo: CoinInfo): void;
-    setCustom(shortcut: CoinShortcut, blockchainLink?: BlockchainLink): void;
-    private setInstance;
-    private setPreferred;
-    private onDisconnect;
-    private clearReconnect;
-    private patchCoinInfo;
-    private getReconnectFilter;
-}
-export {};

package/libESM/backend/BackendManager.mjs

@@ -1,137 +0,0 @@
-import { BLOCKCHAIN, createBlockchainMessage } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { Blockchain } from "./Blockchain.mjs";
-import * as settingsStore from "../data/settingsStore.mjs";
-const DEFAULT_IDENTITY = 'default';
-export class BackendManager {
-  instances = {};
-  reconnect = {};
-  custom = {};
-  preferred = {};
-  get(shortcut, identity = DEFAULT_IDENTITY) {
-    return this.instances[`${shortcut}/${identity}`] ?? null;
-  }
-  async getOrConnect({
-    coinInfo,
-    postMessage,
-    identity
-  }) {
-    const coinIdentity = `${coinInfo.shortcut}/${identity ?? DEFAULT_IDENTITY}`;
-    let backend = this.instances[coinIdentity];
-    if (!backend) {
-      backend = new Blockchain({
-        coinInfo: this.patchCoinInfo(coinInfo),
-        identity,
-        debug: settingsStore.get('debug'),
-        proxy: settingsStore.get('proxy'),
-        postMessage,
-        onDisconnected: pendingSubscriptions => {
-          const reconnectAttempts = pendingSubscriptions ? 0 : undefined;
-          this.onDisconnect({
-            coinInfo,
-            postMessage,
-            identity
-          }, reconnectAttempts);
-        }
-      });
-      this.setInstance(coinIdentity, backend);
-    }
-    const reconnect = this.clearReconnect(coinIdentity);
-    try {
-      const info = await backend.init();
-      this.setPreferred(coinInfo.shortcut, info.url);
-      return backend;
-    } catch (error) {
-      this.onDisconnect({
-        coinInfo,
-        postMessage,
-        identity
-      }, reconnect?.attempts);
-      throw error;
-    }
-  }
-  dispose() {
-    Object.keys(this.reconnect).filter(this.getReconnectFilter()).forEach(this.clearReconnect, this);
-    Object.values(this.instances).forEach(i => i.disconnect());
-  }
-  reconnectAll(coin) {
-    const backends = Object.values(this.instances).filter(backend => !coin || coin.shortcut === backend.coinInfo.shortcut);
-    backends.forEach(i => i.disconnect());
-    return Promise.all(backends.map(this.getOrConnect, this));
-  }
-  isSupported(coinInfo) {
-    const info = this.custom[coinInfo.shortcut] || coinInfo.blockchainLink;
-    if (!info) {
-      throw ERRORS.TypedError('Backend_NotSupported');
-    }
-  }
-  setCustom(shortcut, blockchainLink) {
-    this.setPreferred(shortcut, undefined);
-    if (blockchainLink) {
-      this.custom[shortcut] = blockchainLink;
-    } else {
-      delete this.custom[shortcut];
-    }
-  }
-  setInstance(coinIdentity, instance) {
-    if (!instance) delete this.instances[coinIdentity];else this.instances[coinIdentity] = instance;
-  }
-  setPreferred(shortcut, url) {
-    if (!url) delete this.preferred[shortcut];else this.preferred[shortcut] = url;
-  }
-  onDisconnect({
-    coinInfo,
-    postMessage,
-    identity
-  }, reconnectAttempt) {
-    const coinIdentity = `${coinInfo.shortcut}/${identity ?? DEFAULT_IDENTITY}`;
-    this.setInstance(coinIdentity, undefined);
-    if (reconnectAttempt === undefined || reconnectAttempt === 4) {
-      this.setPreferred(coinInfo.shortcut, undefined);
-    }
-    if (reconnectAttempt === undefined) {
-      return;
-    }
-    const timeout = Math.min(2500 * reconnectAttempt, 20000);
-    const time = Date.now() + timeout;
-    const handle = setTimeout(() => {
-      this.getOrConnect({
-        coinInfo,
-        postMessage,
-        identity
-      }).catch(() => {});
-    }, timeout);
-    clearTimeout(this.reconnect[coinIdentity]?.handle);
-    this.reconnect[coinIdentity] = {
-      attempts: reconnectAttempt + 1,
-      handle
-    };
-    postMessage(createBlockchainMessage(BLOCKCHAIN.RECONNECTING, {
-      coin: coinInfo,
-      identity,
-      time
-    }));
-  }
-  clearReconnect(coinIdentity) {
-    const reconnect = this.reconnect[coinIdentity];
-    clearTimeout(reconnect?.handle);
-    delete this.reconnect[coinIdentity];
-    return reconnect;
-  }
-  patchCoinInfo(coinInfo) {
-    const custom = this.custom[coinInfo.shortcut];
-    const preferred = this.preferred[coinInfo.shortcut];
-    const url = preferred ? [preferred] : custom?.url ?? coinInfo.blockchainLink?.url;
-    return {
-      ...coinInfo,
-      blockchainLink: {
-        ...coinInfo.blockchainLink,
-        ...custom,
-        url
-      }
-    };
-  }
-  getReconnectFilter(coinInfo) {
-    return key => !coinInfo || key.startsWith(`${coinInfo.shortcut}/`);
-  }
-}

package/libESM/backend/Blockchain.d.mts

@@ -1,81 +0,0 @@
-import type { BlockchainLinkParams, ServerInfo, SubscriptionAccountInfo } from '@trezor/blockchain-link';
-import { BlockchainLink } from '@trezor/blockchain-link';
-import type { CoinInfo, CoreEventMessage, Proxy, PushTransaction } from '@trezor/connect-common';
-export type BlockchainOptions = {
-    coinInfo: CoinInfo;
-    postMessage: (message: CoreEventMessage) => void;
-    proxy?: Proxy;
-    debug?: boolean;
-    identity?: string;
-    onDisconnected?: (pendingSubscriptions?: boolean) => void;
-};
-export declare class Blockchain {
-    readonly link: BlockchainLink;
-    serverInfo?: ServerInfo;
-    readonly identity?: string;
-    readonly coinInfo: BlockchainOptions['coinInfo'];
-    readonly postMessage: BlockchainOptions['postMessage'];
-    private onDisconnected;
-    private initPromise?;
-    constructor(options: BlockchainOptions);
-    private onBackendDisconnected;
-    private initLink;
-    init(): Promise<ServerInfo>;
-    getTransactions(txs: string[]): Promise<import("@trezor/blockchain-link-types").Transaction[]>;
-    getTransactionHexes(txids: string[]): Promise<string[]>;
-    getCurrentFiatRates(params: {
-        currencies?: string[];
-        token?: string;
-    }): Promise<{
-        ts: number;
-        rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
-    }>;
-    getContractInfo(params: BlockchainLinkParams<'getContractInfo'>): Promise<import("@trezor/blockchain-link-types/libESM/blockbook-api").ContractInfoResult>;
-    getFiatRatesForTimestamps(params: {
-        currencies?: string[];
-        timestamps: number[];
-        token?: string;
-    }): Promise<{
-        tickers: {
-            ts: number;
-            rates: import("@trezor/blockchain-link-types").FiatRatesBySymbol;
-        }[];
-    }>;
-    getAccountBalanceHistory(params: BlockchainLinkParams<'getAccountBalanceHistory'>): Promise<import("@trezor/blockchain-link-types").AccountBalanceHistory[]>;
-    getNetworkInfo(): Promise<ServerInfo>;
-    getAccountInfo(request: BlockchainLinkParams<'getAccountInfo'>): Promise<import("@trezor/blockchain-link-types").AccountInfo>;
-    getAccountUtxo(descriptor: string): Promise<import("@trezor/blockchain-link-types").Utxo[]>;
-    rpcCall(params: BlockchainLinkParams<'rpcCall'>): Promise<{
-        data: string;
-    }>;
-    estimateFee(request: Parameters<typeof this.link.estimateFee>[0]): Promise<{
-        feePerUnit: string;
-        feePerTx?: string;
-        feePayer?: string;
-        feeLimit?: string;
-        eip1559?: import("@trezor/blockchain-link-types").Eip1559Fees;
-    }[]>;
-    subscribeBlocks(): Promise<{
-        subscribed: boolean;
-    }>;
-    subscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
-        subscribed: boolean;
-    }>;
-    subscribeFiatRates(_currency?: string): Promise<{
-        subscribed: boolean;
-    }>;
-    unsubscribeBlocks(): Promise<{
-        subscribed: boolean;
-    }>;
-    unsubscribeAccounts(accounts: SubscriptionAccountInfo[]): Promise<{
-        subscribed: boolean;
-    }>;
-    unsubscribeFiatRates(): Promise<{
-        subscribed: boolean;
-    }>;
-    unsubscribeAll(): Promise<{
-        subscribed: boolean;
-    }>;
-    pushTransaction(tx: PushTransaction['tx']): Promise<string>;
-    disconnect(): void;
-}