@trezor/connect 9.7.3 → 10.0.0-alpha.1

package/libESM/api/signTransaction.mjs

@@ -0,0 +1,334 @@
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { BigNumber } from "@trezor/utils/libESM/bigNumber.mjs";
+import { promiseAllSequence } from "@trezor/utils/libESM/promiseAllSequence.mjs";
+import { createPendingTransaction, deriveOutputScript, enhanceSignTx, enhanceTrezorInputs, getOrigTransactions, getReferencedTransactions, parseTransactionHexes, requireReferencedTransactions, signTx, signTxLegacy, transformOrigTransactions, transformReferencedTransactions, validateReferencedTransactions, validateTrezorInputs, validateTrezorOutputs, verifyTx } from "./bitcoin/index.mjs";
+import { initBlockchain, isBackendSupported } from "../backend/BlockchainLink.mjs";
+import { AbstractMethod } from "../core/AbstractMethod.mjs";
+import { getBitcoinNetwork } from "../data/coinInfo.mjs";
+import { getLabel } from "../utils/pathUtils.mjs";
+import { PAYMENT_REQUEST_AMOUNT_BYTES, encodePaymentRequestAmount } from "../utils/paymentRequest.mjs";
+import { getTransactionVbytes } from "./bitcoin/transactionBytes.mjs";
+import { validateParams } from "./common/paramsValidator.mjs";
+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 = ['read', 'write'];
+    if (this.params.push) {
+      permissions.push('push_tx');
+    }
+    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 || !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 [];
+    }
+    isBackendSupported(coinInfo);
+    const blockchain = await initBlockchain(coinInfo, sendCoreMessage, identity);
+    const refTxs = !refTxsIds.length ? [] : await blockchain.getTransactionHexes(refTxsIds).then(parseTransactionHexes(coinInfo.network)).then(rawTxs => {
+      enhanceTrezorInputs(this.params.inputs, rawTxs);
+      return 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) {
+      isBackendSupported(coinInfo);
+      const blockchain = await initBlockchain(coinInfo, sendCoreMessage, params.identity);
+      const txid = await blockchain.pushTransaction(response.serializedTx);
+      return {
+        ...response,
+        txid
+      };
+    }
+    return response;
+  }
+}

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

@@ -0,0 +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';

package/libESM/api/solana/api/index.mjs

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

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

@@ -0,0 +1,31 @@
+import type { CoinInfo, MethodPermission } from '@trezor/connect-common';
+import { SolanaComposeTransaction as SolanaComposeTransactionSchema } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+type SolanaComposeTransactionParams = SolanaComposeTransactionSchema & {
+    coinInfo: CoinInfo;
+};
+export default class SolanaComposeTransaction extends AbstractMethod<'solanaComposeTransaction', SolanaComposeTransactionParams> {
+    constructor(message: MethodMessage<'solanaComposeTransaction'>);
+    get requiredPermissions(): MethodPermission[];
+    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/libESM/api/solana/api/solanaComposeTransaction.mjs

@@ -0,0 +1,76 @@
+import { SYSTEM_PROGRAM_PUBLIC_KEY } from "@trezor/coins-solana/constants";
+import solana from "@trezor/coins-solana/runtime";
+import { SolanaComposeTransaction as SolanaComposeTransactionSchema } from "@trezor/connect-common";
+import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
+import { Assert } from "@trezor/schema-utils";
+import { initBlockchain, isBackendSupported } from "../../../backend/BlockchainLink.mjs";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getCoinInfo } from "../../../data/coinInfo.mjs";
+export default class SolanaComposeTransaction extends AbstractMethod {
+  constructor(message) {
+    const {
+      payload
+    } = message;
+    Assert(SolanaComposeTransactionSchema, payload);
+    const coinInfo = getCoinInfo(payload.coin || 'sol');
+    if (!coinInfo) {
+      throw ERRORS.TypedError('Method_UnknownCoin');
+    }
+    isBackendSupported(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 && 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/libESM/api/solana/api/solanaGetAddress.d.mts

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

@@ -0,0 +1,22 @@
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { AbstractMiscGetAddress } from "../../common/AbstractMiscGetAddress.mjs";
+export default class SolanaGetAddress extends AbstractMiscGetAddress {
+  constructor(message) {
+    super(message, 2);
+    this.requiredDeviceCapabilities = ['Capability_Solana'];
+    this.requiredFirmwareCoins = [getMiscNetwork('Solana')];
+  }
+  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;
+  }
+}

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

@@ -0,0 +1,28 @@
+import type { MethodPermission, PROTO } from '@trezor/connect-common';
+import type { MethodContext, MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+export default class SolanaGetPublicKey extends AbstractMethod<'solanaGetPublicKey', PROTO.SolanaGetPublicKey[]> {
+    hasBundle?: boolean;
+    constructor(message: MethodMessage<'solanaGetPublicKey'>);
+    get requiredPermissions(): MethodPermission[];
+    get info(): string;
+    get confirmation(): {
+        view: "export-xpub";
+        label: string;
+    };
+    run({ sendCoreMessage }: MethodContext): Promise<({
+        publicKey: string;
+        path: number[];
+        serializedPath: string;
+    } & {
+        publicKey: string;
+        publicKeyBase58: string;
+    }) | ({
+        publicKey: string;
+        path: number[];
+        serializedPath: string;
+    } & {
+        publicKey: string;
+        publicKeyBase58: string;
+    })[]>;
+}

package/libESM/api/solana/api/solanaGetPublicKey.mjs

@@ -0,0 +1,67 @@
+import { base58 } from "@scure/base";
+import { Bundle, GetPublicKey as GetPublicKeySchema, UI_REQUEST, createUiMessage } from "@trezor/connect-common";
+import { Assert } from "@trezor/schema-utils";
+import { AbstractMethod } from "../../../core/AbstractMethod.mjs";
+import { getMiscNetwork } from "../../../data/coinInfo.mjs";
+import { fromHardened, getSerializedPath, validatePath } from "../../../utils/pathUtils.mjs";
+import { bundlify } from "../../common/paramsValidator.mjs";
+export default class SolanaGetPublicKey extends AbstractMethod {
+  hasBundle;
+  constructor(message) {
+    const {
+      hasBundle,
+      payload
+    } = bundlify(message.payload);
+    Assert(Bundle(GetPublicKeySchema), payload);
+    const params = payload.bundle.map(batch => {
+      const path = validatePath(batch.path, 2);
+      return {
+        address_n: path,
+        show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : false
+      };
+    });
+    super(message, params);
+    this.hasBundle = hasBundle;
+    this.confirmMissingBackup = true;
+    this.requiredDeviceCapabilities = ['Capability_Solana'];
+    this.requiredFirmwareCoins = [getMiscNetwork('Solana')];
+  }
+  get requiredPermissions() {
+    return ['read'];
+  }
+  get info() {
+    return 'Export Solana public key';
+  }
+  get confirmation() {
+    return {
+      view: 'export-xpub',
+      label: this.params.length > 1 ? 'Export multiple Solana public keys' : `Export Solana public key for account #${fromHardened(this.params[0].address_n[2]) + 1}`
+    };
+  }
+  async run({
+    sendCoreMessage
+  }) {
+    const responses = [];
+    const cmd = this.getDevice().getCommands();
+    for (let i = 0; i < this.params.length; i++) {
+      const batch = this.params[i];
+      const {
+        message
+      } = await cmd.typedCall('SolanaGetPublicKey', 'SolanaPublicKey', batch);
+      responses.push({
+        path: batch.address_n,
+        serializedPath: getSerializedPath(batch.address_n),
+        publicKey: message.public_key,
+        publicKeyBase58: base58.encode(Buffer.from(message.public_key, 'hex'))
+      });
+      if (this.hasBundle) {
+        sendCoreMessage(createUiMessage(UI_REQUEST.BUNDLE_PROGRESS, {
+          total: this.params.length,
+          progress: i,
+          response: message
+        }));
+      }
+    }
+    return this.hasBundle ? responses : responses[0];
+  }
+}

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

@@ -0,0 +1,41 @@
+import type { MethodPermission, PROTO, TokenInfo } from '@trezor/connect-common';
+import type { MethodMessage } from '../../../core/AbstractMethod';
+import { AbstractMethod } from '../../../core/AbstractMethod';
+type Params = {
+    proto: PROTO.SolanaSignTx;
+    serialize: boolean;
+    symbols?: (string | undefined)[];
+};
+export default class SolanaSignTransaction extends AbstractMethod<'solanaSignTransaction', Params> {
+    constructor(message: MethodMessage<'solanaSignTransaction'>);
+    get requiredPermissions(): MethodPermission[];
+    initAsync(): Promise<void>;
+    get info(): string;
+    payloadToPrecomposed(): Promise<{
+        type: "final";
+        inputs: never[];
+        outputsPermutation: number[];
+        outputs: {
+            address: string;
+            amount: string;
+            script_type: "PAYTOADDRESS";
+        }[];
+        totalSpent: string;
+        fee: string;
+        feePerByte: string;
+        feeLimit: string;
+        bytes: number;
+        max: undefined;
+        isTokenKnown: boolean;
+        token: TokenInfo | undefined;
+        createdTimestamp: number | undefined;
+    } | undefined>;
+    run(): Promise<{
+        signature: string;
+        serializedTx: string;
+    } | {
+        signature: string;
+        serializedTx?: undefined;
+    }>;
+}
+export {};