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

package/lib/api/tron/tronEncode.js

@@ -1,157 +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/lib/definitions/messages-tron.js";
-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 ?? '')
-          }))
-        };
-      }
-    case 'FreezeBalanceV2Contract':
-      {
-        const {
-          owner_address,
-          balance,
-          resource
-        } = contract.parameter.value;
-        const schema = getSchema('TronFreezeBalanceV2Contract');
-        return {
-          type: TronRawContractType.FreezeBalanceV2Contract,
-          bytes: toBinary(schema, create(schema, {
-            ownerAddress: hexToBytes(owner_address ?? ''),
-            balance: BigInt(balance ?? 0),
-            resource: resource || undefined
-          }))
-        };
-      }
-    case 'UnfreezeBalanceV2Contract':
-      {
-        const {
-          owner_address,
-          balance,
-          resource
-        } = contract.parameter.value;
-        const schema = getSchema('TronUnfreezeBalanceV2Contract');
-        return {
-          type: TronRawContractType.UnfreezeBalanceV2Contract,
-          bytes: toBinary(schema, create(schema, {
-            ownerAddress: hexToBytes(owner_address ?? ''),
-            balance: BigInt(balance ?? 0),
-            resource: resource || undefined
-          }))
-        };
-      }
-    case 'WithdrawExpireUnfreezeContract':
-      {
-        const {
-          owner_address
-        } = contract.parameter.value;
-        const schema = getSchema('TronWithdrawUnfreeze');
-        return {
-          type: TronRawContractType.WithdrawExpireUnfreezeContract,
-          bytes: toBinary(schema, create(schema, {
-            ownerAddress: hexToBytes(owner_address ?? '')
-          }))
-        };
-      }
-    case 'WithdrawBalanceContract':
-      {
-        const {
-          owner_address
-        } = contract.parameter.value;
-        const schema = getSchema('TronWithdrawBalance');
-        return {
-          type: TronRawContractType.WithdrawBalanceContract,
-          bytes: toBinary(schema, create(schema, {
-            ownerAddress: hexToBytes(owner_address ?? '')
-          }))
-        };
-      }
-    case 'VoteWitnessContract':
-      {
-        const {
-          owner_address,
-          votes
-        } = contract.parameter.value;
-        const schema = getSchema('TronVoteWitnessContract');
-        return {
-          type: TronRawContractType.VoteWitnessContract,
-          bytes: toBinary(schema, create(schema, {
-            ownerAddress: hexToBytes(owner_address ?? ''),
-            votes: (votes ?? []).map(({
-              address,
-              count
-            }) => ({
-              address: hexToBytes(address ?? ''),
-              count: BigInt(count ?? 0)
-            }))
-          }))
-        };
-      }
-    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/lib/api/tron/tronProtobuf.d.ts

@@ -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/lib/api/tron/tronProtobuf.js

@@ -1,28 +0,0 @@
-import { BinaryReader, BinaryWriter, WireType } from "@bufbuild/protobuf/wire";
-import { bytesToHex, hexToBytes } from "@noble/hashes/utils.js";
-export const encodeBroadcastTransaction = (rawDataHex, signatureHex) => {
-  const writer = new BinaryWriter();
-  writer.tag(1, WireType.LengthDelimited).bytes(hexToBytes(rawDataHex));
-  writer.tag(2, WireType.LengthDelimited).bytes(hexToBytes(signatureHex));
-  return bytesToHex(writer.finish());
-};
-export const decodeBroadcastTransaction = hex => {
-  const reader = new BinaryReader(hexToBytes(hex));
-  let rawData;
-  const signature = [];
-  while (reader.pos < reader.len) {
-    const [fieldNo] = reader.tag();
-    if (fieldNo === 1) {
-      rawData = reader.bytes();
-    } else if (fieldNo === 2) {
-      signature.push(reader.bytes());
-    } else {
-      throw new Error(`Unexpected field ${fieldNo} in broadcast transaction`);
-    }
-  }
-  if (!rawData) throw new Error('Missing rawData in broadcast transaction');
-  return {
-    rawData,
-    signature
-  };
-};

package/lib/api/unlockPath.d.ts

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

package/lib/api/unlockPath.js

@@ -1,33 +0,0 @@
-import { UnlockPathParams } from "@trezor/connect-common";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { validatePath } from "../utils/pathUtils.js";
-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 [{
-      permission: 'read_xpub'
-    }];
-  }
-  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/lib/api/verifyMessage.d.ts

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

package/lib/api/verifyMessage.js

@@ -1,46 +0,0 @@
-import { VerifyMessage as VerifyMessageSchema } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { getBitcoinNetwork } from "../data/coinInfo.js";
-import { validateModelOneMessageSize } from "../device/validateMessageSize.js";
-import { messageToHex } from "../utils/formatUtils.js";
-import { getLabel } from "../utils/pathUtils.js";
-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 [this.coinPerm('verify_message', this.params.coinInfo)];
-  }
-  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/lib/api/wipeDevice.d.ts

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

package/lib/api/wipeDevice.js

@@ -1,49 +0,0 @@
-import { DEVICE, UI_REQUEST } from "@trezor/connect-common";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-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 [{
-      permission: '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/lib/backend/BackendManager.d.ts

@@ -1,30 +0,0 @@
-import type { BlockchainLink, CoinInfo, Proxy } from '@trezor/connect-common';
-import type { BlockchainOptions } from "./Blockchain.js";
-import { Blockchain } from "./Blockchain.js";
-type CoinShortcut = CoinInfo['shortcut'];
-type BackendParams = Pick<BlockchainOptions, 'coinInfo' | 'postMessage' | 'identity'>;
-export declare class BackendManager {
-  private proxy?;
-  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): boolean;
-  setCustom(shortcut: CoinShortcut, blockchainLink?: BlockchainLink): void;
-  updateProxy(proxy: Proxy | undefined): Promise<void>;
-  private setInstance;
-  private setPreferred;
-  private onDisconnect;
-  private clearReconnect;
-  private patchCoinInfo;
-  private getReconnectFilter;
-}
-export {};

package/lib/backend/BackendManager.js

@@ -1,145 +0,0 @@
-import { BLOCKCHAIN, createBlockchainMessage } from "@trezor/connect-common";
-import { deepEqual } from "@trezor/utils";
-import { Blockchain } from "./Blockchain.js";
-import * as settingsStore from "../data/settingsStore.js";
-const DEFAULT_IDENTITY = 'default';
-export class BackendManager {
-  proxy;
-  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: this.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;
-    return !!info;
-  }
-  setCustom(shortcut, blockchainLink) {
-    this.setPreferred(shortcut, undefined);
-    if (blockchainLink) {
-      this.custom[shortcut] = blockchainLink;
-    } else {
-      delete this.custom[shortcut];
-    }
-  }
-  async updateProxy(proxy) {
-    if (proxy !== undefined && !deepEqual(this.proxy, proxy)) {
-      this.proxy = proxy;
-      await this.reconnectAll();
-    }
-  }
-  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 thisCustom = this.custom;
-    const custom = thisCustom[coinInfo.shortcut];
-    const thisPreferred = this.preferred;
-    const preferred = thisPreferred[coinInfo.shortcut];
-    const url = preferred ? [preferred] : custom?.url ?? coinInfo.blockchainLink?.url ?? [];
-    const patchedBlockchainLink = {
-      ...coinInfo.blockchainLink,
-      ...custom,
-      url
-    };
-    return {
-      ...coinInfo,
-      blockchainLink: patchedBlockchainLink
-    };
-  }
-  getReconnectFilter(coinInfo) {
-    return key => !coinInfo || key.startsWith(`${coinInfo.shortcut}/`);
-  }
-}

package/lib/backend/Blockchain.d.ts

@@ -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[], descriptor?: 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/lib/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;
-}