feat(earn): prepare transactions for supply when gas fee is covered

src/earn/prepareTransactions.test.ts

@@ -7,7 +7,7 @@ import {
   prepareSupplyTransactions,
   prepareWithdrawAndClaimTransactions,
 } from 'src/earn/prepareTransactions'
-import { getDynamicConfigParams } from 'src/statsig'
+import { getDynamicConfigParams, getFeatureGate } from 'src/statsig'
 import { StatsigDynamicConfigs } from 'src/statsig/types'
 import { TokenBalance } from 'src/tokens/slice'
 import { Network, NetworkId } from 'src/transactions/types'
@@ -63,10 +63,11 @@ describe('prepareTransactions', () => {
     jest.mocked(encodeFunctionData).mockReturnValue('0xencodedData')
     jest.mocked(getDynamicConfigParams).mockImplementation(({ configName, defaultValues }) => {
       if (configName === StatsigDynamicConfigs.EARN_STABLECOIN_CONFIG) {
-        return { ...defaultValues, depositGasPadding: 100 }
+        return { ...defaultValues, depositGasPadding: 100, approveGasPadding: 200 }
       }
       return defaultValues
     })
+    jest.mocked(getFeatureGate).mockReturnValue(false)
   })
 
   describe('prepareSupplyTransactions', () => {
@@ -146,6 +147,84 @@ describe('prepareTransactions', () => {
         feeCurrencies: [mockFeeCurrency],
         spendToken: mockToken,
         spendTokenAmount: new BigNumber(5),
+        isGasSubsidized: false,
+      })
+    })
+    it('prepares fees from the cloud function for approve and supply when subsidizing gas fees', async () => {
+      mockFetch.mockResponseOnce(
+        JSON.stringify({
+          status: 'OK',
+          simulatedTransactions: [
+            {
+              status: 'success',
+              blockNumber: '1',
+              gasNeeded: 3000,
+              gasUsed: 2800,
+              gasPrice: '1',
+            },
+            {
+              status: 'success',
+              blockNumber: '1',
+              gasNeeded: 50000,
+              gasUsed: 49800,
+              gasPrice: '1',
+            },
+          ],
+        })
+      )
+      jest.mocked(getFeatureGate).mockReturnValue(true)
+
+      const result = await prepareSupplyTransactions({
+        amount: '5',
+        token: mockToken,
+        walletAddress: '0x1234',
+        feeCurrencies: [mockFeeCurrency],
+        poolContractAddress: '0x5678',
+      })
+
+      const expectedTransactions = [
+        {
+          from: '0x1234',
+          to: mockTokenAddress,
+          data: '0xencodedData',
+          gas: BigInt(3200),
+          _estimatedGasUse: BigInt(2800),
+        },
+        {
+          from: '0x1234',
+          to: '0x5678',
+          data: '0xencodedData',
+          gas: BigInt(50100),
+          _estimatedGasUse: BigInt(49800),
+        },
+      ]
+      expect(result).toEqual({
+        type: 'possible',
+        feeCurrency: mockFeeCurrency,
+        transactions: expectedTransactions,
+      })
+      expect(publicClient[Network.Arbitrum].readContract).toHaveBeenCalledWith({
+        address: mockTokenAddress,
+        abi: erc20.abi,
+        functionName: 'allowance',
+        args: ['0x1234', '0x5678'],
+      })
+      expect(encodeFunctionData).toHaveBeenNthCalledWith(1, {
+        abi: erc20.abi,
+        functionName: 'approve',
+        args: ['0x5678', BigInt(5e6)],
+      })
+      expect(encodeFunctionData).toHaveBeenNthCalledWith(2, {
+        abi: aavePool,
+        functionName: 'supply',
+        args: [mockTokenAddress, BigInt(5e6), '0x1234', 0],
+      })
+      expect(prepareTransactions).toHaveBeenCalledWith({
+        baseTransactions: expectedTransactions,
+        feeCurrencies: [mockFeeCurrency],
+        spendToken: mockToken,
+        spendTokenAmount: new BigNumber(5),
+        isGasSubsidized: true,
       })
     })
 
@@ -204,6 +283,7 @@ describe('prepareTransactions', () => {
         feeCurrencies: [mockFeeCurrency],
         spendToken: mockToken,
         spendTokenAmount: new BigNumber(5),
+        isGasSubsidized: false,
       })
     })
 

src/earn/prepareTransactions.ts

@@ -4,9 +4,9 @@
 import aavePool from 'src/abis/AavePoolV3'
 import erc20 from 'src/abis/IERC20'
 import { RewardsInfo } from 'src/earn/types'
-import { getDynamicConfigParams } from 'src/statsig'
+import { getDynamicConfigParams, getFeatureGate } from 'src/statsig'
 import { DynamicConfigs } from 'src/statsig/constants'
-import { StatsigDynamicConfigs } from 'src/statsig/types'
+import { StatsigDynamicConfigs, StatsigFeatureGates } from 'src/statsig/types'
 import { TokenBalance } from 'src/tokens/slice'
 import Logger from 'src/utils/Logger'
 import { ensureError } from 'src/utils/ensureError'
@@ -122,7 +122,7 @@
     )
   }
 
-  const { depositGasPadding } = getDynamicConfigParams(
+  const { depositGasPadding, approveGasPadding } = getDynamicConfigParams(
     DynamicConfigs[StatsigDynamicConfigs.EARN_STABLECOIN_CONFIG]
   )
 
@@ -131,11 +131,25 @@
   )
   baseTransactions[baseTransactions.length - 1]._estimatedGasUse = BigInt(supplySimulatedTx.gasUsed)
 
+  const isGasSubsidized = getFeatureGate(StatsigFeatureGates.SUBSIDIZE_STABLECOIN_EARN_GAS_FEES)
+  if (isGasSubsidized && baseTransactions.length > 1) {
+    // extract fee of the approve transaction and set gas fields
+    const approveSimulatedTx = simulatedTransactions[0]
+    if (approveSimulatedTx.status !== 'success') {
+      throw new Error(
+        `Failed to simulate approve transaction. response: ${JSON.stringify(simulatedTransactions)}`
+      )
+    }
+    baseTransactions[0].gas = BigInt(approveSimulatedTx.gasNeeded) + BigInt(approveGasPadding)
+    baseTransactions[0]._estimatedGasUse = BigInt(approveSimulatedTx.gasUsed)
+  }
+
   return prepareTransactions({
     feeCurrencies,
     baseTransactions,
     spendToken: token,
     spendTokenAmount: new BigNumber(amount),
+    isGasSubsidized,
   })
 }
 

src/statsig/constants.ts

@@ -143,6 +143,7 @@ export const DynamicConfigs = {
       providerLogoUrl: '',
       providerTermsAndConditionsUrl: '',
       depositGasPadding: 0,
+      approveGasPadding: 0,
       moreAavePoolsUrl: '',
     },
   },

src/viem/prepareTransactions.test.ts

@@ -198,6 +198,47 @@ describe('prepareTransactions module', () => {
         feeCurrencies: mockFeeCurrencies,
       })
     })
+    it("returns a 'possible' result when the balances for feeCurrencies are too low to cover the fee but isGasSubsidized is true", async () => {
+      mocked(estimateFeesPerGas).mockResolvedValue({
+        maxFeePerGas: BigInt(100),
+        maxPriorityFeePerGas: BigInt(2),
+        baseFeePerGas: BigInt(50),
+      })
+      mocked(estimateGas).mockResolvedValue(BigInt(1_000))
+
+      // max gas fee is 10 * 10k = 100k units, too high for either fee currency
+
+      const result = await prepareTransactions({
+        feeCurrencies: mockFeeCurrencies,
+        spendToken: mockSpendToken,
+        spendTokenAmount: new BigNumber(45_000),
+        decreasedAmountGasFeeMultiplier: 1,
+        baseTransactions: [
+          {
+            from: '0xfrom' as Address,
+            to: '0xto' as Address,
+            data: '0xdata',
+          },
+        ],
+        isGasSubsidized: true,
+      })
+      expect(result).toStrictEqual({
+        type: 'possible',
+        feeCurrency: mockFeeCurrencies[0],
+        transactions: [
+          {
+            from: '0xfrom',
+            to: '0xto',
+            data: '0xdata',
+
+            gas: BigInt(1000),
+            maxFeePerGas: BigInt(100),
+            maxPriorityFeePerGas: BigInt(2),
+            _baseFeePerGas: BigInt(50),
+          },
+        ],
+      })
+    })
     it("returns a 'not-enough-balance-for-gas' result when gas estimation throws error due to insufficient funds", async () => {
       mocked(estimateFeesPerGas).mockResolvedValue({
         maxFeePerGas: BigInt(100),
@@ -304,6 +345,46 @@ describe('prepareTransactions module', () => {
         decreasedSpendAmount: new BigNumber(4.35), // 70.0 balance minus maxGasFee
       })
     })
+    it("returns a 'possible' result when spending the exact max amount of a feeCurrency, and no other feeCurrency has enough balance to pay for the fee and isGasSubsidized is true", async () => {
+      mocked(estimateFeesPerGas).mockResolvedValue({
+        maxFeePerGas: BigInt(1),
+        maxPriorityFeePerGas: BigInt(2),
+        baseFeePerGas: BigInt(1),
+      })
+
+      const result = await prepareTransactions({
+        feeCurrencies: mockFeeCurrencies,
+        spendToken: mockFeeCurrencies[1],
+        spendTokenAmount: mockFeeCurrencies[1].balance.shiftedBy(mockFeeCurrencies[1].decimals),
+        decreasedAmountGasFeeMultiplier: 1.01,
+        isGasSubsidized: true,
+        baseTransactions: [
+          {
+            from: '0xfrom' as Address,
+            to: '0xto' as Address,
+            data: '0xdata',
+            _estimatedGasUse: BigInt(50),
+            gas: BigInt(15_000),
+          },
+        ],
+      })
+      expect(result).toStrictEqual({
+        type: 'possible',
+        feeCurrency: mockFeeCurrencies[0],
+        transactions: [
+          {
+            _baseFeePerGas: BigInt(1),
+            _estimatedGasUse: BigInt(50),
+            from: '0xfrom',
+            gas: BigInt(15_000),
+            maxFeePerGas: BigInt(1),
+            maxPriorityFeePerGas: BigInt(2),
+            to: '0xto',
+            data: '0xdata',
+          },
+        ],
+      })
+    })
     it("returns a 'need-decrease-spend-amount-for-gas' result when spending close to the max amount of a feeCurrency, and no other feeCurrency has enough balance to pay for the fee", async () => {
       mocked(estimateFeesPerGas).mockResolvedValue({
         maxFeePerGas: BigInt(1),

src/viem/prepareTransactions.ts

@@ -261,6 +261,7 @@ export async function tryEstimateTransactions(
  * @param decreasedAmountGasFeeMultiplier
  * @param baseTransactions
  * @param throwOnSpendTokenAmountExceedsBalance
+ * @param isGasSubsidized - This flag should only be set to true if all of the baseTransactions already have gas estimates, aka the 'gas' and '_estimatedGasUse' fields have been manually set
  */
 export async function prepareTransactions({
   feeCurrencies,
@@ -269,13 +270,15 @@ export async function prepareTransactions({
   decreasedAmountGasFeeMultiplier = 1,
   baseTransactions,
   throwOnSpendTokenAmountExceedsBalance = true,
+  isGasSubsidized = false,
 }: {
   feeCurrencies: TokenBalance[]
   spendToken?: TokenBalance
   spendTokenAmount?: BigNumber
   decreasedAmountGasFeeMultiplier?: number
   baseTransactions: (TransactionRequest & { gas?: bigint })[]
   throwOnSpendTokenAmountExceedsBalance?: boolean
+  isGasSubsidized?: boolean
 }): Promise<PreparedTransactionsResult> {
   if (!spendToken && spendTokenAmount.isGreaterThan(0)) {
     throw new Error(
@@ -299,7 +302,7 @@ export async function prepareTransactions({
     estimatedGasFeeInDecimal: BigNumber
   }> = []
   for (const feeCurrency of feeCurrencies) {
-    if (feeCurrency.balance.isLessThanOrEqualTo(0)) {
+    if (feeCurrency.balance.isLessThanOrEqualTo(0) && !isGasSubsidized) {
       // No balance, try next fee currency
       continue
     }
@@ -314,15 +317,16 @@ export async function prepareTransactions({
     const estimatedGasFee = getEstimatedGasFee(estimatedTransactions)
     const estimatedGasFeeInDecimal = estimatedGasFee?.shiftedBy(-feeDecimals)
     gasFees.push({ feeCurrency, maxGasFeeInDecimal, estimatedGasFeeInDecimal })
-    if (maxGasFeeInDecimal.isGreaterThan(feeCurrency.balance)) {
+    if (maxGasFeeInDecimal.isGreaterThan(feeCurrency.balance) && !isGasSubsidized) {
       // Not enough balance to pay for gas, try next fee currency
       continue
     }
     const spendAmountDecimal = spendTokenAmount.shiftedBy(-(spendToken?.decimals ?? 0))
     if (
       spendToken &&
       spendToken.tokenId === feeCurrency.tokenId &&
-      spendAmountDecimal.plus(maxGasFeeInDecimal).isGreaterThan(spendToken.balance)
+      spendAmountDecimal.plus(maxGasFeeInDecimal).isGreaterThan(spendToken.balance) &&
+      !isGasSubsidized
     ) {
       // Not enough balance to pay for gas, try next fee currency
       continue