feat: init

Author: foodaka

package.json

@@ -33,7 +33,7 @@
   "dependencies": {
     "@aave/contract-helpers": "1.36.1",
     "@aave/math-utils": "1.36.1",
-    "@aave/react": "^0.4.0",
+    "@aave/react": "canary",
     "@amplitude/analytics-browser": "^2.13.0",
     "@bgd-labs/aave-address-book": "^4.25.1",
     "@cowprotocol/app-data": "^3.1.0",
@@ -156,4 +156,4 @@
     "budgetPercentIncreaseRed": 20,
     "showDetails": true
   }
-}
+}

src/components/transactions/ClaimRewards/ClaimRewardsActions.tsx

@@ -1,10 +1,16 @@
-import { ProtocolAction } from '@aave/contract-helpers';
+import { ProtocolAction, EthereumTransactionTypeExtended, eEthereumTxType } from '@aave/contract-helpers';
 import { Trans } from '@lingui/macro';
+import { utils } from 'ethers';
 import { Reward } from 'src/helpers/types';
 import { useTransactionHandler } from 'src/helpers/useTransactionHandler';
 import { useAppDataContext } from 'src/hooks/app-data-provider/useAppDataProvider';
 import { useRootStore } from 'src/store/root';
 
+import { useMeritClaimRewards } from '@aave/react';
+import { useShallow } from 'zustand/shallow';
+import { useWeb3Context } from 'src/libs/hooks/useWeb3Context';
+
+
 import { TxActionsWrapper } from '../TxActionsWrapper';
 
 export type ClaimRewardsActionsProps = {
@@ -21,6 +27,15 @@ export const ClaimRewardsActions = ({
   const claimRewards = useRootStore((state) => state.claimRewards);
   const { reserves } = useAppDataContext();
 
+  const { currentAccount } = useWeb3Context();
+
+
+  const [currentMarketData] = useRootStore(
+    useShallow((store) => [store.currentMarketData])
+  );
+
+  const { data: meritClaimRewards } = useMeritClaimRewards({ user: currentAccount, chainId: currentMarketData.chainId });
+
   const { action, loadingTxns, mainTxState, requiresApproval } = useTransactionHandler({
     protocolAction: ProtocolAction.claimRewards,
     eventTxInfo: {
@@ -29,12 +44,130 @@ export const ClaimRewardsActions = ({
     },
     tryPermit: false,
     handleGetTxns: async () => {
-      return claimRewards({ isWrongNetwork, blocked, selectedReward, formattedReserves: reserves });
+      // Check if we need to claim both protocol and merit rewards
+      const isClaimingAll = selectedReward.symbol === 'all';
+      const isClaimingMeritAll = selectedReward.symbol === 'merit-all';
+      const isClaimingProtocolAll = selectedReward.symbol === 'protocol-all';
+      const hasProtocolRewards = selectedReward.incentiveControllerAddress !== 'MERIT_REWARD';
+      const hasMeritRewards = meritClaimRewards?.rewards && meritClaimRewards.rewards.length > 0;
+      const isIndividualProtocolReward = hasProtocolRewards && !isClaimingAll && !isClaimingProtocolAll && !isClaimingMeritAll;
+
+      // Use simple approach for individual protocol rewards (most common case)
+      if (isIndividualProtocolReward) {
+        return claimRewards({ isWrongNetwork, blocked, selectedReward, formattedReserves: reserves });
+      }
+
+      // Use complex multicall logic only when needed
+      if (isClaimingAll && hasProtocolRewards && hasMeritRewards) {
+        // Get protocol rewards transaction
+        const protocolTxns = await claimRewards({
+          isWrongNetwork,
+          blocked,
+          selectedReward,
+          formattedReserves: reserves
+        });
+
+        // Create multicall transaction that includes both protocol and merit claims
+        if (!meritClaimRewards?.transaction) {
+          throw new Error('Merit rewards transaction not available');
+        }
+        const multicallTx = await createMulticallTransaction(protocolTxns, meritClaimRewards.transaction);
+
+        // Check if there are any approval transactions that need to be handled separately
+        const approvalTxns = protocolTxns.filter(tx => tx.txType === 'ERC20_APPROVAL');
+
+        return approvalTxns.length > 0 ? [...approvalTxns, multicallTx] : [multicallTx];
+      } else if ((isClaimingAll && !hasProtocolRewards && hasMeritRewards) || isClaimingMeritAll) {
+        // Only merit rewards - use merit transaction directly
+        if (!meritClaimRewards?.transaction) {
+          throw new Error('Merit rewards transaction not available');
+        }
+        return [convertMeritTransactionToEthereum(meritClaimRewards.transaction)];
+      } else {
+        // Protocol-all or other cases - use existing protocol logic
+        return claimRewards({ isWrongNetwork, blocked, selectedReward, formattedReserves: reserves });
+      }
     },
     skip: Object.keys(selectedReward).length === 0 || blocked,
-    deps: [selectedReward],
+    deps: [selectedReward, meritClaimRewards],
   });
 
+  // Helper function to create multicall transaction
+  const createMulticallTransaction = async (
+    protocolTxns: EthereumTransactionTypeExtended[],
+    meritTransaction: any
+  ): Promise<EthereumTransactionTypeExtended> => {
+    // Multicall3 contract address (same across chains)
+    const multicallAddress = '0xcA11bde05977b3631167028862bE2a173976CA11';
+
+    // Prepare calls array for multicall
+    const calls = [];
+
+    // Add protocol transaction calls
+    for (const txExt of protocolTxns) {
+      if (txExt.txType === 'ERC20_APPROVAL') continue; // Skip approvals for multicall
+
+      const tx = await txExt.tx();
+      calls.push({
+        target: tx.to,
+        callData: tx.data,
+        value: tx.value || '0'
+      });
+    }
+
+    // Add merit transaction call
+    calls.push({
+      target: meritTransaction.to,
+      callData: meritTransaction.data,
+      value: meritTransaction.value || '0'
+    });
+
+    // Encode multicall
+    const multicallInterface = new utils.Interface([
+      'function aggregate3Value((address target, bool allowFailure, uint256 value, bytes callData)[] calls) payable returns ((bool success, bytes returnData)[])'
+    ]);
+
+    const callsWithFailure = calls.map(call => [
+      call.target,
+      false, // allowFailure = false
+      call.value,
+      call.callData
+    ]);
+
+    const data = multicallInterface.encodeFunctionData('aggregate3Value', [callsWithFailure]);
+
+    return {
+      txType: eEthereumTxType.DLP_ACTION,
+      tx: async () => ({
+        to: multicallAddress,
+        from: currentAccount,
+        data,
+        value: '0',
+      }),
+      gas: async () => ({
+        gasLimit: '800000', // Conservative gas limit for multicall
+        gasPrice: '0',
+      }),
+    };
+  };
+
+  // Helper function to convert merit transaction to Ethereum format
+  const convertMeritTransactionToEthereum = (meritTx: any): EthereumTransactionTypeExtended => {
+    return {
+      txType: eEthereumTxType.DLP_ACTION,
+      tx: async () => ({
+        to: meritTx.to,
+        from: meritTx.from || currentAccount,
+        data: meritTx.data,
+        value: meritTx.value || '0',
+      }),
+      gas: async () => ({
+        gasLimit: '400000', // Conservative gas limit for merit only
+        gasPrice: '0',
+      }),
+    };
+  };
+
   return (
     <TxActionsWrapper
       requiresApproval={requiresApproval}
@@ -45,6 +178,10 @@ export const ClaimRewardsActions = ({
       actionText={
         selectedReward.symbol === 'all' ? (
           <Trans>Claim all</Trans>
+        ) : selectedReward.symbol === 'merit-all' ? (
+          <Trans>Claim all merit rewards</Trans>
+        ) : selectedReward.symbol === 'protocol-all' ? (
+          <Trans>Claim all protocol rewards</Trans>
         ) : (
           <Trans>Claim {selectedReward.symbol}</Trans>
         )