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

package/lib/api/tron/tronEncode.js

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

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

package/lib/api/unlockPath.d.ts

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

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

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

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

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

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

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

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

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