@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/tron/api/tronComposeTransaction.js

@@ -0,0 +1,52 @@
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { TronComposeTransaction as TronComposeTransactionSchema } from "@trezor/connect-common";
+import { TRON_BANDWIDTH_FORMULA_OVERHEAD } from "@trezor/network-tron/constants";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { encodeTronContractRawData } from "../tronEncode.js";
+export default class TronComposeTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(TronComposeTransactionSchema, payload);
+    super(message, payload);
+    this.useDevice = false;
+    this.useUi = false;
+  }
+  get requiredPermissions() {
+    return [];
+  }
+  get info() {
+    return 'Compose Tron transaction';
+  }
+  async run() {
+    const {
+      contract,
+      blockHash,
+      blockHeight,
+      fee_limit,
+      data
+    } = this.params;
+    const ref_block_bytes = blockHeight.toString(16).padStart(16, '0').slice(12, 16);
+    const ref_block_hash = blockHash.replace(/^0x/, '').slice(16, 32);
+    const timestamp = Date.now();
+    const expiration = timestamp + 60 * 60 * 1000;
+    const rawData = encodeTronContractRawData(contract, {
+      ref_block_bytes,
+      ref_block_hash,
+      expiration,
+      timestamp,
+      fee_limit,
+      data
+    });
+    return {
+      rawDataHex: bytesToHex(rawData),
+      ref_block_bytes,
+      ref_block_hash,
+      expiration,
+      timestamp,
+      bandwidth: rawData.length + TRON_BANDWIDTH_FORMULA_OVERHEAD
+    };
+  }
+}

package/lib/api/tron/api/tronGetAddress.d.ts

@@ -1,27 +1,17 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-type Params = PROTO.TronGetAddress & {
-    address?: string;
-};
-export default class TronGetAddress extends AbstractMethod<'tronGetAddress', Params[]> {
-    hasBundle?: boolean;
-    progress: number;
-    init(): void;
-    get info(): "Export Tron address" | "Export multiple Tron addresses";
-    getButtonRequestData(code: string): {
-        type: "address";
-        serializedPath: string;
-        address: string;
-    } | undefined;
-    get confirmation(): {
-        view: "export-address";
-        label: string;
-    };
-    _call({ address_n, show_display, chunkify }: Params): Promise<{
-        mac?: string | undefined;
-        address: string;
-    }>;
-    run(): Promise<import("../../../types").Address | import("../../../types").Address[]>;
-}
-export {};
-//# sourceMappingURL=tronGetAddress.d.ts.map
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
+import type { MiscGetAddressParams } from "../../common/AbstractMiscGetAddress.js";
+export default class TronGetAddress extends AbstractMiscGetAddress<'tronGetAddress'> {
+  constructor(message: MethodMessage<'tronGetAddress'>);
+  get info(): string;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  _call({
+    proto
+  }: MiscGetAddressParams): Promise<{
+    mac?: string | undefined;
+    address: string;
+  }>;
+}

package/lib/api/tron/api/tronGetAddress.js

@@ -1,108 +1,22 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../../constants");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const events_1 = require("../../../events");
-const types_1 = require("../../../types");
-const getAddress_1 = require("../../../types/api/getAddress");
-const pathUtils_1 = require("../../../utils/pathUtils");
-class TronGetAddress extends AbstractMethod_1.AbstractMethod {
-  hasBundle;
-  progress = 0;
-  init() {
-    this.noBackupConfirmationMode = 'always';
-    this.requiredPermissions = ['read'];
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
+export default class TronGetAddress extends AbstractMiscGetAddress {
+  constructor(message) {
+    super(message, 2);
     this.requiredDeviceCapabilities = ['Capability_Tron'];
-    this.hasBundle = !!this.payload.bundle;
-    const payload = !this.payload.bundle ? {
-      ...this.payload,
-      bundle: [this.payload]
-    } : this.payload;
-    (0, schema_utils_1.Assert)((0, types_1.Bundle)(getAddress_1.GetAddress), payload);
-    this.params = payload.bundle.map(batch => {
-      const path = (0, pathUtils_1.validatePath)(batch.path, 2);
-      return {
-        address_n: path,
-        address: batch.address,
-        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
-        chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
-      };
-    });
-    const useEventListener = payload.useEventListener && this.params.length === 1 && typeof this.params[0].address === 'string' && this.params[0].show_display;
-    this.useUi = !useEventListener;
+    this.requiredFirmwareCoins = [getMiscNetwork('trx')];
   }
   get info() {
-    if (this.params.length === 1) {
-      return 'Export Tron address';
-    }
-    return 'Export multiple Tron addresses';
-  }
-  getButtonRequestData(code) {
-    if (code === 'ButtonRequest_Address') {
-      return {
-        type: 'address',
-        serializedPath: (0, pathUtils_1.getSerializedPath)(this.params[this.progress].address_n),
-        address: this.params[this.progress].address || 'not-set'
-      };
-    }
+    return this.getInfo('Tron', false);
   }
   get confirmation() {
-    return {
-      view: 'export-address',
-      label: this.params.length > 1 ? 'Export multiple Tron addresses' : `Export Tron address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`
-    };
+    return this.getConfirmation('Tron');
   }
   async _call({
-    address_n,
-    show_display,
-    chunkify
+    proto
   }) {
-    const cmd = this.device.getCommands();
-    const response = await cmd.typedCall('TronGetAddress', 'TronAddress', {
-      address_n,
-      show_display,
-      chunkify
-    });
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('TronGetAddress', 'TronAddress', proto);
     return response.message;
   }
-  async run() {
-    const responses = [];
-    for (let i = 0; i < this.params.length; i++) {
-      const batch = this.params[i];
-      if (batch.show_display) {
-        const silent = await this._call({
-          ...batch,
-          show_display: false
-        });
-        if (typeof batch.address === 'string') {
-          if (batch.address !== silent.address) {
-            throw constants_1.ERRORS.TypedError('Method_AddressNotMatch');
-          }
-        } else {
-          batch.address = silent.address;
-        }
-      }
-      const message = await this._call(batch);
-      responses.push({
-        path: batch.address_n,
-        serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
-        address: message.address
-      });
-      if (this.hasBundle) {
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
-          total: this.params.length,
-          progress: i,
-          response: message
-        }));
-      }
-      this.progress++;
-    }
-    return this.hasBundle ? responses : responses[0];
-  }
-}
-exports.default = TronGetAddress;
-//# sourceMappingURL=tronGetAddress.js.map
+}

package/lib/api/tron/api/tronSignTransaction.d.ts

@@ -1,19 +1,20 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import { TronContractsParameters, TronContractsTypes } from '../../../types/api/tron';
+import type { PROTO, PermissionRequest, TronContracts } from '@trezor/connect-common';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
 type Params = {
-    tx: PROTO.TronSignTx;
-    contractType: TronContractsTypes;
-    contract: TronContractsParameters;
+  tx: PROTO.TronSignTx;
+  contract: TronContracts;
 };
 export default class TronSignTransaction extends AbstractMethod<'tronSignTransaction', Params> {
-    hasBundle?: boolean;
-    progress: number;
-    init(): void;
-    get info(): string;
-    run(): Promise<{
-        signature: string;
-    }>;
+  hasBundle?: boolean;
+  progress: number;
+  constructor(message: MethodMessage<'tronSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    signature: string;
+    serializedTx: string | undefined;
+    rawDataHex: string | undefined;
+  }>;
 }
-export {};
-//# sourceMappingURL=tronSignTransaction.d.ts.map
+export {};

package/lib/api/tron/api/tronSignTransaction.js

@@ -1,37 +1,97 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../../constants");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const tron_1 = require("../../../types/api/tron");
-const pathUtils_1 = require("../../../utils/pathUtils");
+import { bytesToHex } from "@noble/hashes/utils.js";
+import { TronSignTransaction as TronSignTransactionSchema } 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 { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+import { encodeTronContractRawData } from "../tronEncode.js";
+import { encodeBroadcastTransaction } from "../tronProtobuf.js";
+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':
+    case 'WithdrawBalanceContract':
+      return input;
+  }
+};
 const contractMapping = {
   TransferContract: 'TronTransferContract',
   TriggerSmartContract: 'TronTriggerSmartContract',
   FreezeBalanceV2Contract: 'TronFreezeBalanceV2Contract',
   UnfreezeBalanceV2Contract: 'TronUnfreezeBalanceV2Contract',
   WithdrawExpireUnfreezeContract: 'TronWithdrawUnfreeze',
+  WithdrawBalanceContract: 'TronWithdrawBalance',
   VoteWitnessContract: 'TronVoteWitnessContract'
 };
-class TronSignTransaction extends AbstractMethod_1.AbstractMethod {
+export default class TronSignTransaction extends AbstractMethod {
   hasBundle;
   progress = 0;
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.requiredDeviceCapabilities = ['Capability_Tron'];
+  constructor(message) {
     const {
       payload
-    } = this;
+    } = message;
     const contractType = payload.contract?.[0]?.type;
     if (!contractType || !(contractType in contractMapping)) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', `Unsupported Tron contract type: ${contractType ?? 'undefined'}`);
+      throw ERRORS.TypedError('Method_InvalidParameter', `Unsupported Tron contract type: ${contractType ?? 'undefined'}`);
     }
-    (0, schema_utils_1.Assert)(tron_1.TronSignTransaction, payload);
-    const path = (0, pathUtils_1.validatePath)(payload.path, 3);
-    this.params = {
+    Assert(TronSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 3);
+    const payloadContracts = payload.contract;
+    const firstContract = payloadContracts[0];
+    const contract = transformContract(firstContract);
+    const params = {
       tx: {
         address_n: path,
         ref_block_bytes: payload.ref_block_bytes,
@@ -41,23 +101,37 @@ class TronSignTransaction extends AbstractMethod_1.AbstractMethod {
         fee_limit: payload.fee_limit,
         data: payload.data
       },
-      contractType: payload.contract[0].type,
-      contract: payload.contract[0].parameter.value
+      contract
     };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Tron'];
+    this.requiredFirmwareCoins = [getMiscNetwork('trx')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
   }
   get info() {
     return 'Sign Tron transaction';
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     await cmd.typedCall('TronSignTx', 'TronContractRequest', this.params.tx);
     const {
       message
-    } = await cmd.typedCall(contractMapping[this.params.contractType], 'TronSignature', this.params.contract);
+    } = await cmd.typedCall(contractMapping[this.params.contract.type], 'TronSignature', this.params.contract.parameter.value);
+    const {
+      signature
+    } = message;
+    let serializedTx;
+    let rawDataHex;
+    try {
+      rawDataHex = bytesToHex(encodeTronContractRawData(this.params.contract, this.params.tx));
+      serializedTx = encodeBroadcastTransaction(rawDataHex, signature);
+    } catch {}
     return {
-      signature: message.signature
+      signature,
+      serializedTx,
+      rawDataHex
     };
   }
-}
-exports.default = TronSignTransaction;
-//# sourceMappingURL=tronSignTransaction.js.map
+}

package/lib/api/tron/tronEncode.d.ts

@@ -0,0 +1,11 @@
+import type { TronContracts } from '@trezor/connect-common';
+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/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/tron/tronProtobuf.js

@@ -0,0 +1,28 @@
+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,10 +1,12 @@
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import { AbstractMethod } from '../core/AbstractMethod';
+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> {
-    init(): void;
-    run(): Promise<{
-        address_n: number[];
-        mac: string;
-    }>;
-}
-//# sourceMappingURL=unlockPath.d.ts.map
+  constructor(message: MethodMessage<'unlockPath'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    address_n: number[];
+    mac: string;
+  }>;
+}