@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/tezos/api/tezosGetPublicKey.js

@@ -1,68 +1,84 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const events_1 = require("../../../events");
-const types_1 = require("../../../types");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-class TezosGetPublicKey extends AbstractMethod_1.AbstractMethod {
+import { Bundle, GetPublicKey as GetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { fromHardenedPathPart } from "@trezor/crypto-utils";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { getSerializedPath, validatePath } from "../../../utils/pathUtils.js";
+import { bundlify } from "../../common/paramsValidator.js";
+export default class TezosGetPublicKey extends AbstractMethod {
   hasBundle;
-  init() {
-    this.requiredPermissions = ['read'];
-    this.requiredDeviceCapabilities = ['Capability_Tezos'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Tezos'), this.firmwareRange);
-    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)(types_1.GetPublicKey), payload);
-    this.params = payload.bundle.map(batch => {
-      const path = (0, pathUtils_1.validatePath)(batch.path, 3);
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 3);
       return {
         address_n: path,
-        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false,
         chunkify: typeof batch.chunkify === 'boolean' ? batch.chunkify : false
       };
     });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.requiredDeviceCapabilities = ['Capability_Tezos'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xtz')];
   }
+  get requiredPermissions() {
+    return this.coinPerms('read_xpub', this.requiredFirmwareCoins);
+  }
+  init() {}
   get info() {
     return 'Export Tezos public key';
   }
   get confirmation() {
+    if (this.params.length > 1) {
+      return {
+        view: 'export-address',
+        label: 'Export multiple Tezos public keys'
+      };
+    }
+    const {
+      params
+    } = this;
+    const first = params[0];
+    const addressN = first.address_n;
+    const accountIndex = addressN[2];
     return {
       view: 'export-address',
-      label: this.params.length > 1 ? 'Export multiple Tezos public keys' : `Export Tezos public key for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`
+      label: `Export Tezos public key for account #${fromHardenedPathPart(accountIndex) + 1}`
     };
   }
-  async run() {
+  async run({
+    sendCoreMessage
+  }) {
     const responses = [];
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     for (let i = 0; i < this.params.length; i++) {
-      const batch = this.params[i];
+      const {
+        params
+      } = this;
+      const batch = params[i];
       const {
         message
       } = await cmd.typedCall('TezosGetPublicKey', 'TezosPublicKey', batch);
       responses.push({
         path: batch.address_n,
-        serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
-        publicKey: message.public_key
+        serializedPath: getSerializedPath(batch.address_n),
+        publicKey: message.public_key,
+        displayablePublicKey: message.public_key
       });
       if (this.hasBundle) {
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
           total: this.params.length,
           progress: i,
           response: message
         }));
       }
     }
-    return this.hasBundle ? responses : responses[0];
+    const first = responses[0];
+    return this.hasBundle ? responses : first;
   }
-}
-exports.default = TezosGetPublicKey;
-//# sourceMappingURL=tezosGetPublicKey.js.map
+}

package/lib/api/tezos/api/tezosSignTransaction.d.ts

@@ -1,12 +1,14 @@
-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 TezosSignTransaction extends AbstractMethod<'tezosSignTransaction', PROTO.TezosSignTx> {
-    init(): void;
-    get info(): string;
-    run(): Promise<{
-        signature: string;
-        sig_op_contents: string;
-        operation_hash: string;
-    }>;
-}
-//# sourceMappingURL=tezosSignTransaction.d.ts.map
+  constructor(message: MethodMessage<'tezosSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    signature: string;
+    sig_op_contents: string;
+    operation_hash: string;
+  }>;
+}

package/lib/api/tezos/api/tezosSignTransaction.js

@@ -1,36 +1,30 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const tslib_1 = require("tslib");
-const schema_utils_1 = require("@trezor/schema-utils");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const tezos_1 = require("../../../types/api/tezos");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-const helper = tslib_1.__importStar(require("../tezosSignTx"));
-class TezosSignTransaction extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.requiredDeviceCapabilities = ['Capability_Tezos'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Tezos'), this.firmwareRange);
+import { TezosSignTransaction as TezosSignTransactionSchema } from "@trezor/connect-common";
+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 * as helper from "../tezosSignTx.js";
+export default class TezosSignTransaction extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.AssertWeak)(tezos_1.TezosSignTransaction, payload);
-    const path = (0, pathUtils_1.validatePath)(payload.path, 3);
-    this.params = helper.createTx(path, payload.branch, payload.operation);
+    } = message;
+    Assert(TezosSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 3);
+    const params = helper.createTx(path, payload.branch, payload.operation);
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Tezos'];
+    this.requiredFirmwareCoins = [getMiscNetwork('xtz')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
   }
   get info() {
     return 'Sign Tezos transaction';
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     const response = await cmd.typedCall('TezosSignTx', 'TezosSignedTx', this.params);
     return response.message;
   }
-}
-exports.default = TezosSignTransaction;
-//# sourceMappingURL=tezosSignTransaction.js.map
+}

package/lib/api/tezos/tezosSignTx.d.ts

@@ -1,72 +1,71 @@
-import { PROTO } from '../../constants';
-import { TezosOperation } from '../../types/api/tezos';
+import { TezosOperation } from '@trezor/connect-common';
+import type { PROTO } from '@trezor/connect-common';
 export declare const createTx: (address_n: number[], branch: string, operation: TezosOperation, chunkify?: boolean) => {
-    chunkify?: boolean | undefined;
-    transaction?: {
-        parameters?: number[] | undefined;
-        parameters_manager?: {
-            transfer?: {
-                amount: string | number;
-                destination: {
-                    hash: Uint8Array<ArrayBufferLike>;
-                    tag: number;
-                };
-            } | undefined;
-            set_delegate?: Uint8Array<ArrayBufferLike> | undefined;
-            cancel_delegate?: boolean | undefined;
-        } | undefined;
-        fee: string | number;
+  chunkify?: boolean | undefined;
+  reveal?: {
+    public_key: Uint8Array<ArrayBufferLike>;
+    fee: string | number;
+    gas_limit: number;
+    source: Uint8Array<ArrayBufferLike>;
+    counter: number;
+    storage_limit: number;
+  } | undefined;
+  transaction?: {
+    parameters?: number[] | undefined;
+    parameters_manager?: {
+      transfer?: {
         amount: string | number;
-        gas_limit: number;
         destination: {
-            hash: Uint8Array<ArrayBufferLike>;
-            tag: number;
+          hash: Uint8Array<ArrayBufferLike>;
+          tag: number;
         };
-        source: Uint8Array<ArrayBufferLike>;
-        counter: number;
-        storage_limit: number;
+      } | undefined;
+      set_delegate?: Uint8Array<ArrayBufferLike> | undefined;
+      cancel_delegate?: boolean | undefined;
     } | undefined;
-    proposal?: {
-        source: string;
-        period: number;
-        proposals: string[];
-    } | undefined;
-    ballot?: {
-        source: string;
-        period: number;
-        proposal: string;
-        ballot: PROTO.TezosBallotType;
-    } | undefined;
-    reveal?: {
-        fee: string | number;
-        public_key: Uint8Array<ArrayBufferLike>;
-        gas_limit: number;
-        source: Uint8Array<ArrayBufferLike>;
-        counter: number;
-        storage_limit: number;
-    } | undefined;
-    origination?: {
-        delegate?: Uint8Array<ArrayBufferLike> | undefined;
-        manager_pubkey?: string | undefined;
-        spendable?: boolean | undefined;
-        delegatable?: boolean | undefined;
-        fee: string | number;
-        script: string | number[];
-        gas_limit: number;
-        source: Uint8Array<ArrayBufferLike>;
-        counter: number;
-        storage_limit: number;
-        balance: number;
-    } | undefined;
-    delegation?: {
-        fee: string | number;
-        delegate: Uint8Array<ArrayBufferLike>;
-        gas_limit: number;
-        source: Uint8Array<ArrayBufferLike>;
-        counter: number;
-        storage_limit: number;
-    } | undefined;
-    address_n: number[];
-    branch: Uint8Array<ArrayBufferLike>;
-};
-//# sourceMappingURL=tezosSignTx.d.ts.map
+    amount: string | number;
+    fee: string | number;
+    gas_limit: number;
+    destination: {
+      hash: Uint8Array<ArrayBufferLike>;
+      tag: number;
+    };
+    source: Uint8Array<ArrayBufferLike>;
+    counter: number;
+    storage_limit: number;
+  } | undefined;
+  origination?: {
+    delegate?: Uint8Array<ArrayBufferLike> | undefined;
+    manager_pubkey?: string | undefined;
+    spendable?: boolean | undefined;
+    delegatable?: boolean | undefined;
+    script: string | number[];
+    fee: string | number;
+    gas_limit: number;
+    balance: number;
+    source: Uint8Array<ArrayBufferLike>;
+    counter: number;
+    storage_limit: number;
+  } | undefined;
+  delegation?: {
+    fee: string | number;
+    delegate: Uint8Array<ArrayBufferLike>;
+    gas_limit: number;
+    source: Uint8Array<ArrayBufferLike>;
+    counter: number;
+    storage_limit: number;
+  } | undefined;
+  proposal?: {
+    source: string;
+    period: number;
+    proposals: string[];
+  } | undefined;
+  ballot?: {
+    proposal: string;
+    ballot: PROTO.TezosBallotType;
+    source: string;
+    period: number;
+  } | undefined;
+  address_n: number[];
+  branch: Uint8Array<ArrayBufferLike>;
+};

package/lib/api/tezos/tezosSignTx.js

@@ -1,14 +1,9 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createTx = void 0;
-const tslib_1 = require("tslib");
-const bs58check_1 = tslib_1.__importDefault(require("bs58check"));
-const schema_utils_1 = require("@trezor/schema-utils");
-const constants_1 = require("../../constants");
-const tezos_1 = require("../../types/api/tezos");
+import { sha256 } from "@noble/hashes/sha2.js";
+import { base58check as createBase58check } from "@scure/base";
+import { TezosOperation } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { Assert } from "@trezor/schema-utils";
+const bs58check = createBase58check(sha256);
 const PREFIX = {
   B: new Uint8Array([1, 52]),
   tz1: new Uint8Array([6, 161, 159]),
@@ -19,7 +14,7 @@ const PREFIX = {
   sppk: new Uint8Array([3, 254, 226, 86]),
   p2pk: new Uint8Array([3, 178, 139, 127])
 };
-const bs58checkDecode = (prefix, enc) => bs58check_1.default.decode(enc).slice(prefix.length);
+const bs58checkDecode = (prefix, enc) => bs58check.decode(enc).slice(prefix.length);
 const concatArray = (first, second) => {
   const result = new Uint8Array(first.length + second.length);
   result.set(first);
@@ -49,7 +44,7 @@ const publicKeyHash2buffer = publicKeyHash => {
         hash: concatArray(bs58checkDecode(PREFIX.KT1, publicKeyHash), new Uint8Array([0]))
       };
     default:
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Wrong Tezos publicKeyHash address');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Wrong Tezos publicKeyHash address');
   }
 };
 const publicKey2buffer = publicKey => {
@@ -61,16 +56,16 @@ const publicKey2buffer = publicKey => {
     case 'p2pk':
       return concatArray(new Uint8Array([2]), bs58checkDecode(PREFIX.p2pk, publicKey));
     default:
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Wrong Tezos publicKey');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'Wrong Tezos publicKey');
   }
 };
-const createTx = (address_n, branch, operation, chunkify) => {
+export const createTx = (address_n, branch, operation, chunkify) => {
   let message = {
     address_n,
     branch: bs58checkDecode(PREFIX.B, branch),
     chunkify: typeof chunkify === 'boolean' ? chunkify : false
   };
-  (0, schema_utils_1.Assert)(tezos_1.TezosOperation, operation);
+  Assert(TezosOperation, operation);
   if (operation.reveal) {
     const {
       reveal
@@ -206,6 +201,4 @@ const createTx = (address_n, branch, operation, chunkify) => {
     };
   }
   return message;
-};
-exports.createTx = createTx;
-//# sourceMappingURL=tezosSignTx.js.map
+};

package/lib/api/thpGetCredentials.d.ts

@@ -1,10 +1,13 @@
-import { AbstractMethod } from '../core/AbstractMethod';
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
 export default class ThpGetCredentials extends AbstractMethod<'thpGetCredentials'> {
-    init(): void;
-    run(): Promise<{
-        autoconnect: boolean;
-        trezor_static_public_key: string;
-        credential: string;
-    }>;
-}
-//# sourceMappingURL=thpGetCredentials.d.ts.map
+  constructor(message: MethodMessage<'thpGetCredentials'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    autoconnect: boolean;
+    host_static_key: string;
+    trezor_static_public_key: string;
+    credential: string;
+  }>;
+}

package/lib/api/thpGetCredentials.js

@@ -1,34 +1,30 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const DataManager_1 = require("../data/DataManager");
-const thp_1 = require("../device/thp");
-const events_1 = require("../events");
-class ThpGetCredentials extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
-    this.requiredPermissions = ['management'];
+import { DEVICE, UI_REQUEST } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import * as settingsStore from "../data/settingsStore.js";
+import { getThpCredentials } from "../device/thp/index.js";
+export default class ThpGetCredentials extends AbstractMethod {
+  constructor(message) {
+    super(message, undefined);
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
     this.useDeviceState = false;
-    this.skipFinalReload = true;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
   async run() {
-    const thpState = this.device.getThpState();
+    const thpState = this.getDevice().getThpState();
     if (!thpState?.handshakeCredentials) {
-      throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
+      throw ERRORS.TypedError('Device_ThpStateMissing');
     }
-    const credentials = await (0, thp_1.getThpCredentials)(this.device, true);
+    const credentials = await getThpCredentials(this.getDevice(), true);
     thpState.setPairingCredentials([credentials]);
-    DataManager_1.DataManager.getSettings('thp')?.knownCredentials?.push(credentials);
-    this.device.emit(events_1.DEVICE.THP_CREDENTIALS_CHANGED, {
-      credentials,
-      staticKey: thpState.handshakeCredentials.staticKey.toString('hex')
+    settingsStore.get('thp')?.knownCredentials?.push(credentials);
+    this.getDevice().emit(DEVICE.THP_CREDENTIALS_CHANGED, {
+      credentials
     });
     return credentials;
   }
-}
-exports.default = ThpGetCredentials;
-//# sourceMappingURL=thpGetCredentials.js.map
+}

package/lib/api/thpRemoveCredentials.d.ts

@@ -1,8 +1,15 @@
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class ThpRemoveCredentials extends AbstractMethod<'thpRemoveCredentials'> {
-    init(): void;
-    run(): Promise<{
-        message: string;
-    }>;
+import { type PermissionRequest } from '@trezor/connect-common';
+import type { ThpCredentials } from '@trezor/protocol';
+import type { MethodMessage } from "../core/AbstractMethod.js";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+type Params = {
+  credentials: ThpCredentials[];
+};
+export default class ThpRemoveCredentials extends AbstractMethod<'thpRemoveCredentials', Params> {
+  constructor(message: MethodMessage<'thpRemoveCredentials'>);
+  get requiredPermissions(): PermissionRequest[];
+  run(): Promise<{
+    message: string;
+  }>;
 }
-//# sourceMappingURL=thpRemoveCredentials.d.ts.map
+export {};

package/lib/api/thpRemoveCredentials.js

@@ -1,39 +1,44 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const constants_1 = require("../constants");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const DataManager_1 = require("../data/DataManager");
-const events_1 = require("../events");
-class ThpRemoveCredentials extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.allowDeviceMode = [events_1.UI.INITIALIZE, events_1.UI.SEEDLESS];
-    this.requiredPermissions = ['management'];
+import { UI_REQUEST } from "@trezor/connect-common";
+import { AbstractMethod } from "../core/AbstractMethod.js";
+import * as settingsStore from "../data/settingsStore.js";
+export default class ThpRemoveCredentials extends AbstractMethod {
+  constructor(message) {
+    const params = {
+      credentials: message.payload.credentials || []
+    };
+    super(message, params);
+    this.useDevice = message.payload.device !== undefined;
+    this.allowDeviceMode = [UI_REQUEST.INITIALIZE, UI_REQUEST.SEEDLESS];
     this.useDeviceState = false;
-    this.skipFinalReload = true;
+  }
+  get requiredPermissions() {
+    return [{
+      permission: 'management'
+    }];
   }
   run() {
-    const thpState = this.device.getThpState();
-    if (!thpState) {
-      throw constants_1.ERRORS.TypedError('Device_ThpStateMissing');
-    }
-    const knownCredentials = DataManager_1.DataManager.getSettings('thp')?.knownCredentials;
-    if (knownCredentials) {
-      const toRemoveCredentials = (this.payload.credentials || thpState.pairingCredentials).map(c => c.credential);
-      const index = knownCredentials.findIndex(({
-        credential
-      }) => toRemoveCredentials.includes(credential));
-      if (index >= 0) {
-        knownCredentials.splice(index, 1);
+    const requestedCredentials = this.params.credentials;
+    if (this.useDevice) {
+      const thpState = this.getDevice().getThpState();
+      if (thpState) {
+        requestedCredentials.push(...thpState.pairingCredentials);
+        thpState.resetState();
       }
     }
-    thpState.resetState();
+    const credentialsMap = new Map(requestedCredentials.map(c => [c.credential, c]));
+    const knownCredentials = settingsStore.get('thp')?.knownCredentials;
+    if (knownCredentials && knownCredentials.length > 0) {
+      credentialsMap.forEach(c => {
+        let index;
+        while ((index = knownCredentials.findIndex(({
+          credential
+        }) => c.credential === credential)) >= 0) {
+          knownCredentials.splice(index, 1);
+        }
+      });
+    }
     return Promise.resolve({
       message: 'Success'
     });
   }
-}
-exports.default = ThpRemoveCredentials;
-//# sourceMappingURL=thpRemoveCredentials.js.map
+}

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

@@ -1,3 +1,3 @@
-export { default as tronGetAddress } from './tronGetAddress';
-export { default as tronSignTransaction } from './tronSignTransaction';
-//# sourceMappingURL=index.d.ts.map
+export { default as tronComposeTransaction } from "./tronComposeTransaction.js";
+export { default as tronGetAddress } from "./tronGetAddress.js";
+export { default as tronSignTransaction } from "./tronSignTransaction.js";

package/lib/api/tron/api/index.js

@@ -1,22 +1,3 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.tronSignTransaction = exports.tronGetAddress = void 0;
-const tslib_1 = require("tslib");
-var tronGetAddress_1 = require("./tronGetAddress");
-Object.defineProperty(exports, "tronGetAddress", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(tronGetAddress_1).default;
-  }
-});
-var tronSignTransaction_1 = require("./tronSignTransaction");
-Object.defineProperty(exports, "tronSignTransaction", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(tronSignTransaction_1).default;
-  }
-});
-//# sourceMappingURL=index.js.map
+export { default as tronComposeTransaction } from "./tronComposeTransaction.js";
+export { default as tronGetAddress } from "./tronGetAddress.js";
+export { default as tronSignTransaction } from "./tronSignTransaction.js";

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

@@ -0,0 +1,17 @@
+import { type PermissionRequest } from '@trezor/connect-common';
+import { TronComposeTransaction as TronComposeTransactionSchema } from '@trezor/connect-common';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+export default class TronComposeTransaction extends AbstractMethod<'tronComposeTransaction', TronComposeTransactionSchema> {
+  constructor(message: MethodMessage<'tronComposeTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  run(): Promise<{
+    rawDataHex: string;
+    ref_block_bytes: string;
+    ref_block_hash: string;
+    expiration: number;
+    timestamp: number;
+    bandwidth: number;
+  }>;
+}