fix: flashloan fee calculation now matches aave's (#622)

* fix: flashloan fee calculation now matches aave's

* fix: pr comments

* fix: implement ceil rounding for flash loan fee calculations (#623)

- Fixed calculateFlashLoanAmounts to use ceil rounding (round up on any remainder)
- This ensures flash loan fees are never undercharged due to truncation
- Removed incorrect 100x scaling that was using BASIS_POINTS_SCALE
- Now using Aave's PERCENT_SCALE (10000) directly where 100% = 10000 bps
- Added 7 comprehensive unit tests covering edge cases:
  - Very small amounts (1 wei)
  - Exact division with no remainder
  - Small remainders
  - Medium DeFi amounts (ETH scale)
  - Large amounts (100+ ETH)
  - Maximum uint256-like amounts
  - Fractional percentages with remainders
- All 99 tests passing

* add opt-out flag for quote adjustments in getOrderToSign (#624)

* feat: add opt-out flag for quote adjustments in getOrderToSign

* override order to sign from params (#626)

* use applyQuote boolean instead of overriding orderToSign (#628)

* fix: pr review

---------

Co-authored-by: Martin Grabina <[email protected]>

* fix: lint

* fix: more pipeline fixes

---------

Co-authored-by: Martin Grabina <[email protected]>

Author: carlos-cow

packages/contracts-ts/src/generated/packageVersion.ts

@@ -1,3 +1,3 @@
 // Automatically generated by the script in scripts/version.js
 // Do not edit this file manually
-export const CONTRACTS_PKG_VERSION = '0.4.0';
+export const CONTRACTS_PKG_VERSION = '0.4.1';

packages/flash-loans/src/aave/AaveCollateralSwapSdk.test.ts

@@ -456,9 +456,9 @@ adapterNames.forEach((adapterName) => {
     describe('calculateFlashLoanAmounts', () => {
       test('should calculate correct flash loan fee amount', () => {
         const sellAmount = BigInt('1000000000000000000') // 1 ETH
-        const flashLoanFeePercent = 0.05 // 0.05%
+        const flashLoanFeeBps = 5 // 0.05%
 
-        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeePercent })
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
 
         // 0.05% of 1 ETH = 0.0005 ETH = 500000000000000 wei
         expect(result.flashLoanFeeAmount).toBe(BigInt('500000000000000'))
@@ -467,30 +467,30 @@ adapterNames.forEach((adapterName) => {
 
       test('should handle zero flash loan fee', () => {
         const sellAmount = BigInt('1000000000000000000') // 1 ETH
-        const flashLoanFeePercent = 0
+        const flashLoanFeeBps = 0
 
-        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeePercent })
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
 
         expect(result.flashLoanFeeAmount).toBe(BigInt('0'))
         expect(result.sellAmountToSign).toBe(sellAmount)
       })
 
       test('should calculate fee for small amounts', () => {
         const sellAmount = BigInt('100') // Very small amount
-        const flashLoanFeePercent = 0.09 // 0.09%
+        const flashLoanFeeBps = 9 // 0.09%
 
-        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeePercent })
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
 
-        // Fee should be 0 due to rounding down
-        expect(result.flashLoanFeeAmount).toBe(BigInt('0'))
-        expect(result.sellAmountToSign).toBe(sellAmount)
+        // 100 * 9 / 10000 = 0.09, ceil rounds up to 1
+        expect(result.flashLoanFeeAmount).toBe(BigInt('1'))
+        expect(result.sellAmountToSign).toBe(BigInt('99'))
       })
 
       test('should calculate fee for large percentage', () => {
         const sellAmount = BigInt('10000000000000000000') // 10 ETH
-        const flashLoanFeePercent = 1.0 // 1%
+        const flashLoanFeeBps = 100 // 1%
 
-        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeePercent })
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
 
         // 1% of 10 ETH = 0.1 ETH = 100000000000000000 wei
         expect(result.flashLoanFeeAmount).toBe(BigInt('100000000000000000'))
@@ -499,12 +499,119 @@ adapterNames.forEach((adapterName) => {
 
       test('should handle fractional percentages precisely', () => {
         const sellAmount = BigInt('1000000000000000000') // 1 ETH
-        const flashLoanFeePercent = 0.0123 // 0.0123%
+        const flashLoanFeeBps = 123 // 1.23% (123 basis points)
+
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
+
+        // 1000000000000000000 * 123 / 10000 = 12300000000000000 (exact)
+        expect(result.flashLoanFeeAmount).toBe(BigInt('12300000000000000'))
+        expect(result.sellAmountToSign).toBe(BigInt('987700000000000000'))
+      })
+
+      test('should round up for very small amounts with tiny remainders', () => {
+        // Test edge case: amount so small that fee rounds to 1 wei
+        const sellAmount = BigInt('1') // 1 wei
+        const flashLoanFeeBps = 5 // 0.05%
+
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
+
+        // 1 * 5 / 10000 = 0.0005, should round up to 1
+        expect(result.flashLoanFeeAmount).toBe(BigInt('1'))
+        expect(result.sellAmountToSign).toBe(BigInt('0'))
+      })
+
+      test('should handle exact division with no remainder', () => {
+        // Test case where division is exact (no rounding needed)
+        const sellAmount = BigInt('10000') // 10000 wei
+        const flashLoanFeeBps = 1 // 0.01%
+
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
+
+        // 10000 * 1 / 10000 = 1 (exact)
+        expect(result.flashLoanFeeAmount).toBe(BigInt('1'))
+        expect(result.sellAmountToSign).toBe(BigInt('9999'))
+      })
+
+      test('should round up for small remainder', () => {
+        // Test with remainder = 1
+        const sellAmount = BigInt('10001')
+        const flashLoanFeeBps = 1 // 0.01%
+
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
+
+        // 10001 * 1 / 10000 = 1.0001, should round up to 2
+        expect(result.flashLoanFeeAmount).toBe(BigInt('2'))
+        expect(result.sellAmountToSign).toBe(BigInt('9999'))
+      })
+
+      test('should round up for medium amounts', () => {
+        // Test with typical DeFi amounts
+        const sellAmount = BigInt('1500000000000000000') // 1.5 ETH
+        const flashLoanFeeBps = 9 // 0.09%
+
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
+
+        // 1.5 ETH * 0.09% = 0.00135 ETH = 1350000000000000 wei
+        // 1500000000000000000 * 9 / 10000 = 1350000000000000 (exact)
+        expect(result.flashLoanFeeAmount).toBe(BigInt('1350000000000000'))
+        expect(result.sellAmountToSign).toBe(BigInt('1498650000000000000'))
+      })
+
+      test('should round up for large amounts with small remainder', () => {
+        // Test with very large amounts (100 ETH)
+        const sellAmount = BigInt('100000000000000000001') // 100 ETH + 1 wei
+        const flashLoanFeeBps = 5 // 0.05%
+
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
+
+        // 100000000000000000001 * 5 / 10000 = 50000000000000000.0005
+        // Should round up to 50000000000000001
+        expect(result.flashLoanFeeAmount).toBe(BigInt('50000000000000001'))
+        expect(result.sellAmountToSign).toBe(BigInt('99950000000000000000'))
+      })
+
+      test('should handle maximum uint256-like amounts', () => {
+        // Test with very large numbers (close to max supply of common tokens)
+        const sellAmount = BigInt('1000000000000000000000000') // 1 million tokens with 18 decimals
+        const flashLoanFeeBps = 10 // 0.1%
+
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
+
+        // 1000000000000000000000000 * 10 / 10000 = 1000000000000000000000 (exact)
+        expect(result.flashLoanFeeAmount).toBe(BigInt('1000000000000000000000'))
+        expect(result.sellAmountToSign).toBe(BigInt('999000000000000000000000'))
+      })
+
+      test('should round up with fractional percentage that creates remainder', () => {
+        // Test with percentage that guarantees a remainder
+        const sellAmount = BigInt('123456789')
+        const flashLoanFeeBps = 7 // 0.07%
+
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
+
+        // 123456789 * 7 / 10000 = 86419.7523, should round up to 86420
+        expect(result.flashLoanFeeAmount).toBe(BigInt('86420'))
+        expect(result.sellAmountToSign).toBe(BigInt('123370369'))
+      })
+
+      test('should match Aave PercentageMath.percentMul() rounding behavior', () => {
+        // This test verifies we use ceil rounding (round up on any remainder)
+        // Our implementation: if (remainder > 0) round up by 1
+
+        const sellAmount = BigInt('2813982695824406449')
+        const flashLoanFeeBps = 5 // 0.05%
+
+        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps })
 
-        const result = flashLoanSdk.calculateFlashLoanAmounts({ sellAmount, flashLoanFeePercent })
+        // Manual calculation:
+        // bps = 0.05 * 100 = 5
+        // product = 2813982695824406449 * 5 = 14069913479122032245
+        // quotient = 14069913479122032245 / 10000 = 1406991347912203 (truncated)
+        // remainder = 14069913479122032245 % 10000 = 2245
+        // Since remainder > 0, round up: 1406991347912203 + 1 = 1406991347912204
 
-        expect(result.flashLoanFeeAmount).toBe(BigInt('123000000000000'))
-        expect(result.sellAmountToSign).toBe(BigInt('999877000000000000'))
+        expect(result.flashLoanFeeAmount).toBe(BigInt('1406991347912204'))
+        expect(result.sellAmountToSign).toBe(BigInt('2813982695824406449') - BigInt('1406991347912204'))
       })
     })
 

packages/flash-loans/src/aave/AaveCollateralSwapSdk.ts

@@ -142,7 +142,10 @@ export class AaveCollateralSwapSdk {
       throw new Error(`flashLoanFeePercent must be between 0 and 100, got: ${flashLoanFeePercent}`)
     }
 
-    const { flashLoanFeeAmount, sellAmountToSign } = this.calculateFlashLoanAmounts({ flashLoanFeePercent, sellAmount })
+    const { flashLoanFeeAmount, sellAmountToSign } = this.calculateFlashLoanAmounts({
+      flashLoanFeeBps: flashLoanFeePercent * 100, // Convert percentage (0.05 for 0.05%) to bps (5)
+      sellAmount,
+    })
 
     // Omit validFor because we use validTo instead (it is defined above)
     const { validFor: _, ...restParameters } = tradeParameters
@@ -247,6 +250,7 @@ export class AaveCollateralSwapSdk {
         customEIP1271Signature: (orderToSign: UnsignedOrder, signer: AbstractSigner<Provider>) => {
           return this.adapterEIP1271Signature(chainId, instanceAddress, orderToSign, signer)
         },
+        applyCostsSlippageAndFees: false,
       },
       appData: {
         metadata: {
@@ -365,12 +369,23 @@ export class AaveCollateralSwapSdk {
     }
   }
 
-  calculateFlashLoanAmounts({ sellAmount, flashLoanFeePercent }: { sellAmount: bigint; flashLoanFeePercent: number }): {
+  calculateFlashLoanAmounts({ sellAmount, flashLoanFeeBps }: { sellAmount: bigint; flashLoanFeeBps: number }): {
     flashLoanFeeAmount: bigint
     sellAmountToSign: bigint
   } {
-    const flashLoanFeeAmount =
-      (sellAmount * BigInt(Math.round(flashLoanFeePercent * PERCENT_SCALE))) / BigInt(100 * PERCENT_SCALE)
+    // Match Aave's PercentageMath.percentMul() rounding behavior:
+    // Aave: (value * percentage + HALF_PERCENTAGE_FACTOR) / PERCENTAGE_FACTOR where PERCENTAGE_FACTOR = 10000
+    // flashLoanFeeBps is in basis points (5 for 0.05%, 50 for 0.5%, etc.)
+    const bps = BigInt(Math.round(flashLoanFeeBps))
+    const PERCENTAGE_FACTOR = BigInt(PERCENT_SCALE) // 10000
+
+    // Calculate with Aave's formula, but manually handle rounding since BigInt division truncates
+    const product = sellAmount * bps
+    const quotient = product / PERCENTAGE_FACTOR
+    const remainder = product % PERCENTAGE_FACTOR
+
+    // Round up if remainder is present (ceil behavior for fees)
+    const flashLoanFeeAmount = quotient + (remainder > 0n ? 1n : 0n)
 
     return {
       flashLoanFeeAmount,

packages/flash-loans/src/aave/collateralSwap.integration.test.ts

@@ -101,7 +101,7 @@ describe('AaveFlashLoanIntegration.collateralSwap', () => {
     // The amount is before slippage and partner fee!
     const buyAmount = 18000000n // 18 USDC.e
     const validTo = Math.ceil(Date.now() / 1000) + 10 * 60 // 10m
-    const flashLoanFeePercent = 0.05 // 0.05%
+    const flashLoanFeeBps = 5 // 0.05%
     const slippageBps = 0 // 0.08%
     const partnerFee = {
       volumeBps: 10, // 0.1%
@@ -112,7 +112,7 @@ describe('AaveFlashLoanIntegration.collateralSwap', () => {
     const collateralPermit = undefined
 
     const { flashLoanFeeAmount, sellAmountToSign } = flashLoanSdk.calculateFlashLoanAmounts({
-      flashLoanFeePercent,
+      flashLoanFeeBps,
       sellAmount,
     })
 

packages/flash-loans/src/aave/const.ts

@@ -30,6 +30,11 @@ export const DEFAULT_HOOK_GAS_LIMIT = {
 
 export const PERCENT_SCALE = 10_000
 
+// Constants for flash loan fee calculation matching Aave's PercentageMath.percentMul()
+// Aave uses PERCENTAGE_FACTOR = 10000, but we scale 100× for basis points conversion
+export const BASIS_POINTS_SCALE = BigInt(100 * PERCENT_SCALE) // 1_000_000
+export const HALF_BASIS_POINTS_SCALE = BASIS_POINTS_SCALE / 2n // 500_000
+
 export const DEFAULT_VALIDITY = 10 * 60 // 10 min
 
 export const GAS_ESTIMATION_ADDITION_PERCENT = 10 // 10%

packages/flash-loans/src/aave/debtSwap.integration.test.ts

@@ -49,14 +49,14 @@ describe('AaveFlashLoanIntegration.debtSwap', () => {
     // The amount is before slippage and partner fee!
     const buyAmount = 11000000000000000n // 0.011 GNO
     const validTo = Math.ceil(Date.now() / 1000) + 10 * 60 // 10m
-    const flashLoanFeePercent = 0.05 // 0.05%
+    const flashLoanFeeBps = 5 // 0.05%
 
     // Set true if you sell native token
     const isEthFlow = false
     const collateralPermit = undefined
 
     const { flashLoanFeeAmount, sellAmountToSign } = flashLoanSdk.calculateFlashLoanAmounts({
-      flashLoanFeePercent,
+      flashLoanFeeBps,
       sellAmount,
     })
 
@@ -71,8 +71,6 @@ describe('AaveFlashLoanIntegration.debtSwap', () => {
       validTo,
       slippageBps: 0,
       partnerFee: undefined,
-      //slippageBps,
-      //partnerFee,
     }
 
     const orderToSign = getOrderToSign(

packages/flash-loans/src/aave/repayCollateral.integration.test.ts

@@ -49,14 +49,14 @@ describe('AaveFlashLoanIntegration.repayCollateral', () => {
     // The amount is before slippage and partner fee!
     const buyAmount = 11000000000000000n // 0.011 GNO
     const validTo = Math.ceil(Date.now() / 1000) + 10 * 60 // 10m
-    const flashLoanFeePercent = 0.05 // 0.05%
+    const flashLoanFeeBps = 5 // 0.05%
 
     // Set true if you sell native token
     const isEthFlow = false
     const collateralPermit = undefined
 
     const { flashLoanFeeAmount, sellAmountToSign } = flashLoanSdk.calculateFlashLoanAmounts({
-      flashLoanFeePercent,
+      flashLoanFeeBps,
       sellAmount,
     })
 
@@ -69,7 +69,6 @@ describe('AaveFlashLoanIntegration.repayCollateral', () => {
       buyAmount: buyAmount.toString(),
       kind: OrderKind.BUY,
       validTo,
-      // TODO: BUY orders do not work if you add slippage and/or partnerFee
       slippageBps: 0,
       partnerFee: undefined,
     }

packages/trading/src/getOrderToSign.test.ts

@@ -47,11 +47,7 @@ describe('getOrderToSign', () => {
 
   it('When validTo is set, then should use exact validTo value', () => {
     const exactValidTo = 2524608000 // January 1, 2050 00:00:00 UTC
-    const result = getOrderToSign(
-      params,
-      { ...defaultOrderParams, validTo: exactValidTo },
-      appDataKeccak256,
-    )
+    const result = getOrderToSign(params, { ...defaultOrderParams, validTo: exactValidTo }, appDataKeccak256)
 
     expect(result.validTo).toBe(exactValidTo)
   })
@@ -72,9 +68,29 @@ describe('getOrderToSign', () => {
     expect(result.buyAmount).toBe('1990000000000000000')
   })
 
+  it('When sell order and cost/slippage adjustments disabled, then buy amount should remain unchanged', () => {
+    const result = getOrderToSign(
+      { ...params, applyCostsSlippageAndFees: false },
+      { ...defaultOrderParams, kind: OrderKind.SELL },
+      appDataKeccak256,
+    )
+
+    expect(result.buyAmount).toBe(defaultOrderParams.buyAmount)
+  })
+
   it('When buy order, then sell amount should be adjusted to slippage', () => {
     const result = getOrderToSign(params, { ...defaultOrderParams, kind: OrderKind.BUY }, appDataKeccak256)
 
     expect(result.sellAmount).toBe('1005000000000000000')
   })
+
+  it('When buy order and cost/slippage adjustments disabled, then sell amount should remain unchanged', () => {
+    const result = getOrderToSign(
+      { ...params, applyCostsSlippageAndFees: false },
+      { ...defaultOrderParams, kind: OrderKind.BUY },
+      appDataKeccak256,
+    )
+
+    expect(result.sellAmount).toBe(defaultOrderParams.sellAmount)
+  })
 })