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

package/lib/api/signTransaction.d.ts

@@ -1,199 +0,0 @@
-import type { AccountAddresses, BitcoinNetworkInfo, PROTO, PermissionRequest, RefTransaction, TransactionOptions } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage } from "../core/AbstractMethod.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-type Params = {
-  inputs: PROTO.TxInputType[];
-  outputs: PROTO.TxOutputType[];
-  paymentRequests: PROTO.PaymentRequest[];
-  coinjoinRequest?: PROTO.CoinJoinRequest;
-  refTxs?: RefTransaction[];
-  addresses?: AccountAddresses;
-  options: TransactionOptions;
-  coinInfo: BitcoinNetworkInfo;
-  identity?: string;
-  push: boolean;
-  unlockPath?: PROTO.UnlockPath;
-};
-export default class SignTransaction extends AbstractMethod<'signTransaction', Params> {
-  constructor(message: MethodMessage<'signTransaction'>);
-  get requiredPermissions(): PermissionRequest[];
-  get info(): string;
-  payloadToPrecomposed(): Promise<undefined> | Promise<{
-    type: "final";
-    inputs: (({
-      sequence?: number | undefined;
-      multisig?: {
-        address_n?: number[] | undefined;
-        nodes?: {
-          private_key?: string | undefined;
-          fingerprint: number;
-          depth: number;
-          child_num: number;
-          chain_code: string;
-          public_key: string;
-        }[] | undefined;
-        pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
-        pubkeys: {
-          node: string | {
-            private_key?: string | undefined;
-            fingerprint: number;
-            depth: number;
-            child_num: number;
-            chain_code: string;
-            public_key: string;
-          };
-          address_n: number[];
-        }[];
-        signatures: string[];
-        m: number;
-      } | undefined;
-      decred_tree?: number | undefined;
-      orig_hash?: string | undefined;
-      orig_index?: number | undefined;
-      decred_staking_spend?: PROTO.DecredStakingSpendType | undefined;
-      script_pubkey?: string | undefined;
-      coinjoin_flags?: number | undefined;
-      script_sig?: string | undefined;
-      witness?: string | undefined;
-      ownership_proof?: string | undefined;
-      commitment_data?: string | undefined;
-      prev_hash: string;
-      prev_index: number;
-      amount: string | number;
-    } & {
-      script_type?: "SPENDADDRESS" | "SPENDMULTISIG" | "SPENDWITNESS" | "SPENDP2SHWITNESS" | "SPENDTAPROOT" | undefined;
-      address_n: number[];
-    }) | ({
-      sequence?: number | undefined;
-      multisig?: {
-        address_n?: number[] | undefined;
-        nodes?: {
-          private_key?: string | undefined;
-          fingerprint: number;
-          depth: number;
-          child_num: number;
-          chain_code: string;
-          public_key: string;
-        }[] | undefined;
-        pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
-        pubkeys: {
-          node: string | {
-            private_key?: string | undefined;
-            fingerprint: number;
-            depth: number;
-            child_num: number;
-            chain_code: string;
-            public_key: string;
-          };
-          address_n: number[];
-        }[];
-        signatures: string[];
-        m: number;
-      } | undefined;
-      decred_tree?: number | undefined;
-      orig_hash?: string | undefined;
-      orig_index?: number | undefined;
-      decred_staking_spend?: PROTO.DecredStakingSpendType | undefined;
-      script_pubkey?: string | undefined;
-      coinjoin_flags?: number | undefined;
-      script_sig?: string | undefined;
-      witness?: string | undefined;
-      ownership_proof?: string | undefined;
-      commitment_data?: string | undefined;
-      prev_hash: string;
-      prev_index: number;
-      amount: string | number;
-    } & {
-      address_n?: undefined;
-      script_pubkey: string;
-      script_type: "EXTERNAL";
-    }))[];
-    outputs: ({
-      multisig?: {
-        address_n?: number[] | undefined;
-        nodes?: {
-          private_key?: string | undefined;
-          fingerprint: number;
-          depth: number;
-          child_num: number;
-          chain_code: string;
-          public_key: string;
-        }[] | undefined;
-        pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
-        pubkeys: {
-          node: string | {
-            private_key?: string | undefined;
-            fingerprint: number;
-            depth: number;
-            child_num: number;
-            chain_code: string;
-            public_key: string;
-          };
-          address_n: number[];
-        }[];
-        signatures: string[];
-        m: number;
-      } | undefined;
-      orig_hash?: string | undefined;
-      orig_index?: number | undefined;
-      address_n?: undefined;
-      script_type?: "PAYTOADDRESS" | undefined;
-      payment_req_index?: number | undefined;
-      amount: string | number;
-      address: string;
-    } | {
-      multisig?: {
-        address_n?: number[] | undefined;
-        nodes?: {
-          private_key?: string | undefined;
-          fingerprint: number;
-          depth: number;
-          child_num: number;
-          chain_code: string;
-          public_key: string;
-        }[] | undefined;
-        pubkeys_order?: PROTO.MultisigPubkeysOrder | undefined;
-        pubkeys: {
-          node: string | {
-            private_key?: string | undefined;
-            fingerprint: number;
-            depth: number;
-            child_num: number;
-            chain_code: string;
-            public_key: string;
-          };
-          address_n: number[];
-        }[];
-        signatures: string[];
-        m: number;
-      } | undefined;
-      orig_hash?: string | undefined;
-      orig_index?: number | undefined;
-      script_type?: "PAYTOADDRESS" | "PAYTOSCRIPTHASH" | "PAYTOMULTISIG" | "PAYTOWITNESS" | "PAYTOP2SHWITNESS" | "PAYTOTAPROOT" | undefined;
-      address?: undefined;
-      payment_req_index?: number | undefined;
-      amount: string | number;
-      address_n: number[];
-    } | {
-      orig_hash?: string | undefined;
-      orig_index?: number | undefined;
-      address_n?: undefined;
-      address?: undefined;
-      payment_req_index?: number | undefined;
-      amount: 0 | "0";
-      script_type: "PAYTOOPRETURN";
-      op_return_data: string;
-    })[];
-    outputsPermutation: number[];
-    totalSpent: string;
-    fee: string;
-    feePerByte: string;
-    bytes: number;
-  }>;
-  private fetchAddresses;
-  private fetchRefTxs;
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<import("@trezor/connect-common").SignedTransaction>;
-}
-export {};

package/lib/api/signTransaction.js

@@ -1,331 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { BigNumber } from "@trezor/utils/lib/bigNumber.js";
-import { promiseAllSequence } from "@trezor/utils/lib/promiseAllSequence.js";
-import { createPendingTransaction, deriveOutputScript, enhanceSignTx, getOrigTransactions, getReferencedTransactions, parseTransactionHexes, requireReferencedTransactions, signTx, signTxLegacy, transformOrigTransactions, transformReferencedTransactions, validateReferencedTransactions, validateTrezorInputs, validateTrezorOutputs, verifyTx } from "./bitcoin/index.js";
-import { assertBackendSupported, initBlockchain } from "../backend/BlockchainLink.js";
-import { AbstractMethod } from "../core/AbstractMethod.js";
-import { getBitcoinNetwork } from "../data/coinInfo.js";
-import { getLabel } from "../utils/pathUtils.js";
-import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../utils/paymentRequest.js";
-import { getTransactionVbytes } from "./bitcoin/transactionBytes.js";
-import { validateParams } from "./common/paramsValidator.js";
-export default class SignTransaction extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    validateParams(payload, [{
-      name: 'coin',
-      type: 'string',
-      required: true
-    }, {
-      name: 'identity',
-      type: 'string'
-    }, {
-      name: 'inputs',
-      type: 'array',
-      required: true
-    }, {
-      name: 'outputs',
-      type: 'array',
-      required: true
-    }, {
-      name: 'paymentRequests',
-      type: 'array',
-      allowEmpty: true
-    }, {
-      name: 'coinjoinRequest',
-      type: 'object'
-    }, {
-      name: 'refTxs',
-      type: 'array',
-      allowEmpty: true
-    }, {
-      name: 'account',
-      type: 'object'
-    }, {
-      name: 'locktime',
-      type: 'number'
-    }, {
-      name: 'timestamp',
-      type: 'number'
-    }, {
-      name: 'version',
-      type: 'number'
-    }, {
-      name: 'expiry',
-      type: 'number'
-    }, {
-      name: 'overwintered',
-      type: 'boolean'
-    }, {
-      name: 'versionGroupId',
-      type: 'number'
-    }, {
-      name: 'branchId',
-      type: 'number'
-    }, {
-      name: 'push',
-      type: 'boolean'
-    }, {
-      name: 'preauthorized',
-      type: 'boolean'
-    }, {
-      name: 'amountUnit',
-      type: ['number', 'string']
-    }, {
-      name: 'unlockPath',
-      type: 'object'
-    }, {
-      name: 'serialize',
-      type: 'boolean'
-    }, {
-      name: 'chunkify',
-      type: 'boolean'
-    }]);
-    if (payload.unlockPath) {
-      validateParams(payload.unlockPath, [{
-        name: 'address_n',
-        required: true,
-        type: 'array'
-      }, {
-        name: 'mac',
-        required: true,
-        type: 'string'
-      }]);
-    }
-    const coinInfo = getBitcoinNetwork(payload.coin);
-    if (!coinInfo) {
-      throw ERRORS.TypedError('Method_UnknownCoin');
-    }
-    const inputs = validateTrezorInputs(payload.inputs, coinInfo);
-    const outputs = validateTrezorOutputs(payload.outputs, coinInfo);
-    if (payload.paymentRequests && payload.paymentRequests.length > 0) {
-      outputs.forEach(output => {
-        output.payment_req_index = 0;
-      });
-    }
-    if (payload.refTxs && payload.account?.transactions) {
-      console.warn('two sources of referential transactions were passed. payload.refTxs have precedence');
-    }
-    const refTxs = validateReferencedTransactions({
-      transactions: payload.refTxs || payload.account?.transactions,
-      inputs,
-      outputs,
-      coinInfo,
-      addresses: payload.account?.addresses
-    });
-    const outputsWithAmount = outputs.filter(output => typeof output.amount === 'string' && !Object.prototype.hasOwnProperty.call(output, 'op_return_data'));
-    if (outputsWithAmount.length > 0) {
-      const total = outputsWithAmount.reduce((bn, output) => bn.plus(typeof output.amount === 'string' ? output.amount : '0'), new BigNumber(0));
-      if (total.lt(coinInfo.dustLimit)) {
-        throw ERRORS.TypedError('Method_InvalidParameter', 'Total amount is below dust limit.');
-      }
-    }
-    const paymentRequests = payload.paymentRequests?.map(p => encodePaymentRequestAmount(p, PAYMENT_REQUEST_AMOUNT_BYTES.DEFAULT)) ?? [];
-    const params = {
-      inputs,
-      outputs,
-      paymentRequests,
-      refTxs,
-      addresses: payload.account ? payload.account.addresses : undefined,
-      options: enhanceSignTx({
-        lock_time: payload.locktime,
-        timestamp: payload.timestamp,
-        version: payload.version,
-        expiry: payload.expiry,
-        overwintered: payload.overwintered,
-        version_group_id: payload.versionGroupId,
-        branch_id: payload.branchId,
-        amount_unit: payload.amountUnit,
-        serialize: payload.serialize,
-        coinjoin_request: payload.coinjoinRequest,
-        chunkify: typeof payload.chunkify === 'boolean' ? payload.chunkify : false
-      }, coinInfo),
-      coinInfo,
-      identity: payload.identity,
-      push: typeof payload.push === 'boolean' ? payload.push : false,
-      unlockPath: payload.unlockPath
-    };
-    super(message, params);
-    this.requiredFirmwareCoins = [coinInfo];
-    this.preauthorized = payload.preauthorized;
-  }
-  get requiredPermissions() {
-    const permissions = [this.coinPerm('sign', this.params.coinInfo)];
-    if (this.params.push) {
-      permissions.push(this.coinPerm('push_tx', this.params.coinInfo));
-    }
-    return permissions;
-  }
-  get info() {
-    return getLabel('Sign #NETWORK transaction', this.params.coinInfo);
-  }
-  payloadToPrecomposed() {
-    try {
-      const {
-        inputs,
-        outputs,
-        coinInfo
-      } = this.params;
-      const {
-        refTxs
-      } = this.params;
-      const inputsTotal = inputs.reduce((bn, input) => {
-        if (typeof input.amount === 'string') {
-          return bn.plus(input.amount);
-        } else {
-          if (!refTxs) {
-            throw ERRORS.TypedError('Runtime', 'refTxs are required for precomposed transaction info when input amount is not provided');
-          }
-          const refTx = refTxs.find(tx => tx.hash === input.prev_hash);
-          const refOutput = refTx?.outputs?.[input.prev_index] ?? refTx?.bin_outputs?.[input.prev_index];
-          if (refOutput) return bn.plus(refOutput.amount);
-        }
-        return bn;
-      }, new BigNumber(0));
-      const outputsTotal = outputs.reduce((bn, output) => bn.plus(typeof output.amount === 'string' ? output.amount : '0'), new BigNumber(0));
-      const bytes = getTransactionVbytes(inputs, outputs, coinInfo);
-      if (!bytes) throw ERRORS.TypedError('Runtime', 'Transaction bytes not calculated');
-      const fee = inputsTotal.minus(outputsTotal);
-      if (fee.lte(0)) {
-        throw ERRORS.TypedError('Runtime', 'Computed fee is non-positive');
-      }
-      const feePerByte = fee.dividedBy(bytes);
-      const result = {
-        type: 'final',
-        inputs,
-        outputs,
-        outputsPermutation: Array.from({
-          length: outputs.length
-        }, (_, i) => i),
-        totalSpent: inputsTotal.toString(),
-        fee: fee.toString(),
-        feePerByte: feePerByte.toString(),
-        bytes
-      };
-      return Promise.resolve(result);
-    } catch (e) {
-      console.error('Error in payloadToPrecomposed', e);
-      return Promise.resolve(undefined);
-    }
-  }
-  async fetchAddresses(blockchain) {
-    const device = this.getDevice();
-    const {
-      params: {
-        inputs,
-        coinInfo
-      }
-    } = this;
-    const accountPath = inputs.find(i => i.address_n);
-    if (!accountPath?.address_n) {
-      throw ERRORS.TypedError('Runtime', 'Account not found');
-    }
-    const address_n = accountPath.address_n.slice(0, 3);
-    const node = await device.getCommands().getHDNode({
-      address_n
-    }, {
-      coinInfo
-    });
-    const account = await blockchain.getAccountInfo({
-      descriptor: node.xpubSegwit || node.xpub,
-      details: 'tokens'
-    });
-    return account.addresses;
-  }
-  async fetchRefTxs(sendCoreMessage, useLegacySignProcess) {
-    const {
-      params: {
-        inputs,
-        outputs,
-        options,
-        coinInfo,
-        identity,
-        addresses
-      }
-    } = this;
-    const requiredRefTxs = requireReferencedTransactions(inputs, options, coinInfo);
-    const refTxsIds = requiredRefTxs ? getReferencedTransactions(inputs) : [];
-    const origTxsIds = !useLegacySignProcess ? getOrigTransactions(inputs, outputs) : [];
-    if (!refTxsIds.length && !origTxsIds.length) {
-      return [];
-    }
-    assertBackendSupported(coinInfo);
-    const blockchain = await initBlockchain(coinInfo, sendCoreMessage, identity);
-    const refTxs = !refTxsIds.length ? [] : await blockchain.getTransactionHexes(refTxsIds).then(parseTransactionHexes(coinInfo.network)).then(rawTxs => transformReferencedTransactions(rawTxs));
-    const origTxs = !origTxsIds.length ? [] : await blockchain.getTransactionHexes(origTxsIds).then(parseTransactionHexes(coinInfo.network)).then(async rawOrigTxs => {
-      const accountAddresses = addresses ?? (await this.fetchAddresses(blockchain));
-      if (!accountAddresses) return [];
-      return transformOrigTransactions(rawOrigTxs, coinInfo, inputs, accountAddresses);
-    });
-    return refTxs.concat(origTxs);
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const device = this.getDevice();
-    const {
-      params
-    } = this;
-    const {
-      inputs,
-      outputs,
-      coinInfo
-    } = params;
-    const useLegacySignProcess = !!device.unavailableCapabilities.replaceTransaction;
-    const refTxs = params.refTxs ?? (await this.fetchRefTxs(sendCoreMessage, useLegacySignProcess));
-    let outputScripts = [];
-    if (params.options.serialize !== false) {
-      const getHDNode = address_n => device.getCommands().getHDNode({
-        address_n
-      }, {
-        coinInfo,
-        unlockPath: params.unlockPath
-      });
-      outputScripts = await promiseAllSequence(outputs.map(output => () => deriveOutputScript(getHDNode, output, coinInfo.network)));
-    }
-    if (this.preauthorized) {
-      await device.getCommands().preauthorize(true);
-    } else if (params.unlockPath) {
-      await device.getCommands().unlockPath(params.unlockPath);
-    }
-    const signTxMethod = !useLegacySignProcess ? signTx : signTxLegacy;
-    device.startPiggybackAck();
-    const response = await signTxMethod({
-      ...params,
-      refTxs,
-      typedCall: device.getCommands().typedCall
-    });
-    await device.stopPiggybackAck();
-    if (!response.serializedTx) {
-      return response;
-    }
-    const bitcoinTx = verifyTx(response.serializedTx, {
-      inputs,
-      outputs,
-      outputScripts,
-      network: coinInfo.network
-    });
-    if (bitcoinTx.hasWitnesses()) {
-      response.witnesses = bitcoinTx.ins.map((_, i) => bitcoinTx?.getWitness(i)?.toString('hex'));
-    }
-    if (bitcoinTx && params.addresses) {
-      response.signedTransaction = createPendingTransaction(bitcoinTx, {
-        addresses: params.addresses,
-        inputs,
-        outputs
-      });
-    }
-    if (params.push) {
-      assertBackendSupported(coinInfo);
-      const blockchain = await initBlockchain(coinInfo, sendCoreMessage, params.identity);
-      const txid = await blockchain.pushTransaction(response.serializedTx);
-      return {
-        ...response,
-        txid
-      };
-    }
-    return response;
-  }
-}

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

@@ -1,4 +0,0 @@
-export { default as solanaComposeTransaction } from "./solanaComposeTransaction.js";
-export { default as solanaGetAddress } from "./solanaGetAddress.js";
-export { default as solanaGetPublicKey } from "./solanaGetPublicKey.js";
-export { default as solanaSignTransaction } from "./solanaSignTransaction.js";

package/lib/api/solana/api/index.js

@@ -1,4 +0,0 @@
-export { default as solanaComposeTransaction } from "./solanaComposeTransaction.js";
-export { default as solanaGetAddress } from "./solanaGetAddress.js";
-export { default as solanaGetPublicKey } from "./solanaGetPublicKey.js";
-export { default as solanaSignTransaction } from "./solanaSignTransaction.js";

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

@@ -1,33 +0,0 @@
-import type { CoinInfo, PermissionRequest } from '@trezor/connect-common';
-import { SolanaComposeTransaction as SolanaComposeTransactionSchema } from '@trezor/connect-common';
-import type { MethodContext, MethodMessage } from "../../../core/AbstractMethod.js";
-import { AbstractMethod } from "../../../core/AbstractMethod.js";
-type SolanaComposeTransactionParams = SolanaComposeTransactionSchema & {
-  coinInfo: CoinInfo;
-};
-export default class SolanaComposeTransaction extends AbstractMethod<'solanaComposeTransaction', SolanaComposeTransactionParams> {
-  constructor(message: MethodMessage<'solanaComposeTransaction'>);
-  get requiredPermissions(): PermissionRequest[];
-  get info(): string;
-  run({
-    sendCoreMessage
-  }: MethodContext): Promise<{
-    serializedTx: string;
-    additionalInfo: {
-      newAccountProgramName?: undefined;
-      tokenAccountInfo?: undefined;
-    };
-  } | {
-    serializedTx: string;
-    additionalInfo: {
-      newAccountProgramName: "spl-token" | "spl-token-2022" | undefined;
-      tokenAccountInfo: {
-        baseAddress: string;
-        tokenProgram: string;
-        tokenMint: string;
-        tokenAccount: string;
-      } | undefined;
-    };
-  }>;
-}
-export {};

package/lib/api/solana/api/solanaComposeTransaction.js

@@ -1,73 +0,0 @@
-import { SolanaComposeTransaction as SolanaComposeTransactionSchema } from "@trezor/connect-common";
-import { ERRORS } from "@trezor/connect-common/lib/constants/index.js";
-import { SYSTEM_PROGRAM_PUBLIC_KEY } from "@trezor/network-solana/constants";
-import solana from "@trezor/network-solana/runtime";
-import { Assert } from "@trezor/schema-utils";
-import { assertBackendSupported, initBlockchain } from "../../../backend/BlockchainLink.js";
-import { AbstractMethod } from "../../../core/AbstractMethod.js";
-import { getCoinInfoOrThrow } from "../../../data/coinInfo.js";
-export default class SolanaComposeTransaction extends AbstractMethod {
-  constructor(message) {
-    const {
-      payload
-    } = message;
-    Assert(SolanaComposeTransactionSchema, payload);
-    const coinInfo = getCoinInfoOrThrow(payload.coin || 'sol');
-    assertBackendSupported(coinInfo);
-    const params = {
-      coinInfo,
-      ...payload
-    };
-    super(message, params);
-    this.useDevice = false;
-    this.useUi = false;
-  }
-  get requiredPermissions() {
-    return [];
-  }
-  get info() {
-    return 'Compose Solana transaction';
-  }
-  async run({
-    sendCoreMessage
-  }) {
-    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
-    if (this.params.serializedTx) {
-      return {
-        serializedTx: this.params.serializedTx,
-        additionalInfo: {}
-      };
-    }
-    if (!this.params.toAddress) {
-      throw ERRORS.TypedError('Method_InvalidParameter', 'toAddress not found');
-    }
-    const {
-      getAssociatedTokenAccountAddress,
-      buildTokenTransferTransaction,
-      buildTransferTransaction
-    } = await solana();
-    const {
-      token,
-      toAddress
-    } = this.params;
-    const [recipientAccountOwner, recipientTokenAccounts] = token ? await backend.getAccountInfo({
-      descriptor: toAddress
-    }).then(accountInfo => !accountInfo ? [undefined, undefined] : getAssociatedTokenAccountAddress(toAddress, token.mint, token.program).then(associatedTokenAccount => {
-      const accountOwner = accountInfo?.misc?.owner;
-      const tokenInfo = accountInfo?.tokens?.find(t => t.contract === token.mint)?.accounts?.find(account => associatedTokenAccount.toString() === account.publicKey);
-      return [accountOwner, tokenInfo];
-    })) : [undefined, undefined];
-    const tokenTransferTxAndDestinationAddress = this.params.token?.accounts ? await buildTokenTransferTransaction(this.params.fromAddress, this.params.toAddress, recipientAccountOwner || SYSTEM_PROGRAM_PUBLIC_KEY, this.params.token.mint, this.params.amount || '0', this.params.token.decimals, this.params.token.accounts, recipientTokenAccounts, this.params.blockHash, this.params.lastValidBlockHeight, this.params.priorityFees, this.params.token.program, this.params.memo) : undefined;
-    if (this.params.token && !tokenTransferTxAndDestinationAddress) throw ERRORS.TypedError('Method_InvalidParameter', 'Token accounts not found');
-    const tx = tokenTransferTxAndDestinationAddress ? tokenTransferTxAndDestinationAddress.transaction : buildTransferTransaction(this.params.fromAddress, this.params.toAddress, this.params.amount, this.params.blockHash, this.params.lastValidBlockHeight, this.params.priorityFees, this.params.memo);
-    const isCreatingAccount = this.params.token && recipientTokenAccounts === undefined && (recipientAccountOwner === SYSTEM_PROGRAM_PUBLIC_KEY || recipientAccountOwner == null);
-    const newAccountProgramName = isCreatingAccount ? this.params.token?.program : undefined;
-    return {
-      serializedTx: tx.serialize(),
-      additionalInfo: {
-        newAccountProgramName,
-        tokenAccountInfo: tokenTransferTxAndDestinationAddress?.tokenAccountInfo
-      }
-    };
-  }
-}

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

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

package/lib/api/solana/api/solanaGetAddress.js

@@ -1,22 +0,0 @@
-import { getMiscNetwork } from "../../../data/coinInfo.js";
-import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.js";
-export default class SolanaGetAddress extends AbstractMiscGetAddress {
-  constructor(message) {
-    super(message, 2);
-    this.requiredDeviceCapabilities = ['Capability_Solana'];
-    this.requiredFirmwareCoins = [getMiscNetwork('sol')];
-  }
-  get info() {
-    return this.getInfo('Solana', false);
-  }
-  get confirmation() {
-    return this.getConfirmation('Solana');
-  }
-  async _call({
-    proto
-  }) {
-    const cmd = this.getDevice().getCommands();
-    const response = await cmd.typedCall('SolanaGetAddress', 'SolanaAddress', proto);
-    return response.message;
-  }
-}