Tron Support

const evmAccounts = evmChains.map(
  (chain) => `eip155:${chain.id}:${evmAddress}`
);
const tronAccounts = tronAddress ? [`tron:0x2b6653dc:${tronAddress}`] : [];

const options = await pay.getPaymentOptions({
  paymentLink,
  accounts: [...evmAccounts, ...tronAccounts],
});

for (const action of actions) {
  const namespace = action.walletRpc.chainId.split(':')[0];

  switch (namespace) {
    case 'eip155':
      data.push(await handleEvmAction(action));
      break;
    case 'solana':
      data.push(await handleSolanaAction(action));
      break;
    case 'tron':
      data.push(handleTronAction(action)); // returns an object, see below
      break;
    default:
      throw new Error(`Unsupported namespace: ${namespace}`);
  }
}

import { TronWeb, utils } from 'tronweb';

interface TronUnsignedTransaction {
  txID: string;
  raw_data_hex: string;
  raw_data?: Record<string, any>;
}

// A type alias (not an interface) so it is assignable to the Pay SDK's
// `data` element type without a cast.
type TronSignedTransaction = { raw_data_hex: string; signature: string[] };

function signTronPayment(
  tx: TronUnsignedTransaction,
  privateKeyHex: string,
  walletAddress: string
): TronSignedTransaction {
  // 1. txID must be sha256(raw_data_hex)
  const digest = utils.crypto.SHA256(utils.code.hexStr2byteArray(tx.raw_data_hex));
  const computedTxID = utils.bytes.byteArray2hexStr(digest).toLowerCase();
  if (computedTxID !== tx.txID.replace(/^0x/, '').toLowerCase()) {
    throw new Error(`Tron txID mismatch: expected ${computedTxID}, got ${tx.txID}`);
  }

  // 2. The transaction must spend from the quoted buyer
  const owner = tx.raw_data?.contract?.[0]?.parameter?.value?.owner_address;
  if (owner && TronWeb.address.toHex(owner) !== TronWeb.address.toHex(walletAddress)) {
    throw new Error('Tron transaction owner does not match the wallet account');
  }

  // 3. Sign the digest — 65-byte recoverable signature as 130 hex chars
  const signature = utils.crypto.ECKeySign(
    digest,
    utils.code.hexStr2byteArray(privateKeyHex.replace(/^0x/, ''))
  );

  return { raw_data_hex: tx.raw_data_hex, signature: [signature] };
}

import type { ConfirmPaymentParams } from '@walletconnect/pay';

async function approvePayment(actions: Action[]): Promise<NonNullable<ConfirmPaymentParams['data']>> {
  // Plain strings for EVM/Solana results, a JSON object for Tron — in action order
  const data: NonNullable<ConfirmPaymentParams['data']> = [];

  for (const action of actions) {
    const { chainId, method, params } = action.walletRpc;
    const namespace = chainId.split(':')[0];

    switch (namespace) {
      case 'eip155':
        data.push(await handleEvmAction(method, chainId, params));
        break;
      case 'solana':
        data.push(await handleSolanaAction(method, params));
        break;
      case 'tron': {
        if (method !== 'tron_signTransaction') {
          throw new Error(`Unsupported Tron method: ${method}`);
        }
        const parsed = JSON.parse(params);
        const request = Array.isArray(parsed) ? parsed[0] : parsed;
        const transaction = request?.transaction?.transaction ?? request?.transaction;
        data.push(signTronPayment(transaction, tronPrivateKey, tronAddress));
        break;
      }
      default:
        throw new Error(`Unsupported namespace: ${namespace}`);
    }
  }

  return data;
}

const result = await pay.confirmPayment({ paymentId, optionId, data });