@trezor/connect 9.7.3 → 10.0.0-beta.1

package/lib/api/signTransaction.js

@@ -1,25 +1,20 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const bigNumber_1 = require("@trezor/utils/lib/bigNumber");
-const promiseAllSequence_1 = require("@trezor/utils/lib/promiseAllSequence");
-const constants_1 = require("../constants");
-const bitcoin_1 = require("./bitcoin");
-const BlockchainLink_1 = require("../backend/BlockchainLink");
-const AbstractMethod_1 = require("../core/AbstractMethod");
-const paramsValidator_1 = require("./common/paramsValidator");
-const coinInfo_1 = require("../data/coinInfo");
-const pathUtils_1 = require("../utils/pathUtils");
-const transactionBytes_1 = require("./bitcoin/transactionBytes");
-class SignTransaction extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.requiredPermissions = ['read', 'write'];
+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
-    } = this;
-    (0, paramsValidator_1.validateParams)(payload, [{
+    } = message;
+    validateParams(payload, [{
       name: 'coin',
       type: 'string',
       required: true
@@ -69,9 +64,6 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
     }, {
       name: 'branchId',
       type: 'number'
-    }, {
-      name: 'decredStakingTicket',
-      type: 'boolean'
     }, {
       name: 'push',
       type: 'boolean'
@@ -92,7 +84,7 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
       type: 'boolean'
     }]);
     if (payload.unlockPath) {
-      (0, paramsValidator_1.validateParams)(payload.unlockPath, [{
+      validateParams(payload.unlockPath, [{
         name: 'address_n',
         required: true,
         type: 'array'
@@ -102,14 +94,12 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
         type: 'string'
       }]);
     }
-    const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(payload.coin);
+    const coinInfo = getBitcoinNetwork(payload.coin);
     if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+      throw ERRORS.TypedError('Method_UnknownCoin');
     }
-    this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, coinInfo, this.firmwareRange);
-    this.preauthorized = payload.preauthorized;
-    const inputs = (0, bitcoin_1.validateTrezorInputs)(payload.inputs, coinInfo);
-    const outputs = (0, bitcoin_1.validateTrezorOutputs)(payload.outputs, coinInfo);
+    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;
@@ -118,7 +108,7 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
     if (payload.refTxs && payload.account?.transactions) {
       console.warn('two sources of referential transactions were passed. payload.refTxs have precedence');
     }
-    const refTxs = (0, bitcoin_1.validateReferencedTransactions)({
+    const refTxs = validateReferencedTransactions({
       transactions: payload.refTxs || payload.account?.transactions,
       inputs,
       outputs,
@@ -127,32 +117,19 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
     });
     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_1.BigNumber(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 constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Total amount is below dust limit.');
+        throw ERRORS.TypedError('Method_InvalidParameter', 'Total amount is below dust limit.');
       }
     }
-    const paymentRequests = payload.paymentRequests?.map(p => {
-      if (typeof p.amount === 'number') {
-        const buffer = Buffer.allocUnsafe(8);
-        buffer.writeBigInt64LE(BigInt(p.amount), 0);
-        return {
-          ...p,
-          amount: buffer.toString('hex')
-        };
-      }
-      return {
-        ...p,
-        amount: p.amount
-      };
-    }) ?? [];
-    this.params = {
+    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: {
+      options: enhanceSignTx({
         lock_time: payload.locktime,
         timestamp: payload.timestamp,
         version: payload.version,
@@ -160,53 +137,62 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
         overwintered: payload.overwintered,
         version_group_id: payload.versionGroupId,
         branch_id: payload.branchId,
-        decred_staking_ticket: payload.decredStakingTicket,
         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
     };
-    this.params.options = (0, bitcoin_1.enhanceSignTx)(this.params.options, coinInfo);
+    super(message, params);
+    this.requiredFirmwareCoins = [coinInfo];
+    this.preauthorized = payload.preauthorized;
+  }
+  get requiredPermissions() {
+    const permissions = [this.coinPerm('sign', this.params.coinInfo)];
     if (this.params.push) {
-      this.requiredPermissions.push('push_tx');
+      permissions.push(this.coinPerm('push_tx', this.params.coinInfo));
     }
+    return permissions;
   }
   get info() {
-    const coinInfo = (0, coinInfo_1.getBitcoinNetwork)(this.payload.coin);
-    return (0, pathUtils_1.getLabel)('Sign #NETWORK transaction', coinInfo);
+    return getLabel('Sign #NETWORK transaction', this.params.coinInfo);
   }
-  async payloadToPrecomposed() {
+  payloadToPrecomposed() {
     try {
       const {
         inputs,
         outputs,
         coinInfo
       } = this.params;
-      const refTxs = this.params.refTxs ?? (await this.fetchRefTxs(false));
+      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_1.BigNumber(0));
-      const outputsTotal = outputs.reduce((bn, output) => bn.plus(typeof output.amount === 'string' ? output.amount : '0'), new bigNumber_1.BigNumber(0));
-      const bytes = (0, transactionBytes_1.getTransactionVbytes)(inputs, outputs, coinInfo);
-      if (!bytes) throw constants_1.ERRORS.TypedError('Runtime', 'Transaction bytes not calculated');
+      }, 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 constants_1.ERRORS.TypedError('Runtime', 'Computed fee is non-positive');
+        throw ERRORS.TypedError('Runtime', 'Computed fee is non-positive');
       }
       const feePerByte = fee.dividedBy(bytes);
-      return {
+      const result = {
         type: 'final',
         inputs,
         outputs,
@@ -218,22 +204,23 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
         feePerByte: feePerByte.toString(),
         bytes
       };
+      return Promise.resolve(result);
     } catch (e) {
       console.error('Error in payloadToPrecomposed', e);
-      return undefined;
+      return Promise.resolve(undefined);
     }
   }
   async fetchAddresses(blockchain) {
+    const device = this.getDevice();
     const {
-      device,
       params: {
         inputs,
         coinInfo
       }
     } = this;
     const accountPath = inputs.find(i => i.address_n);
-    if (!accountPath || !accountPath.address_n) {
-      throw constants_1.ERRORS.TypedError('Runtime', 'Account not found');
+    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({
@@ -247,7 +234,7 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
     });
     return account.addresses;
   }
-  async fetchRefTxs(useLegacySignProcess) {
+  async fetchRefTxs(sendCoreMessage, useLegacySignProcess) {
     const {
       params: {
         inputs,
@@ -258,28 +245,27 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
         addresses
       }
     } = this;
-    const requiredRefTxs = (0, bitcoin_1.requireReferencedTransactions)(inputs, options, coinInfo);
-    const refTxsIds = requiredRefTxs ? (0, bitcoin_1.getReferencedTransactions)(inputs) : [];
-    const origTxsIds = !useLegacySignProcess ? (0, bitcoin_1.getOrigTransactions)(inputs, outputs) : [];
+    const requiredRefTxs = requireReferencedTransactions(inputs, options, coinInfo);
+    const refTxsIds = requiredRefTxs ? getReferencedTransactions(inputs) : [];
+    const origTxsIds = !useLegacySignProcess ? getOrigTransactions(inputs, outputs) : [];
     if (!refTxsIds.length && !origTxsIds.length) {
       return [];
     }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage, identity);
-    const refTxs = !refTxsIds.length ? [] : await blockchain.getTransactionHexes(refTxsIds).then((0, bitcoin_1.parseTransactionHexes)(coinInfo.network)).then(rawTxs => {
-      (0, bitcoin_1.enhanceTrezorInputs)(this.params.inputs, rawTxs);
-      return (0, bitcoin_1.transformReferencedTransactions)(rawTxs);
-    });
-    const origTxs = !origTxsIds.length ? [] : await blockchain.getTransactionHexes(origTxsIds).then((0, bitcoin_1.parseTransactionHexes)(coinInfo.network)).then(async rawOrigTxs => {
+    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 (0, bitcoin_1.transformOrigTransactions)(rawOrigTxs, coinInfo, inputs, accountAddresses);
+      return transformOrigTransactions(rawOrigTxs, coinInfo, inputs, accountAddresses);
     });
     return refTxs.concat(origTxs);
   }
-  async run() {
+  async run({
+    sendCoreMessage
+  }) {
+    const device = this.getDevice();
     const {
-      device,
       params
     } = this;
     const {
@@ -288,7 +274,7 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
       coinInfo
     } = params;
     const useLegacySignProcess = !!device.unavailableCapabilities.replaceTransaction;
-    const refTxs = params.refTxs ?? (await this.fetchRefTxs(useLegacySignProcess));
+    const refTxs = params.refTxs ?? (await this.fetchRefTxs(sendCoreMessage, useLegacySignProcess));
     let outputScripts = [];
     if (params.options.serialize !== false) {
       const getHDNode = address_n => device.getCommands().getHDNode({
@@ -297,44 +283,43 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
         coinInfo,
         unlockPath: params.unlockPath
       });
-      outputScripts = await (0, promiseAllSequence_1.promiseAllSequence)(outputs.map(output => () => (0, bitcoin_1.deriveOutputScript)(getHDNode, output, coinInfo.network)));
+      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 ? bitcoin_1.signTx : bitcoin_1.signTxLegacy;
+    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;
     }
-    let bitcoinTx;
-    if (params.options.decred_staking_ticket) {} else {
-      bitcoinTx = (0, bitcoin_1.verifyTx)(response.serializedTx, {
-        inputs,
-        outputs,
-        outputScripts,
-        network: coinInfo.network
-      });
-      if (bitcoinTx.hasWitnesses()) {
-        response.witnesses = bitcoinTx.ins.map((_, i) => bitcoinTx?.getWitness(i)?.toString('hex'));
-      }
+    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 = (0, bitcoin_1.createPendingTransaction)(bitcoinTx, {
+      response.signedTransaction = createPendingTransaction(bitcoinTx, {
         addresses: params.addresses,
         inputs,
         outputs
       });
     }
     if (params.push) {
-      (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-      const blockchain = await (0, BlockchainLink_1.initBlockchain)(coinInfo, this.postMessage, params.identity);
+      assertBackendSupported(coinInfo);
+      const blockchain = await initBlockchain(coinInfo, sendCoreMessage, params.identity);
       const txid = await blockchain.pushTransaction(response.serializedTx);
       return {
         ...response,
@@ -343,6 +328,4 @@ class SignTransaction extends AbstractMethod_1.AbstractMethod {
     }
     return response;
   }
-}
-exports.default = SignTransaction;
-//# sourceMappingURL=signTransaction.js.map
+}

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

@@ -1,5 +1,4 @@
-export { default as solanaComposeTransaction } from './solanaComposeTransaction';
-export { default as solanaGetAddress } from './solanaGetAddress';
-export { default as solanaGetPublicKey } from './solanaGetPublicKey';
-export { default as solanaSignTransaction } from './solanaSignTransaction';
-//# sourceMappingURL=index.d.ts.map
+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,36 +1,4 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.solanaSignTransaction = exports.solanaGetPublicKey = exports.solanaGetAddress = exports.solanaComposeTransaction = void 0;
-const tslib_1 = require("tslib");
-var solanaComposeTransaction_1 = require("./solanaComposeTransaction");
-Object.defineProperty(exports, "solanaComposeTransaction", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(solanaComposeTransaction_1).default;
-  }
-});
-var solanaGetAddress_1 = require("./solanaGetAddress");
-Object.defineProperty(exports, "solanaGetAddress", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(solanaGetAddress_1).default;
-  }
-});
-var solanaGetPublicKey_1 = require("./solanaGetPublicKey");
-Object.defineProperty(exports, "solanaGetPublicKey", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(solanaGetPublicKey_1).default;
-  }
-});
-var solanaSignTransaction_1 = require("./solanaSignTransaction");
-Object.defineProperty(exports, "solanaSignTransaction", {
-  enumerable: true,
-  get: function () {
-    return tslib_1.__importDefault(solanaSignTransaction_1).default;
-  }
-});
-//# sourceMappingURL=index.js.map
+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,30 +1,33 @@
-import { AbstractMethod } from '../../../core/AbstractMethod';
-import { CoinInfo } from '../../../types';
-import { SolanaComposeTransaction as SolanaComposeTransactionSchema } from '../../../types/api/solana';
+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;
+  coinInfo: CoinInfo;
 };
 export default class SolanaComposeTransaction extends AbstractMethod<'solanaComposeTransaction', SolanaComposeTransactionParams> {
-    init(): void;
-    get info(): string;
-    run(): 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;
-        };
-    }>;
+  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 {};
-//# sourceMappingURL=solanaComposeTransaction.d.ts.map
+export {};

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

@@ -1,39 +1,37 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-const solana_1 = require("@trezor/blockchain-link-utils/lib/solana");
-const schema_utils_1 = require("@trezor/schema-utils");
-const BlockchainLink_1 = require("../../../backend/BlockchainLink");
-const constants_1 = require("../../../constants");
-const AbstractMethod_1 = require("../../../core/AbstractMethod");
-const coinInfo_1 = require("../../../data/coinInfo");
-const solana_2 = require("../../../types/api/solana");
-const solanaUtils_1 = require("../solanaUtils");
-class SolanaComposeTransaction extends AbstractMethod_1.AbstractMethod {
-  init() {
-    this.useDevice = false;
-    this.useUi = false;
+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
-    } = this;
-    (0, schema_utils_1.Assert)(solana_2.SolanaComposeTransaction, payload);
-    const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin || 'sol');
-    if (!coinInfo) {
-      throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
-    }
-    (0, BlockchainLink_1.isBackendSupported)(coinInfo);
-    this.params = {
+    } = 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() {
-    const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage, this.params.identity);
+  async run({
+    sendCoreMessage
+  }) {
+    const backend = await initBlockchain(this.params.coinInfo, sendCoreMessage, this.params.identity);
     if (this.params.serializedTx) {
       return {
         serializedTx: this.params.serializedTx,
@@ -41,13 +39,28 @@ class SolanaComposeTransaction extends AbstractMethod_1.AbstractMethod {
       };
     }
     if (!this.params.toAddress) {
-      throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'toAddress not found');
+      throw ERRORS.TypedError('Method_InvalidParameter', 'toAddress not found');
     }
-    const [recipientAccountOwner, recipientTokenAccounts] = this.params.token ? await (0, solanaUtils_1.fetchAccountOwnerAndTokenInfoForAddress)(backend, this.params.toAddress, this.params.token.mint, this.params.token.program) : [undefined, undefined];
-    const tokenTransferTxAndDestinationAddress = this.params.token && this.params.token.accounts ? await (0, solanaUtils_1.buildTokenTransferTransaction)(this.params.fromAddress, this.params.toAddress, recipientAccountOwner || solana_1.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 || solanaUtils_1.dummyPriorityFeesForFeeEstimation, this.params.token.program) : undefined;
-    if (this.params.token && !tokenTransferTxAndDestinationAddress) throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Token accounts not found');
-    const tx = tokenTransferTxAndDestinationAddress ? tokenTransferTxAndDestinationAddress.transaction : await (0, solanaUtils_1.buildTransferTransaction)(this.params.fromAddress, this.params.toAddress, this.params.amount, this.params.blockHash, this.params.lastValidBlockHeight, this.params.priorityFees || solanaUtils_1.dummyPriorityFeesForFeeEstimation);
-    const isCreatingAccount = this.params.token && recipientTokenAccounts === undefined && (recipientAccountOwner === solana_1.SYSTEM_PROGRAM_PUBLIC_KEY || recipientAccountOwner == null);
+    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(),
@@ -57,6 +70,4 @@ class SolanaComposeTransaction extends AbstractMethod_1.AbstractMethod {
       }
     };
   }
-}
-exports.default = SolanaComposeTransaction;
-//# sourceMappingURL=solanaComposeTransaction.js.map
+}

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

@@ -1,27 +1,17 @@
-import { PROTO } from '../../../constants';
-import { AbstractMethod } from '../../../core/AbstractMethod';
-type Params = PROTO.SolanaGetAddress & {
-    address?: string;
-};
-export default class SolanaGetAddress extends AbstractMethod<'solanaGetAddress', Params[]> {
-    hasBundle?: boolean;
-    progress: number;
-    init(): void;
-    get info(): "Export Solana address" | "Export multiple Solana addresses";
-    getButtonRequestData(code: string): {
-        type: "address";
-        serializedPath: string;
-        address: string;
-    } | undefined;
-    get confirmation(): {
-        view: "export-address";
-        label: string;
-    };
-    _call({ address_n, show_display, chunkify }: Params): Promise<{
-        mac?: string | undefined;
-        address: string;
-    }>;
-    run(): Promise<import("../../../types").Address | import("../../../types").Address[]>;
-}
-export {};
-//# sourceMappingURL=solanaGetAddress.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 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;
+  }>;
+}