feat: add Tron payment processor support (#1690)

## Description of the changes

Added support for Tron blockchain payments in the payment-processor package. This implementation enables TRC20 token payments through the ERC20 Fee Proxy contract on Tron networks.

The changes include:
- New `tron-fee-proxy.ts` module with functions for paying requests on Tron:
  - `payTronFeeProxyRequest` - Process payments with TRC20 tokens
  - `approveTronFeeProxyRequest` - Approve token spending
  - `hasSufficientTronAllowance` - Check token allowance
  - `hasSufficientTronBalance` - Verify token balance
  - `getTronPaymentInfo` - Get payment details

- New `utils-tron.ts` module with Tron-specific utilities:
  - TronWeb type definitions
  - Address validation
  - Contract interaction helpers
  - Token approval and payment processing

- Comprehensive test coverage for all new functionality
- Exports for the new modules in the package index

---
Closes RequestNetwork/private-issues#234

Author: rodrigopavezi

.circleci/config.yml

@@ -43,6 +43,15 @@ references:
     name: 'Subgraph deployment and configuration'
     working_directory: ~/
     command: |
+      # Wait for Graph node to be ready
+      for i in $(seq 1 30); do
+        if curl -s http://localhost:8020 > /dev/null 2>&1; then
+          echo "Graph node is ready"
+          break
+        fi
+        echo "Waiting for Graph node... ($i/30)"
+        sleep 2
+      done
       git clone https://github.com/RequestNetwork/storage-subgraph
       cd storage-subgraph
       yarn

packages/payment-detection/src/erc20/fee-proxy-contract.ts

@@ -5,7 +5,7 @@ import {
   PaymentTypes,
   RequestLogicTypes,
 } from '@requestnetwork/types';
-import { EvmChains, NearChains, isSameChain } from '@requestnetwork/currency';
+import { EvmChains, NearChains, TronChains, isSameChain } from '@requestnetwork/currency';
 import ProxyInfoRetriever from './proxy-info-retriever';
 
 import { loadCurrencyFromContract } from './currency';
@@ -14,6 +14,7 @@ import { makeGetDeploymentInformation } from '../utils';
 import { TheGraphClient, TheGraphInfoRetriever } from '../thegraph';
 import { ReferenceBasedDetectorOptions, TGetSubGraphClient } from '../types';
 import { NearInfoRetriever } from '../near';
+import { TronInfoRetriever } from '../tron/tron-info-retriever';
 import { NetworkNotSupported } from '../balance-error';
 
 const PROXY_CONTRACT_ADDRESS_MAP = {
@@ -165,11 +166,13 @@ export class ERC20FeeProxyPaymentDetector<
       | TheGraphClient
       | TheGraphClient<CurrencyTypes.NearChainName>
       | TheGraphClient<CurrencyTypes.TronChainName>,
-  ): TheGraphInfoRetriever | NearInfoRetriever {
+  ): TheGraphInfoRetriever | NearInfoRetriever | TronInfoRetriever {
     const graphInfoRetriever = EvmChains.isChainSupported(paymentChain)
       ? new TheGraphInfoRetriever(subgraphClient as TheGraphClient, this.currencyManager)
       : NearChains.isChainSupported(paymentChain) && this.network
       ? new NearInfoRetriever(subgraphClient as TheGraphClient<CurrencyTypes.NearChainName>)
+      : TronChains.isChainSupported(paymentChain)
+      ? new TronInfoRetriever(subgraphClient as TheGraphClient<CurrencyTypes.TronChainName>)
       : undefined;
     if (!graphInfoRetriever) {
       throw new Error(

packages/payment-processor/src/index.ts

@@ -28,6 +28,8 @@ export * from './payment/encoder-approval';
 export * as Escrow from './payment/erc20-escrow-payment';
 export * from './payment/prepared-transaction';
 export * from './payment/utils-near';
+export * from './payment/utils-tron';
+export * from './payment/tron-fee-proxy';
 export * from './payment/single-request-forwarder';
 export * from './payment/erc20-recurring-payment-proxy';
 export * from './payment/erc20-commerce-escrow-wrapper';

packages/payment-processor/src/payment/tron-fee-proxy.ts

@@ -0,0 +1,191 @@
+import { BigNumber, BigNumberish } from 'ethers';
+import { ClientTypes, ExtensionTypes } from '@requestnetwork/types';
+import { TronChains } from '@requestnetwork/currency';
+
+import { getAmountToPay, getRequestPaymentValues, validateRequest } from './utils';
+import {
+  TronWeb,
+  ITronTransactionCallback,
+  processTronFeeProxyPayment,
+  approveTrc20,
+  getTronAllowance,
+  isTronAccountSolvent,
+  isValidTronAddress,
+  getERC20FeeProxyAddress,
+} from './utils-tron';
+import { validatePaymentReference } from '../utils/validation';
+
+/**
+ * Checks if the TronWeb instance has sufficient allowance for the payment
+ */
+export async function hasSufficientTronAllowance(
+  request: ClientTypes.IRequestData,
+  tronWeb: TronWeb,
+  amount?: BigNumberish,
+): Promise<boolean> {
+  const network = request.currencyInfo.network;
+  if (!network || !TronChains.isChainSupported(network)) {
+    throw new Error('Request currency network is not a supported Tron network');
+  }
+  TronChains.assertChainSupported(network);
+
+  const tokenAddress = request.currencyInfo.value;
+  const { feeAmount } = getRequestPaymentValues(request);
+  const amountToPay = getAmountToPay(request, amount);
+  const totalAmount = BigNumber.from(amountToPay).add(feeAmount || 0);
+
+  const allowance = await getTronAllowance(tronWeb, tokenAddress, network);
+  return allowance.gte(totalAmount);
+}
+
+/**
+ * Checks if the payer has sufficient TRC20 token balance
+ */
+export async function hasSufficientTronBalance(
+  request: ClientTypes.IRequestData,
+  tronWeb: TronWeb,
+  amount?: BigNumberish,
+): Promise<boolean> {
+  const tokenAddress = request.currencyInfo.value;
+  const { feeAmount } = getRequestPaymentValues(request);
+  const amountToPay = getAmountToPay(request, amount);
+  const totalAmount = BigNumber.from(amountToPay).add(feeAmount || 0);
+
+  return isTronAccountSolvent(tronWeb, tokenAddress, totalAmount);
+}
+
+/**
+ * Approves the ERC20FeeProxy contract to spend TRC20 tokens for a request payment
+ */
+export async function approveTronFeeProxyRequest(
+  request: ClientTypes.IRequestData,
+  tronWeb: TronWeb,
+  amount?: BigNumberish,
+  callback?: ITronTransactionCallback,
+): Promise<string> {
+  const network = request.currencyInfo.network;
+  if (!network || !TronChains.isChainSupported(network)) {
+    throw new Error('Request currency network is not a supported Tron network');
+  }
+  TronChains.assertChainSupported(network);
+
+  validateRequest(request, ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT);
+
+  const tokenAddress = request.currencyInfo.value;
+  const { feeAmount } = getRequestPaymentValues(request);
+  const amountToPay = getAmountToPay(request, amount);
+  const totalAmount = BigNumber.from(amountToPay).add(feeAmount || 0);
+
+  return approveTrc20(tronWeb, tokenAddress, network, totalAmount, callback);
+}
+
+/**
+ * Processes a TRC20 fee proxy payment for a Request.
+ *
+ * @param request The request to pay
+ * @param tronWeb The TronWeb instance connected to the payer's wallet
+ * @param amount Optionally, the amount to pay. Defaults to remaining amount of the request.
+ * @param feeAmount Optionally, the fee amount to pay. Defaults to the fee amount from the request.
+ * @param callback Optional callbacks for transaction events
+ * @returns The transaction hash
+ */
+export async function payTronFeeProxyRequest(
+  request: ClientTypes.IRequestData,
+  tronWeb: TronWeb,
+  amount?: BigNumberish,
+  feeAmount?: BigNumberish,
+  callback?: ITronTransactionCallback,
+): Promise<string> {
+  const network = request.currencyInfo.network;
+  if (!network || !TronChains.isChainSupported(network)) {
+    throw new Error('Request currency network is not a supported Tron network');
+  }
+  TronChains.assertChainSupported(network);
+
+  validateRequest(request, ExtensionTypes.PAYMENT_NETWORK_ID.ERC20_FEE_PROXY_CONTRACT);
+
+  const {
+    paymentReference,
+    paymentAddress,
+    feeAddress,
+    feeAmount: requestFeeAmount,
+  } = getRequestPaymentValues(request);
+
+  validatePaymentReference(paymentReference);
+
+  if (!isValidTronAddress(paymentAddress)) {
+    throw new Error(`Invalid Tron payment address: ${paymentAddress}`);
+  }
+
+  const tokenAddress = request.currencyInfo.value;
+  const amountToPay = getAmountToPay(request, amount);
+  const feeToPay = feeAmount ?? requestFeeAmount ?? '0';
+
+  // Check allowance
+  const totalAmount = BigNumber.from(amountToPay).add(feeToPay);
+  const allowance = await getTronAllowance(tronWeb, tokenAddress, network);
+
+  if (allowance.lt(totalAmount)) {
+    throw new Error(
+      `Insufficient TRC20 allowance. Required: ${totalAmount.toString()}, Available: ${allowance.toString()}. ` +
+        `Please call approveTronFeeProxyRequest first.`,
+    );
+  }
+
+  // Check balance
+  const hasSufficientBalance = await isTronAccountSolvent(tronWeb, tokenAddress, totalAmount);
+  if (!hasSufficientBalance) {
+    throw new Error('Insufficient TRC20 token balance for payment');
+  }
+
+  return processTronFeeProxyPayment(
+    tronWeb,
+    network,
+    tokenAddress,
+    paymentAddress,
+    amountToPay,
+    paymentReference,
+    feeToPay,
+    feeAddress || tronWeb.defaultAddress.base58,
+    callback,
+  );
+}
+
+/**
+ * Gets information needed to pay a Tron request
+ */
+export function getTronPaymentInfo(
+  request: ClientTypes.IRequestData,
+  amount?: BigNumberish,
+): {
+  proxyAddress: string;
+  tokenAddress: string;
+  paymentAddress: string;
+  amount: string;
+  paymentReference: string;
+  feeAmount: string;
+  feeAddress: string;
+} {
+  const network = request.currencyInfo.network;
+  if (!network || !TronChains.isChainSupported(network)) {
+    throw new Error('Request currency network is not a supported Tron network');
+  }
+  TronChains.assertChainSupported(network);
+
+  const { paymentReference, paymentAddress, feeAddress, feeAmount } =
+    getRequestPaymentValues(request);
+
+  const tokenAddress = request.currencyInfo.value;
+  const amountToPay = getAmountToPay(request, amount);
+  const proxyAddress = getERC20FeeProxyAddress(network);
+
+  return {
+    proxyAddress,
+    tokenAddress,
+    paymentAddress,
+    amount: amountToPay.toString(),
+    paymentReference: paymentReference ?? '',
+    feeAmount: (feeAmount || '0').toString(),
+    feeAddress: feeAddress ?? '',
+  };
+}