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

package/libESM/api/solana/api/solanaSignTransaction.mjs

@@ -1,203 +0,0 @@
-import solana from "@trezor/coins-solana/runtime";
-import { SolanaSignTransaction as SolanaSignTransactionSchema, SolanaTxAdditionalInfo } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { BigNumber } from "@trezor/utils";
-import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
-import { getMiscNetwork } from "../../../data/coinInfo.mjs";
-import { validatePath } from "../../../utils/pathUtils.mjs";
-import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.mjs";
-import { getSolanaTokenDefinition } from "../solanaDefinitions.mjs";
-export default class SolanaSignTransaction extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = 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,
-      payment_req: payload.payment_req ? encodePaymentRequestAmount(payload.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined
-    };
-    const params = {
-      proto,
-      serialize: !!payload.serialize,
-      symbols
-    };
-    super(message, params);
-    this.requiredDeviceCapabilities = ['Capability_Solana'];
-    this.requiredFirmwareCoins = [getMiscNetwork('Solana')];
-  }
-  get requiredPermissions() {
-    return ['read', 'write'];
-  }
-  async initAsync() {
-    const token = this.params.proto.additional_info?.token_accounts_infos?.[0];
-    if (token) {
-      const tokenDefinition = await getSolanaTokenDefinition({
-        mintAddress: token.token_mint
-      });
-      if (!tokenDefinition) return;
-      this.params.proto.additional_info.encoded_token = tokenDefinition;
-    }
-  }
-  get info() {
-    return 'Sign Solana transaction';
-  }
-  async payloadToPrecomposed() {
-    try {
-      const {
-        getDecompiledMessage
-      } = await solana();
-      const {
-        message,
-        baseFee,
-        instructions
-      } = getDecompiledMessage(this.params.proto.serialized_tx, this.params.serialize);
-      const outputs = [];
-      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 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;
-            }
-          case 'other':
-          default:
-            break;
-        }
-      }
-      if (outputs.length === 0) {
-        throw ERRORS.TypedError('Runtime', 'No outputs decoded');
-      }
-      const fee = baseFee.plus(feePerUnit.multipliedBy(feeLimit).dividedBy(1e6));
-      const totalSpent = sendAmount.plus(rent).plus(fee);
-      return {
-        type: 'final',
-        inputs: [],
-        outputsPermutation: [0],
-        outputs,
-        totalSpent: token ? sendAmount.toString() : totalSpent.toString(),
-        fee: fee.toString(),
-        feePerByte: feePerUnit.toString(),
-        feeLimit: feeLimit.toString(),
-        bytes: 0,
-        max: undefined,
-        isTokenKnown: false,
-        token,
-        createdTimestamp: 'blockhash' in message.lifetimeConstraint ? new Date().getTime() : undefined
-      };
-    } catch (e) {
-      console.error('Error in payloadToPrecomposed', e);
-    }
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    if (this.params.serialize) {
-      const {
-        createTransactionShimFromHex
-      } = await solana();
-      const tx = createTransactionShimFromHex(this.params.proto.serialized_tx);
-      const addressCall = await cmd.typedCall('SolanaGetAddress', 'SolanaAddress', {
-        address_n: this.params.proto.address_n,
-        show_display: false,
-        chunkify: false
-      });
-      const {
-        address
-      } = addressCall.message;
-      const {
-        message
-      } = await cmd.typedCall('SolanaSignTx', 'SolanaTxSignature', {
-        ...this.params.proto,
-        serialized_tx: tx.serializeMessage()
-      });
-      tx.addSignature(address, message.signature);
-      const signedSerializedTx = tx.serialize();
-      return {
-        signature: message.signature,
-        serializedTx: signedSerializedTx
-      };
-    }
-    const {
-      message
-    } = await cmd.typedCall('SolanaSignTx', 'SolanaTxSignature', this.params.proto);
-    return {
-      signature: message.signature
-    };
-  }
-}

package/libESM/api/solana/solanaDefinitions.d.mts

@@ -1,7 +0,0 @@
-import { MessagesSchema } from '@trezor/protobuf';
-interface GetSolanaTokenDefinition {
-    mintAddress?: string;
-}
-export declare const getSolanaTokenDefinition: ({ mintAddress }: GetSolanaTokenDefinition) => Promise<ArrayBuffer | undefined>;
-export declare const decodeSolanaTokenDefinition: (encodedDefinition: ArrayBuffer) => MessagesSchema.SolanaTokenInfo;
-export {};

package/libESM/api/solana/solanaDefinitions.mjs

@@ -1,33 +0,0 @@
-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 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}`);
-      }
-    }
-  } catch (err) {
-    console.warn(`unable to download or parse solana token ${mintAddress} definition. detail: ${err.message}`);
-  }
-  return undefined;
-};
-export const decodeSolanaTokenDefinition = encodedDefinition => {
-  const {
-    protobufPayload
-  } = trzd.decode(encodedDefinition);
-  const {
-    message: decodedTokenDefinition
-  } = protobufManager.decode('SolanaTokenInfo', protobufPayload);
-  Assert(MessagesSchema.SolanaTokenInfo, decodedTokenDefinition);
-  return decodedTokenDefinition;
-};

package/libESM/api/stellar/api/index.d.mts

@@ -1,2 +0,0 @@
-export { default as stellarGetAddress } from './stellarGetAddress';
-export { default as stellarSignTransaction } from './stellarSignTransaction';

package/libESM/api/stellar/api/index.mjs

@@ -1,2 +0,0 @@
-export { default as stellarGetAddress } from "./stellarGetAddress.mjs";
-export { default as stellarSignTransaction } from "./stellarSignTransaction.mjs";

package/libESM/api/stellar/api/stellarGetAddress.d.mts

@@ -1,15 +0,0 @@
-import type { MethodMessage } from '../../../core/AbstractMethod';
-import { AbstractMiscGetAddress } from '../../common/AbstractMiscGetAddress';
-import type { MiscGetAddressParams } from '../../common/AbstractMiscGetAddress';
-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/libESM/api/stellar/api/stellarGetAddress.mjs

@@ -1,22 +0,0 @@
-import { getMiscNetwork } from "../../../data/coinInfo.mjs";
-import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.mjs";
-export default class StellarGetAddress extends AbstractMiscGetAddress {
-  constructor(message) {
-    super(message, 3);
-    this.requiredDeviceCapabilities = ['Capability_Stellar'];
-    this.requiredFirmwareCoins = [getMiscNetwork('Stellar')];
-  }
-  get info() {
-    return this.getInfo('Stellar', true);
-  }
-  get confirmation() {
-    return this.getConfirmation('Stellar');
-  }
-  async _call({
-    proto
-  }) {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('StellarGetAddress', 'StellarAddress', proto);
-    return response.message;
-  }
-}

package/libESM/api/stellar/api/stellarSignTransaction.d.mts

@@ -1,26 +0,0 @@
-import type { MethodPermission, PROTO, StellarTransaction } from '@trezor/connect-common';
-import type { MethodMessage } from '../../../core/AbstractMethod';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-type Params = {
-    path: number[];
-    networkPassphrase: string;
-    transaction: StellarTransaction;
-    payment_req?: PROTO.PaymentRequest;
-};
-declare const StellarSignTransactionFeatures: Readonly<{
-    manageBuyOffer: string[];
-    pathPaymentStrictSend: string[];
-}>;
-export default class StellarSignTransaction extends AbstractMethod<'stellarSignTransaction', Params> {
-    constructor(message: MethodMessage<'stellarSignTransaction'>);
-    get requiredPermissions(): MethodPermission[];
-    get info(): string;
-    _isFeatureSupported(feature: keyof typeof StellarSignTransactionFeatures): boolean;
-    _ensureFeatureIsSupported(feature: keyof typeof StellarSignTransactionFeatures): void;
-    _ensureFirmwareSupportsParams(): void;
-    run(): Promise<{
-        publicKey: string;
-        signature: string;
-    }>;
-}
-export {};

package/libESM/api/stellar/api/stellarSignTransaction.mjs

@@ -1,66 +0,0 @@
-import { StellarSignTransaction as StellarSignTransactionSchema } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
-import { getMiscNetwork } from "../../../data/coinInfo.mjs";
-import { validatePath } from "../../../utils/pathUtils.mjs";
-import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../../../utils/paymentRequest.mjs";
-import * as helper from "../stellarSignTx.mjs";
-const StellarSignTransactionFeatures = Object.freeze({
-  manageBuyOffer: ['1.10.4', '2.4.3'],
-  pathPaymentStrictSend: ['1.10.4', '2.4.3']
-});
-export default class StellarSignTransaction extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(StellarSignTransactionSchema, payload);
-    const path = validatePath(payload.path, 3);
-    const {
-      transaction
-    } = payload;
-    const params = {
-      path,
-      networkPassphrase: payload.networkPassphrase,
-      transaction,
-      payment_req: payload.payment_req ? encodePaymentRequestAmount(payload.payment_req, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT) : undefined
-    };
-    super(message, params);
-    this.requiredDeviceCapabilities = ['Capability_Stellar'];
-    this.requiredFirmwareCoins = [getMiscNetwork('Stellar')];
-  }
-  get requiredPermissions() {
-    return ['read', 'write'];
-  }
-  get info() {
-    return 'Sign Stellar transaction';
-  }
-  _isFeatureSupported(feature) {
-    return this.getDevice().atLeast(StellarSignTransactionFeatures[feature]);
-  }
-  _ensureFeatureIsSupported(feature) {
-    if (!this._isFeatureSupported(feature)) {
-      throw ERRORS.TypedError('Method_InvalidParameter', `Feature ${feature} not supported by device firmware`);
-    }
-  }
-  _ensureFirmwareSupportsParams() {
-    const {
-      params
-    } = this;
-    if (params.transaction.operations && params.transaction.operations.find(o => o.type === 'manageBuyOffer')) {
-      this._ensureFeatureIsSupported('manageBuyOffer');
-    }
-    if (params.transaction.operations && params.transaction.operations.find(o => o.type === 'pathPaymentStrictSend')) {
-      this._ensureFeatureIsSupported('pathPaymentStrictSend');
-    }
-  }
-  async run() {
-    this._ensureFirmwareSupportsParams();
-    const response = await helper.stellarSignTx(this.getDevice().getCommands().typedCall, this.params.path, this.params.networkPassphrase, this.params.transaction, this.params.payment_req);
-    return {
-      publicKey: response.public_key,
-      signature: response.signature
-    };
-  }
-}

package/libESM/api/stellar/stellarSignTx.d.mts

@@ -1,7 +0,0 @@
-import type { StellarTransaction } from '@trezor/connect-common/libESM/types/api/stellar';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { TypedCall } from '../../device/DeviceCommands';
-export declare const stellarSignTx: (typedCall: TypedCall, address_n: number[], networkPassphrase: string, tx: StellarTransaction, payment_req?: PROTO.PaymentRequest) => Promise<{
-    public_key: string;
-    signature: string;
-}>;

package/libESM/api/stellar/stellarSignTx.mjs

@@ -1,191 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-import { StellarOperation } from "@trezor/connect-common/libESM/types/api/stellar/index.mjs";
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-const processTxRequest = async (typedCall, operations, index) => {
-  const lastOp = index + 1 >= operations.length;
-  const {
-    type,
-    ...op
-  } = operations[index];
-  if (lastOp) {
-    const response = await typedCall(type, 'StellarSignedTx', op);
-    return response.message;
-  }
-  await typedCall(type, 'StellarTxOpRequest', op);
-  return processTxRequest(typedCall, operations, index + 1);
-};
-const transformSignMessage = tx => {
-  if (!tx.timebounds) {
-    throw ERRORS.TypedError('Runtime', 'transformSignMessage: Unspecified timebounds are not supported');
-  }
-  const msg = {
-    address_n: [],
-    network_passphrase: '',
-    source_account: tx.source,
-    fee: tx.fee,
-    sequence_number: tx.sequence,
-    timebounds_start: tx.timebounds.minTime,
-    timebounds_end: tx.timebounds.maxTime,
-    memo_type: PROTO.StellarMemoType.NONE,
-    num_operations: tx.operations.length
-  };
-  if (tx.memo) {
-    msg.memo_type = tx.memo.type;
-    msg.memo_text = tx.memo.text;
-    msg.memo_id = tx.memo.id;
-    msg.memo_hash = tx.memo.hash;
-  }
-  return msg;
-};
-const transformOperation = op => {
-  Assert(StellarOperation, op);
-  switch (op.type) {
-    case 'createAccount':
-      return {
-        type: 'StellarCreateAccountOp',
-        source_account: op.source,
-        new_account: op.destination,
-        starting_balance: op.startingBalance
-      };
-    case 'payment':
-      return {
-        type: 'StellarPaymentOp',
-        source_account: op.source,
-        destination_account: op.destination,
-        asset: op.asset,
-        amount: op.amount
-      };
-    case 'pathPaymentStrictReceive':
-      return {
-        type: 'StellarPathPaymentStrictReceiveOp',
-        source_account: op.source,
-        send_asset: op.sendAsset,
-        send_max: op.sendMax,
-        destination_account: op.destination,
-        destination_asset: op.destAsset,
-        destination_amount: op.destAmount,
-        paths: op.path
-      };
-    case 'pathPaymentStrictSend':
-      return {
-        type: 'StellarPathPaymentStrictSendOp',
-        source_account: op.source,
-        send_asset: op.sendAsset,
-        send_amount: op.sendAmount,
-        destination_account: op.destination,
-        destination_asset: op.destAsset,
-        destination_min: op.destMin,
-        paths: op.path
-      };
-    case 'createPassiveSellOffer':
-      return {
-        type: 'StellarCreatePassiveSellOfferOp',
-        source_account: op.source,
-        buying_asset: op.buying,
-        selling_asset: op.selling,
-        amount: op.amount,
-        price_n: op.price.n,
-        price_d: op.price.d
-      };
-    case 'manageSellOffer':
-      return {
-        type: 'StellarManageSellOfferOp',
-        source_account: op.source,
-        buying_asset: op.buying,
-        selling_asset: op.selling,
-        amount: op.amount,
-        offer_id: op.offerId || 0,
-        price_n: op.price.n,
-        price_d: op.price.d
-      };
-    case 'manageBuyOffer':
-      return {
-        type: 'StellarManageBuyOfferOp',
-        source_account: op.source,
-        buying_asset: op.buying,
-        selling_asset: op.selling,
-        amount: op.amount,
-        offer_id: op.offerId || 0,
-        price_n: op.price.n,
-        price_d: op.price.d
-      };
-    case 'setOptions':
-      {
-        const signer = op.signer ? {
-          signer_type: op.signer.type,
-          signer_key: op.signer.key,
-          signer_weight: op.signer.weight
-        } : undefined;
-        return {
-          type: 'StellarSetOptionsOp',
-          source_account: op.source,
-          clear_flags: op.clearFlags,
-          set_flags: op.setFlags,
-          master_weight: op.masterWeight,
-          low_threshold: op.lowThreshold,
-          medium_threshold: op.medThreshold,
-          high_threshold: op.highThreshold,
-          home_domain: op.homeDomain,
-          inflation_destination_account: op.inflationDest,
-          ...signer
-        };
-      }
-    case 'changeTrust':
-      return {
-        type: 'StellarChangeTrustOp',
-        source_account: op.source,
-        asset: op.line,
-        limit: op.limit
-      };
-    case 'allowTrust':
-      return {
-        type: 'StellarAllowTrustOp',
-        source_account: op.source,
-        trusted_account: op.trustor,
-        asset_type: op.assetType,
-        asset_code: op.assetCode,
-        is_authorized: !!op.authorize
-      };
-    case 'accountMerge':
-      return {
-        type: 'StellarAccountMergeOp',
-        source_account: op.source,
-        destination_account: op.destination
-      };
-    case 'manageData':
-      return {
-        type: 'StellarManageDataOp',
-        source_account: op.source,
-        key: op.name,
-        value: op.value
-      };
-    case 'bumpSequence':
-      return {
-        type: 'StellarBumpSequenceOp',
-        source_account: op.source,
-        bump_to: op.bumpTo
-      };
-    case 'claimClaimableBalance':
-      return {
-        type: 'StellarClaimClaimableBalanceOp',
-        source_account: op.source,
-        balance_id: op.balanceId
-      };
-  }
-};
-export const stellarSignTx = async (typedCall, address_n, networkPassphrase, tx, payment_req) => {
-  const message = transformSignMessage(tx);
-  message.address_n = address_n;
-  message.network_passphrase = networkPassphrase;
-  message.payment_req = payment_req;
-  const operations = [];
-  tx.operations.forEach(op => {
-    const transformed = transformOperation(op);
-    if (transformed) {
-      operations.push(transformed);
-    }
-  });
-  await typedCall('StellarSignTx', 'StellarTxOpRequest', message);
-  return processTxRequest(typedCall, operations, 0);
-};

package/libESM/api/telemetryGet.d.mts

@@ -1,14 +0,0 @@
-import { type MethodPermission } from '@trezor/connect-common';
-import { MessagesSchema as PROTO } from '@trezor/protobuf';
-import type { MethodMessage } from '../core/AbstractMethod';
-import { AbstractMethod } from '../core/AbstractMethod';
-export default class TelemetryGet extends AbstractMethod<'telemetryGet', PROTO.TelemetryGet> {
-    constructor(message: MethodMessage<'telemetryGet'>);
-    get requiredPermissions(): MethodPermission[];
-    run(): Promise<{
-        min_temp_c?: number | undefined;
-        max_temp_c?: number | undefined;
-        battery_errors?: number | undefined;
-        battery_cycles?: number | undefined;
-    }>;
-}

package/libESM/api/telemetryGet.mjs

@@ -1,24 +0,0 @@
-import { MessagesSchema as PROTO } from "@trezor/protobuf";
-import { Assert } from "@trezor/schema-utils";
-import { AbstractMethod } from "../core/AbstractMethod.mjs";
-export default class TelemetryGet extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(PROTO.TelemetryGet, payload);
-    const params = {
-      ...payload
-    };
-    super(message, params);
-    this.useDeviceState = false;
-  }
-  get requiredPermissions() {
-    return ['management'];
-  }
-  async run() {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('TelemetryGet', 'Telemetry', this.params);
-    return response.message;
-  }
-}

package/libESM/api/tezos/api/index.d.mts

@@ -1,3 +0,0 @@
-export { default as tezosGetAddress } from './tezosGetAddress';
-export { default as tezosGetPublicKey } from './tezosGetPublicKey';
-export { default as tezosSignTransaction } from './tezosSignTransaction';

package/libESM/api/tezos/api/index.mjs

@@ -1,3 +0,0 @@
-export { default as tezosGetAddress } from "./tezosGetAddress.mjs";
-export { default as tezosGetPublicKey } from "./tezosGetPublicKey.mjs";
-export { default as tezosSignTransaction } from "./tezosSignTransaction.mjs";

package/libESM/api/tezos/api/tezosGetAddress.d.mts

@@ -1,15 +0,0 @@
-import type { MethodMessage } from '../../../core/AbstractMethod';
-import { AbstractMiscGetAddress } from '../../common/AbstractMiscGetAddress';
-import type { MiscGetAddressParams } from '../../common/AbstractMiscGetAddress';
-export default class TezosGetAddress extends AbstractMiscGetAddress<'tezosGetAddress'> {
-    constructor(message: MethodMessage<'tezosGetAddress'>);
-    get info(): string;
-    get confirmation(): {
-        view: "export-address";
-        label: string;
-    };
-    _call({ proto }: MiscGetAddressParams): Promise<{
-        mac?: string | undefined;
-        address: string;
-    }>;
-}

package/libESM/api/tezos/api/tezosGetAddress.mjs

@@ -1,22 +0,0 @@
-import { getMiscNetwork } from "../../../data/coinInfo.mjs";
-import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.mjs";
-export default class TezosGetAddress extends AbstractMiscGetAddress {
-  constructor(message) {
-    super(message, 3);
-    this.requiredDeviceCapabilities = ['Capability_Tezos'];
-    this.requiredFirmwareCoins = [getMiscNetwork('Tezos')];
-  }
-  get info() {
-    return this.getInfo('Tezos', true);
-  }
-  get confirmation() {
-    return this.getConfirmation('Tezos');
-  }
-  async _call({
-    proto
-  }) {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('TezosGetAddress', 'TezosAddress', proto);
-    return response.message;
-  }
-}