@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/solana/api/solanaSignTransaction.js

@@ -1,152 +1,153 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const kit_1 = require("@solana/kit");
-const compute_budget_1 = require("@solana-program/compute-budget");
-const system_1 = require("@solana-program/system");
-const token_1 = require("@solana-program/token");
-const schema_utils_1 = require("@trezor/schema-utils");
-const utils_1 = require("@trezor/utils");
-const constants_1 = require("../../../constants");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const solana_1 = require("../../../types/api/solana");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-const additionalInfo_1 = require("../additionalInfo");
-const solanaDefinitions_1 = require("../solanaDefinitions");
-const solanaUtils_1 = require("../solanaUtils");
-class SolanaSignTransaction extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read', 'write'];
-    this.requiredDeviceCapabilities = ['Capability_Solana'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Solana'), this.firmwareRange);
+import { SolanaSignTransaction as SolanaSignTransactionSchema, SolanaTxAdditionalInfo } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
+import solana from "@trezor/network-solana/runtime";
+import { Assert } from "@trezor/schema-utils";
+import { BigNumber } from "@trezor/utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
+import { getMiscNetwork } from "../../../data/coinInfo.js";
+import { validatePath } from "../../../utils/pathUtils.js";
+import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.js";
+import { getSolanaTokenDefinition } from "../solanaDefinitions.js";
+export default class SolanaSignTransaction extends AbstractMethod {
+  constructor(message) {
     const {
       payload
-    } = this;
-    (0, schema_utils_1.AssertWeak)(solana_1.SolanaSignTransaction, payload);
-    const path = (0, pathUtils_1.validatePath)(payload.path, 2);
-    this.params = {
+    } = message;
+    Assert(SolanaSignTransactionSchema, payload);
+    const path = validatePath(payload.path, 2);
+    let additional_info;
+    let symbols;
+    if (payload.additionalInfo) {
+      Assert(SolanaTxAdditionalInfo, payload.additionalInfo);
+      const token_accounts_infos = payload.additionalInfo.tokenAccountsInfos?.map(tokenAccountInfo => ({
+        base_address: tokenAccountInfo.baseAddress,
+        token_program: tokenAccountInfo.tokenProgram,
+        token_mint: tokenAccountInfo.tokenMint,
+        token_account: tokenAccountInfo.tokenAccount
+      })) ?? [];
+      symbols = payload.additionalInfo.tokenAccountsInfos?.map(tokenAccountInfo => tokenAccountInfo.symbol) ?? [];
+      additional_info = {
+        token_accounts_infos
+      };
+    }
+    const proto = {
       address_n: path,
       serialized_tx: payload.serializedTx,
-      additional_info: (0, additionalInfo_1.transformAdditionalInfo)(payload.additionalInfo),
-      serialize: !!payload.serialize
+      additional_info,
+      payment_req: payload.payment_req ? encodePaymentRequestAmount(payload.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined,
+      chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false
     };
+    const params = {
+      proto,
+      serialize: !!payload.serialize,
+      symbols
+    };
+    super(message, params);
+    this.requiredDeviceCapabilities = ['Capability_Solana'];
+    this.requiredFirmwareCoins = [getMiscNetwork('sol')];
+  }
+  get requiredPermissions() {
+    return this.coinPerms('sign', this.requiredFirmwareCoins);
   }
   async initAsync() {
-    const token = this.params.additional_info?.token_accounts_infos?.[0];
+    const token = this.params.proto.additional_info?.token_accounts_infos?.[0];
     if (token) {
-      const tokenDefinition = await (0, solanaDefinitions_1.getSolanaTokenDefinition)({
+      const tokenDefinition = await getSolanaTokenDefinition({
         mintAddress: token.token_mint
       });
       if (!tokenDefinition) return;
-      this.params.additional_info.encoded_token = tokenDefinition;
+      this.params.proto.additional_info.encoded_token = tokenDefinition;
     }
   }
   get info() {
     return 'Sign Solana transaction';
   }
-  payloadToPrecomposed() {
+  async payloadToPrecomposed() {
     try {
-      let messageBytes;
-      if (this.payload.serialize) {
-        const transaction = (0, kit_1.pipe)(this.payload.serializedTx, (0, kit_1.getBase16Encoder)().encode, (0, kit_1.getTransactionDecoder)().decode);
-        messageBytes = transaction.messageBytes;
-      } else {
-        messageBytes = (0, kit_1.getBase16Encoder)().encode(this.payload.serializedTx);
-      }
-      const compiledMessage = (0, kit_1.pipe)(messageBytes, (0, kit_1.getCompiledTransactionMessageDecoder)().decode);
-      const message = (0, kit_1.decompileTransactionMessage)(compiledMessage);
-      const baseFee = new utils_1.BigNumber(solanaUtils_1.SOLANA_BASE_FEE).multipliedBy(compiledMessage.header.numSignerAccounts);
+      const {
+        getDecompiledMessage
+      } = await solana();
+      const {
+        message,
+        baseFee,
+        instructions
+      } = getDecompiledMessage(this.params.proto.serialized_tx, this.params.serialize);
       const outputs = [];
-      let feePerUnit = new utils_1.BigNumber(0);
-      let feeLimit = new utils_1.BigNumber(0);
-      let rent = new utils_1.BigNumber(0);
-      let sendAmount = new utils_1.BigNumber(0);
+      let feePerUnit = new BigNumber(0);
+      let feeLimit = new BigNumber(0);
+      let rent = new BigNumber(0);
+      let sendAmount = new BigNumber(0);
       let token;
-      for (const instruction of message.instructions) {
-        if (instruction.programAddress === compute_budget_1.COMPUTE_BUDGET_PROGRAM_ADDRESS && instruction.data) {
-          const data = instruction.data;
-          const type = (0, compute_budget_1.identifyComputeBudgetInstruction)({
-            data
-          });
-          if (type === compute_budget_1.ComputeBudgetInstruction.SetComputeUnitPrice) {
-            const parsed = (0, compute_budget_1.parseSetComputeUnitPriceInstruction)({
-              data,
-              programAddress: compute_budget_1.COMPUTE_BUDGET_PROGRAM_ADDRESS
-            });
-            feePerUnit = new utils_1.BigNumber(parsed.data.microLamports.toString());
-          }
-          if (type === compute_budget_1.ComputeBudgetInstruction.SetComputeUnitLimit) {
-            const parsed = (0, compute_budget_1.parseSetComputeUnitLimitInstruction)({
-              data,
-              programAddress: compute_budget_1.COMPUTE_BUDGET_PROGRAM_ADDRESS
-            });
-            feeLimit = new utils_1.BigNumber(parsed.data.units.toString());
-          }
-        }
-        if (instruction.programAddress === system_1.SYSTEM_PROGRAM_ADDRESS && instruction.data && instruction.accounts) {
-          const instructionSafe = {
-            ...instruction,
-            data: instruction.data,
-            accounts: instruction.accounts
-          };
-          const type = (0, system_1.identifySystemInstruction)(instructionSafe);
-          if (type === system_1.SystemInstruction.TransferSol) {
-            const parsed = (0, system_1.parseTransferSolInstruction)(instructionSafe);
-            outputs.push({
-              address: parsed.accounts.destination.address,
-              amount: parsed.data.amount.toString(),
-              script_type: 'PAYTOADDRESS'
-            });
-            sendAmount = sendAmount.plus(parsed.data.amount.toString());
-          } else if (type === system_1.SystemInstruction.CreateAccount) {
-            const parsed = (0, system_1.parseCreateAccountInstruction)(instructionSafe);
-            outputs.push({
-              address: parsed.accounts.newAccount.address,
-              amount: parsed.data.lamports.toString(),
-              script_type: 'PAYTOADDRESS'
-            });
-            rent = rent.plus(parsed.data.lamports.toString());
-          }
-        }
-        if (instruction.programAddress === token_1.TOKEN_PROGRAM_ADDRESS && instruction.data && instruction.accounts) {
-          const instructionSafe = {
-            ...instruction,
-            data: instruction.data,
-            accounts: instruction.accounts
-          };
-          const type = (0, token_1.identifyTokenInstruction)(instructionSafe);
-          if (type === token_1.TokenInstruction.TransferChecked) {
-            const parsed = (0, token_1.parseTransferCheckedInstruction)(instructionSafe);
-            const destinationATA = parsed.accounts.destination.address;
-            const tokenInfo = this.payload.additionalInfo?.tokenAccountsInfos?.find(t => t.tokenAccount === destinationATA && t.tokenMint === parsed.accounts.mint.address);
-            if (!sendAmount.isZero()) {
-              throw constants_1.ERRORS.TypedError('Runtime', 'Multiple token transfers in a single transaction are not supported');
+      for (const instruction of instructions) {
+        const {
+          type,
+          parsed
+        } = instruction;
+        switch (type) {
+          case 'unit-price':
+            {
+              feePerUnit = new BigNumber(parsed.data.microLamports.toString());
+              break;
+            }
+          case 'unit-limit':
+            {
+              feeLimit = new BigNumber(parsed.data.units.toString());
+              break;
+            }
+          case 'transfer-sol':
+            {
+              outputs.push({
+                address: parsed.accounts.destination.address,
+                amount: parsed.data.amount.toString(),
+                script_type: 'PAYTOADDRESS'
+              });
+              sendAmount = sendAmount.plus(parsed.data.amount.toString());
+              break;
+            }
+          case 'create-account':
+            {
+              outputs.push({
+                address: parsed.accounts.newAccount.address,
+                amount: parsed.data.lamports.toString(),
+                script_type: 'PAYTOADDRESS'
+              });
+              rent = rent.plus(parsed.data.lamports.toString());
+              break;
+            }
+          case 'transfer-checked':
+            {
+              const destinationATA = parsed.accounts.destination.address;
+              const tokenAccountInfos = this.params.proto.additional_info?.token_accounts_infos ?? [];
+              const tokenInfoIndex = tokenAccountInfos.findIndex(t => t.token_account === destinationATA && t.token_mint === parsed.accounts.mint.address);
+              const tokenInfo = tokenAccountInfos[tokenInfoIndex];
+              if (!sendAmount.isZero()) {
+                throw ERRORS.TypedError('Runtime', 'Multiple token transfers in a single transaction are not supported');
+              }
+              outputs.push({
+                address: tokenInfo?.base_address || destinationATA,
+                amount: parsed.data.amount.toString(),
+                script_type: 'PAYTOADDRESS'
+              });
+              sendAmount = new BigNumber(parsed.data.amount.toString());
+              token = {
+                standard: 'SPL',
+                contract: parsed.accounts.mint.address,
+                decimals: parsed.data.decimals,
+                symbol: this.params.symbols?.[tokenInfoIndex]
+              };
+              break;
             }
-            outputs.push({
-              address: tokenInfo?.baseAddress || destinationATA,
-              amount: parsed.data.amount.toString(),
-              script_type: 'PAYTOADDRESS'
-            });
-            sendAmount = new utils_1.BigNumber(parsed.data.amount.toString());
-            token = {
-              standard: 'SPL',
-              contract: parsed.accounts.mint.address,
-              decimals: parsed.data.decimals,
-              symbol: tokenInfo?.symbol
-            };
-          }
+          case 'other':
+          default:
+            break;
         }
       }
       if (outputs.length === 0) {
-        throw constants_1.ERRORS.TypedError('Runtime', 'No outputs decoded');
+        throw ERRORS.TypedError('Runtime', 'No outputs decoded');
       }
       const fee = baseFee.plus(feePerUnit.multipliedBy(feeLimit).dividedBy(1e6));
       const totalSpent = sendAmount.plus(rent).plus(fee);
-      return Promise.resolve({
+      return {
         type: 'final',
         inputs: [],
         outputsPermutation: [0],
@@ -160,18 +161,20 @@ class SolanaSignTransaction extends AbstractMethod_1.AbstractMethod {
         isTokenKnown: false,
         token,
         createdTimestamp: 'blockhash' in message.lifetimeConstraint ? new Date().getTime() : undefined
-      });
+      };
     } catch (e) {
       console.error('Error in payloadToPrecomposed', e);
-      return Promise.resolve(undefined);
     }
   }
   async run() {
-    const cmd = this.device.getCommands();
+    const cmd = this.getDevice().getCommands();
     if (this.params.serialize) {
-      const tx = await (0, solanaUtils_1.createTransactionShimFromHex)(this.params.serialized_tx);
+      const {
+        createTransactionShimFromHex
+      } = await solana();
+      const tx = createTransactionShimFromHex(this.params.proto.serialized_tx);
       const addressCall = await cmd.typedCall('SolanaGetAddress', 'SolanaAddress', {
-        address_n: this.params.address_n,
+        address_n: this.params.proto.address_n,
         show_display: false,
         chunkify: false
       });
@@ -181,7 +184,7 @@ class SolanaSignTransaction extends AbstractMethod_1.AbstractMethod {
       const {
         message
       } = await cmd.typedCall('SolanaSignTx', 'SolanaTxSignature', {
-        ...this.params,
+        ...this.params.proto,
         serialized_tx: tx.serializeMessage()
       });
       tx.addSignature(address, message.signature);
@@ -193,11 +196,9 @@ class SolanaSignTransaction extends AbstractMethod_1.AbstractMethod {
     }
     const {
       message
-    } = await cmd.typedCall('SolanaSignTx', 'SolanaTxSignature', this.params);
+    } = await cmd.typedCall('SolanaSignTx', 'SolanaTxSignature', this.params.proto);
     return {
       signature: message.signature
     };
   }
-}
-exports.default = SolanaSignTransaction;
-//# sourceMappingURL=solanaSignTransaction.js.map
+}

package/lib/api/solana/solanaDefinitions.d.ts

@@ -1,8 +1,9 @@
 import { MessagesSchema } from '@trezor/protobuf';
 interface GetSolanaTokenDefinition {
-    mintAddress?: string;
+  mintAddress?: string;
 }
-export declare const getSolanaTokenDefinition: ({ mintAddress }: GetSolanaTokenDefinition) => Promise<ArrayBuffer | undefined>;
+export declare const getSolanaTokenDefinition: ({
+  mintAddress
+}: GetSolanaTokenDefinition) => Promise<ArrayBuffer | undefined>;
 export declare const decodeSolanaTokenDefinition: (encodedDefinition: ArrayBuffer) => MessagesSchema.SolanaTokenInfo;
-export {};
-//# sourceMappingURL=solanaDefinitions.d.ts.map
+export {};

package/lib/api/solana/solanaDefinitions.js

@@ -1,27 +1,19 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.decodeSolanaTokenDefinition = exports.getSolanaTokenDefinition = void 0;
-const tslib_1 = require("tslib");
-const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
-const protobuf_1 = require("@trezor/protobuf");
-const protocol_1 = require("@trezor/protocol");
-const schema_utils_1 = require("@trezor/schema-utils");
-const DataManager_1 = require("../../data/DataManager");
-const getSolanaTokenDefinition = async ({
+import fetch from "cross-fetch";
+import { MessagesSchema, protobufManager } from "@trezor/protobuf";
+import { trzd } from "@trezor/protocol";
+import { Assert } from "@trezor/schema-utils";
+export const getSolanaTokenDefinition = async ({
   mintAddress
 }) => {
   try {
     if (mintAddress) {
       const tokenDefinitionUrl = `https://data.trezor.io/firmware/definitions/solana/token/${mintAddress}.dat`;
-      const tokenDefinition = await (0, cross_fetch_1.default)(tokenDefinitionUrl);
+      const tokenDefinition = await fetch(tokenDefinitionUrl);
       if (tokenDefinition.status === 200) {
         const arrayBuffer = await tokenDefinition.arrayBuffer();
         return arrayBuffer;
       } else if (tokenDefinition.status !== 404) {
-        throw new Error(`unexpected status: $${tokenDefinition.status}`);
+        throw new Error(`unexpected status: ${tokenDefinition.status}`);
       }
     }
   } catch (err) {
@@ -29,18 +21,13 @@ const getSolanaTokenDefinition = async ({
   }
   return undefined;
 };
-exports.getSolanaTokenDefinition = getSolanaTokenDefinition;
-const decodeSolanaTokenDefinition = encodedDefinition => {
-  const messages = DataManager_1.DataManager.getProtobufMessages();
-  const proto = (0, protobuf_1.parseConfigure)(messages);
+export const decodeSolanaTokenDefinition = encodedDefinition => {
   const {
     protobufPayload
-  } = protocol_1.trzd.decode(encodedDefinition);
+  } = trzd.decode(encodedDefinition);
   const {
     message: decodedTokenDefinition
-  } = (0, protobuf_1.decodeMessage)(proto, 'SolanaTokenInfo', protobufPayload);
-  (0, schema_utils_1.Assert)(protobuf_1.MessagesSchema.SolanaTokenInfo, decodedTokenDefinition);
+  } = protobufManager.decode('SolanaTokenInfo', protobufPayload);
+  Assert(MessagesSchema.SolanaTokenInfo, decodedTokenDefinition);
   return decodedTokenDefinition;
-};
-exports.decodeSolanaTokenDefinition = decodeSolanaTokenDefinition;
-//# sourceMappingURL=solanaDefinitions.js.map
+};

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

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

package/lib/api/stellar/api/index.js

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

package/lib/api/stellar/api/stellarGetAddress.d.ts

@@ -1,27 +1,17 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-type Params = PROTO.StellarGetAddress & {
-    address?: string;
-};
-export default class StellarGetAddress extends AbstractMethod<'stellarGetAddress', Params[]> {
-    hasBundle?: boolean;
-    progress: number;
-    init(): void;
-    get info(): string;
-    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=stellarGetAddress.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 StellarGetAddress extends AbstractMiscGetAddress<'stellarGetAddress'> {
+  constructor(message: MethodMessage<'stellarGetAddress'>);
+  get info(): string;
+  get confirmation(): {
+    view: "export-address";
+    label: string;
+  };
+  _call({
+    proto
+  }: MiscGetAddressParams): Promise<{
+    mac?: string | undefined;
+    address: string;
+  }>;
+}

package/lib/api/stellar/api/stellarGetAddress.js

@@ -1,111 +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 coinInfo_1 = require("../../../data/coinInfo");
-const events_1 = require("../../../events");
-const types_1 = require("../../../types");
-const getAddress_1 = require("../../../types/api/getAddress");
-const pathUtils_1 = require("../../../utils/pathUtils");
-const paramsValidator_1 = require("../../common/paramsValidator");
-class StellarGetAddress 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 StellarGetAddress extends AbstractMiscGetAddress {
+  constructor(message) {
+    super(message, 3);
     this.requiredDeviceCapabilities = ['Capability_Stellar'];
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('Stellar'), 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)(getAddress_1.GetAddress), payload);
-    this.params = payload.bundle.map(batch => {
-      const path = (0, pathUtils_1.validatePath)(batch.path, 3);
-      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('xlm')];
   }
   get info() {
-    if (this.params.length === 1) {
-      return `Export Stellar address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1}`;
-    }
-    return 'Export multiple Stellar 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('Stellar', true);
   }
   get confirmation() {
-    return {
-      view: 'export-address',
-      label: this.info
-    };
+    return this.getConfirmation('Stellar');
   }
   async _call({
-    address_n,
-    show_display,
-    chunkify
+    proto
   }) {
-    const cmd = this.device.getCommands();
-    const response = await cmd.typedCall('StellarGetAddress', 'StellarAddress', {
-      address_n,
-      show_display,
-      chunkify
-    });
+    const cmd = this.getDevice().getCommands();
+    const response = await cmd.typedCall('StellarGetAddress', 'StellarAddress', 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 response = await this._call(batch);
-      responses.push({
-        path: batch.address_n,
-        serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
-        address: response.address
-      });
-      if (this.hasBundle) {
-        this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
-          total: this.params.length,
-          progress: i,
-          response
-        }));
-      }
-      this.progress++;
-    }
-    return this.hasBundle ? responses : responses[0];
-  }
-}
-exports.default = StellarGetAddress;
-//# sourceMappingURL=stellarGetAddress.js.map
+}

package/lib/api/stellar/api/stellarSignTransaction.d.ts

@@ -1,24 +1,20 @@
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import { StellarTransaction } from '../../../types/api/stellar';
+import { StellarSignTransaction as StellarSignTransactionSchema } from '@trezor/connect-common';
+import type { PermissionRequest } from '@trezor/connect-common';
+import type { MethodMessage } from "../../../core/AbstractMethod.js";
+import { AbstractMethod } from "../../../core/AbstractMethod.js";
 type Params = {
-    path: number[];
-    networkPassphrase: string;
-    transaction: StellarTransaction;
-};
-declare const StellarSignTransactionFeatures: Readonly<{
-    manageBuyOffer: string[];
-    pathPaymentStrictSend: string[];
-}>;
+  path: number[];
+} & StellarSignTransactionSchema;
 export default class StellarSignTransaction extends AbstractMethod<'stellarSignTransaction', Params> {
-    init(): void;
-    get info(): string;
-    _isFeatureSupported(feature: keyof typeof StellarSignTransactionFeatures): boolean;
-    _ensureFeatureIsSupported(feature: keyof typeof StellarSignTransactionFeatures): void;
-    _ensureFirmwareSupportsParams(): void;
-    run(): Promise<{
-        publicKey: string;
-        signature: string;
-    }>;
+  constructor(message: MethodMessage<'stellarSignTransaction'>);
+  get requiredPermissions(): PermissionRequest[];
+  get info(): string;
+  private _isFeatureSupported;
+  private _ensureFirmwareSupportsOperation;
+  private parseFromXdr;
+  run(): Promise<{
+    publicKey: string;
+    signature: string;
+  }>;
 }
-export {};
-//# sourceMappingURL=stellarSignTransaction.d.ts.map
+export {};