diff --git a/src/FeeCalculator.sol b/src/FeeCalculator.sol
index 2bb57cf..04d67cf 100644
--- a/src/FeeCalculator.sol
+++ b/src/FeeCalculator.sol
@@ -133,12 +133,12 @@ contract FeeCalculator is IFeeCalculator, Ownable {
     }
 
     /// @notice Calculates the deposit fee for a given amount.
-    /// @param tco2 The address of the TCO2 token.
     /// @param pool The address of the pool.
+    /// @param tco2 The address of the TCO2 token.
     /// @param depositAmount The amount to be deposited.
     /// @return feeDistribution How the fee is meant to be
     /// distributed among the fee recipients.
-    function calculateDepositFees(address tco2, address pool, uint256 depositAmount)
+    function calculateDepositFees(address pool, address tco2, uint256 depositAmount)
         external
         view
         override
@@ -177,17 +177,22 @@ contract FeeCalculator is IFeeCalculator, Ownable {
     }
 
     /// @notice Calculates the redemption fees for a given amount.
-    /// @param tco2 The address of the TCO2 token.
     /// @param pool The address of the pool.
-    /// @param redemptionAmount The amount to be redeemed.
+    /// @param tco2s The addresses of the TCO2 token.
+    /// @param redemptionAmounts The amounts to be redeemed.
     /// @return feeDistribution How the fee is meant to be
     /// distributed among the fee recipients.
-    function calculateRedemptionFees(address tco2, address pool, uint256 redemptionAmount)
+    function calculateRedemptionFees(address pool, address[] calldata tco2s, uint256[] calldata redemptionAmounts)
         external
         view
         override
         returns (FeeDistribution memory feeDistribution)
     {
+        require(tco2s.length == redemptionAmounts.length, "length mismatch");
+        require(tco2s.length == 1, "only one");
+        address tco2 = tco2s[0];
+        uint256 redemptionAmount = redemptionAmounts[0];
+
         require(redemptionAmount > 0, "redemptionAmount must be > 0");
 
         uint256 feeAmount = getRedemptionFee(redemptionAmount, getTokenBalance(pool, tco2), getTotalSupply(pool));
diff --git a/src/interfaces/IFeeCalculator.sol b/src/interfaces/IFeeCalculator.sol
index 9b2442d..69266a3 100644
--- a/src/interfaces/IFeeCalculator.sol
+++ b/src/interfaces/IFeeCalculator.sol
@@ -15,23 +15,23 @@ struct FeeDistribution {
 /// @notice This interface defines methods for calculating fees.
 interface IFeeCalculator {
     /// @notice Calculates the deposit fee for a given amount.
-    /// @param tco2 The address of the TCO2 token.
     /// @param pool The address of the pool.
+    /// @param tco2 The address of the TCO2 token.
     /// @param depositAmount The amount to be deposited.
     /// @return feeDistribution How the fee is meant to be
     /// distributed among the fee recipients.
-    function calculateDepositFees(address tco2, address pool, uint256 depositAmount)
+    function calculateDepositFees(address pool, address tco2, uint256 depositAmount)
         external
         view
         returns (FeeDistribution memory feeDistribution);
 
     /// @notice Calculates the redemption fees for a given amount.
-    /// @param tco2 The address of the TCO2 token.
     /// @param pool The address of the pool.
-    /// @param redemptionAmount The amount to be redeemed.
+    /// @param tco2s The addresses of the TCO2 token.
+    /// @param redemptionAmounts The amounts to be redeemed.
     /// @return feeDistribution How the fee is meant to be
     /// distributed among the fee recipients.
-    function calculateRedemptionFees(address tco2, address pool, uint256 redemptionAmount)
+    function calculateRedemptionFees(address pool, address[] calldata tco2s, uint256[] calldata redemptionAmounts)
         external
         view
         returns (FeeDistribution memory feeDistribution);
diff --git a/test/FeeCalculator.fuzzy.t.sol b/test/FeeCalculator.fuzzy.t.sol
index 4f70cb2..d9d2983 100644
--- a/test/FeeCalculator.fuzzy.t.sol
+++ b/test/FeeCalculator.fuzzy.t.sol
@@ -48,7 +48,7 @@ contract FeeCalculatorTestFuzzy is Test {
         mockToken.setTokenBalance(address(mockPool), 1e9 * 1e18);
 
         vm.expectRevert("Fee must be greater than 0");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFeesFuzzy(uint256 depositAmount, uint256 current, uint256 total) public {
@@ -68,7 +68,7 @@ contract FeeCalculatorTestFuzzy is Test {
         mockToken.setTokenBalance(address(mockPool), current);
 
         // Act
-        try feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount) {}
+        try feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount) {}
         catch Error(string memory reason) {
             assertTrue(
                 keccak256(bytes("Fee must be greater than 0")) == keccak256(bytes(reason))
@@ -119,8 +119,13 @@ contract FeeCalculatorTestFuzzy is Test {
         bool oneTimeRedemptionFailed = false;
         uint256 multipleTimesRedemptionFailedCount = 0;
 
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
+
         // Act
-        try feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), redemptionAmount) returns (
+        try feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts) returns (
             FeeDistribution memory feeDistribution
         ) {
             oneTimeFee = feeDistribution.shares.sumOf();
@@ -145,7 +150,8 @@ contract FeeCalculatorTestFuzzy is Test {
 
         for (uint256 i = 0; i < numberOfRedemptions; i++) {
             uint256 redemption = equalRedemption + (i == 0 ? restRedemption : 0);
-            try feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), redemption) returns (
+            redemptionAmounts[0] = redemption;
+            try feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts) returns (
                 FeeDistribution memory feeDistribution
             ) {
                 feeFromDividedRedemptions += feeDistribution.shares.sumOf();
@@ -203,7 +209,7 @@ contract FeeCalculatorTestFuzzy is Test {
         uint256 oneTimeFee = 0;
 
         // Act
-        try feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount) returns (
+        try feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount) returns (
             FeeDistribution memory feeDistribution
         ) {
             oneTimeFee = feeDistribution.shares.sumOf();
@@ -223,7 +229,7 @@ contract FeeCalculatorTestFuzzy is Test {
         for (uint256 i = 0; i < numberOfDeposits; i++) {
             uint256 deposit = equalDeposit + (i == 0 ? restDeposit : 0);
 
-            try feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), deposit) returns (
+            try feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), deposit) returns (
                 FeeDistribution memory feeDistribution
             ) {
                 feeFromDividedDeposits += feeDistribution.shares.sumOf();
@@ -278,7 +284,7 @@ contract FeeCalculatorTestFuzzy is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory gotRecipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
diff --git a/test/FeeCalculator.t.sol b/test/FeeCalculator.t.sol
index 823292a..a14be2f 100644
--- a/test/FeeCalculator.t.sol
+++ b/test/FeeCalculator.t.sol
@@ -74,7 +74,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -88,6 +88,10 @@ contract FeeCalculatorTest is Test {
         // Arrange
         // Set up your test data
         uint256 redemptionAmount = 100 * 1e18;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(1000 * 1e18);
@@ -95,7 +99,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), redemptionAmount);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -109,6 +113,10 @@ contract FeeCalculatorTest is Test {
         // Arrange
         // Set up your test data
         uint256 redemptionAmount = 1 * 1e18;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(1e6 * 1e18);
@@ -116,7 +124,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), redemptionAmount);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -131,6 +139,10 @@ contract FeeCalculatorTest is Test {
         // Arrange
         // Set up your test data
         uint256 redemptionAmount = 1 * 1e18;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(1e6 * 1e18);
@@ -138,7 +150,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), redemptionAmount);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -168,7 +180,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -201,7 +213,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -224,7 +236,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -244,7 +256,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         vm.expectRevert("Fee must be greater than 0");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFees_DepositOfHundredWei_ShouldThrowError() public {
@@ -261,7 +273,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         vm.expectRevert("Fee must be greater than 0");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFees_DepositOfHundredThousandsPartOfOne_NonzeroFee() public {
@@ -275,7 +287,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -295,7 +307,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -334,7 +346,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -382,7 +394,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -411,7 +423,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -431,7 +443,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         vm.expectRevert("depositAmount must be > 0");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFees_CurrentGreaterThanTotal_ExceptionShouldBeThrown() public {
@@ -447,13 +459,17 @@ contract FeeCalculatorTest is Test {
         vm.expectRevert(
             "The total volume in the pool must be greater than or equal to the volume for an individual asset"
         );
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateRedemptionFees_CurrentGreaterThanTotal_ExceptionShouldBeThrown() public {
         // Arrange
         // Set up your test data
-        uint256 depositAmount = 1;
+        uint256 redemptionAmount = 1;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(1000 * 1e18);
@@ -463,13 +479,17 @@ contract FeeCalculatorTest is Test {
         vm.expectRevert(
             "The total volume in the pool must be greater than or equal to the volume for an individual asset"
         );
-        feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
     }
 
     function testCalculateRedemptionFees_AmountGreaterThanCurrent_ExceptionShouldBeThrown() public {
         // Arrange
         // Set up your test data
-        uint256 depositAmount = 600 * 1e18;
+        uint256 redemptionAmount = 600 * 1e18;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(1000 * 1e18);
@@ -477,13 +497,17 @@ contract FeeCalculatorTest is Test {
 
         // Act
         vm.expectRevert("The amount to be redeemed cannot exceed the current balance of the pool");
-        feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
     }
 
     function testCalculateRedemptionFees_ZeroRedemption_ExceptionShouldBeThrown() public {
         // Arrange
         // Set up your test data
-        uint256 depositAmount = 0;
+        uint256 redemptionAmount = 0;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(1000 * 1e18);
@@ -491,7 +515,7 @@ contract FeeCalculatorTest is Test {
 
         // Act & Assert
         vm.expectRevert("redemptionAmount must be > 0");
-        feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
     }
 
     function testCalculateDepositFees_EmptyPool_FeeCappedAt10Percent() public {
@@ -505,7 +529,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -525,7 +549,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -538,6 +562,10 @@ contract FeeCalculatorTest is Test {
         // Arrange
         // Set up your test data
         uint256 redemptionAmount = 0;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(1000 * 1e18);
@@ -545,13 +573,17 @@ contract FeeCalculatorTest is Test {
 
         // Act
         vm.expectRevert("redemptionAmount must be > 0");
-        feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), redemptionAmount);
+        feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
     }
 
     function testCalculateRedemptionFees_TotalEqualCurrent_FeeCappedAt10Percent() public {
         // Arrange
         // Set up your test data
         uint256 redemptionAmount = 100;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(1000);
@@ -559,7 +591,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), redemptionAmount);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -579,7 +611,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -599,7 +631,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -619,7 +651,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -631,7 +663,11 @@ contract FeeCalculatorTest is Test {
     function testCalculateRedemptionFees_HugeTotalLargeCurrentSmallDeposit_FeeCappedAt30Percent() public {
         // Arrange
         // Set up your test data
-        uint256 depositAmount = 10000 * 1e18;
+        uint256 redemptionAmount = 10000 * 1e18;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         uint256 supply = 100000 * 1e18;
@@ -640,19 +676,23 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
         // Assert
         assertEq(recipients[0], feeRecipient);
-        assertEq(fees[0], depositAmount * 30 / 100);
+        assertEq(fees[0], redemptionAmount * 30 / 100);
     }
 
     function testCalculateRedemptionFees_NegativeFeeValue_FeeCappedAt30Percent() public {
         // Arrange
         // Set up your test data
-        uint256 depositAmount = 2323662174650;
+        uint256 redemptionAmount = 2323662174650;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(56636794628913227180683983236);
@@ -660,13 +700,13 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
         // Assert
         assertEq(recipients[0], feeRecipient);
-        assertEq(fees[0], depositAmount * 30 / 100);
+        assertEq(fees[0], redemptionAmount * 30 / 100);
     }
 
     function testFeeSetup_RecipientsEmpty_ShouldThrowError() public {
@@ -805,7 +845,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), 100 * 1e18);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), 100 * 1e18);
         uint256[] memory fees = feeDistribution.shares;
 
         // Assert
@@ -821,7 +861,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), 100 * 1e18);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), 100 * 1e18);
         uint256[] memory fees = feeDistribution.shares;
 
         // Assert
@@ -837,7 +877,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), 100 * 1e18);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), 100 * 1e18);
         uint256[] memory fees = feeDistribution.shares;
 
         // Assert
@@ -846,6 +886,11 @@ contract FeeCalculatorTest is Test {
 
     function testSetRedemptionFeeScale() public {
         // Arrange
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = 100e18;
+
         // Set up mock pool
         mockPool.setTotalSupply(1000 * 1e18);
         mockToken.setTokenBalance(address(mockPool), 500 * 1e18);
@@ -853,7 +898,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), 100e18);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         uint256[] memory fees = feeDistribution.shares;
 
         // Assert
@@ -862,6 +907,11 @@ contract FeeCalculatorTest is Test {
 
     function testSetRedemptionFeeShift() public {
         // Arrange
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = 100e18;
+
         // Set up mock pool
         mockPool.setTotalSupply(1000 * 1e18);
         mockToken.setTokenBalance(address(mockPool), 500 * 1e18);
@@ -869,7 +919,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), 100e18);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         uint256[] memory fees = feeDistribution.shares;
 
         // Assert
@@ -878,6 +928,11 @@ contract FeeCalculatorTest is Test {
 
     function testSetSingleAssetRedemptionRelativeFee() public {
         // Arrange
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = 100 * 1e18;
+
         // Set up mock pool
         mockPool.setTotalSupply(1000 * 1e18);
         mockToken.setTokenBalance(address(mockPool), 1000 * 1e18);
@@ -885,7 +940,7 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), 100 * 1e18);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         uint256[] memory fees = feeDistribution.shares;
 
         assertEq(fees[0], 83 * 1e18);
@@ -894,7 +949,11 @@ contract FeeCalculatorTest is Test {
     function testSetDustAssetRedemptionRelativeFee() public {
         // Arrange
         // Set up your test data
-        uint256 depositAmount = 2323662174650;
+        uint256 redemptionAmount = 2323662174650;
+        address[] memory tco2s = new address[](1);
+        tco2s[0] = address(mockToken);
+        uint256[] memory redemptionAmounts = new uint256[](1);
+        redemptionAmounts[0] = redemptionAmount;
 
         // Set up mock pool
         mockPool.setTotalSupply(56636794628913227180683983236);
@@ -903,10 +962,10 @@ contract FeeCalculatorTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateRedemptionFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateRedemptionFees(address(mockPool), tco2s, redemptionAmounts);
         uint256[] memory fees = feeDistribution.shares;
 
         // Assert
-        assertEq(fees[0], depositAmount * 91 / 100);
+        assertEq(fees[0], redemptionAmount * 91 / 100);
     }
 }
diff --git a/test/FeeCalculatorLaunchParams.fuzzy.t.sol b/test/FeeCalculatorLaunchParams.fuzzy.t.sol
index 3e91a7a..9c1576d 100644
--- a/test/FeeCalculatorLaunchParams.fuzzy.t.sol
+++ b/test/FeeCalculatorLaunchParams.fuzzy.t.sol
@@ -49,7 +49,7 @@ contract FeeCalculatorLaunchParamsTestFuzzy is Test {
         mockToken.setTokenBalance(address(mockPool), 1e9 * 1e18);
 
         vm.expectRevert("Fee must be greater than 0");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFeesFuzzy(uint256 depositAmount, uint256 current, uint256 total) public {
@@ -69,7 +69,7 @@ contract FeeCalculatorLaunchParamsTestFuzzy is Test {
         mockToken.setTokenBalance(address(mockPool), current);
 
         // Act
-        try feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount) {}
+        try feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount) {}
         catch Error(string memory reason) {
             assertTrue(
                 keccak256(bytes("Fee must be greater than 0")) == keccak256(bytes(reason))
@@ -116,7 +116,7 @@ contract FeeCalculatorLaunchParamsTestFuzzy is Test {
         uint256 oneTimeFee = 0;
 
         // Act
-        try feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount) returns (
+        try feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount) returns (
             FeeDistribution memory feeDistribution
         ) {
             oneTimeFee = feeDistribution.shares.sumOf();
@@ -137,7 +137,7 @@ contract FeeCalculatorLaunchParamsTestFuzzy is Test {
         for (uint256 i = 0; i < numberOfDeposits; i++) {
             uint256 deposit = equalDeposit + (i == 0 ? restDeposit : 0);
 
-            try feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), deposit) returns (
+            try feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), deposit) returns (
                 FeeDistribution memory feeDistribution
             ) {
                 feeFromDividedDeposits += feeDistribution.shares.sumOf();
diff --git a/test/FeeCalculatorLaunchParams.t.sol b/test/FeeCalculatorLaunchParams.t.sol
index b9c42b2..3e4ee52 100644
--- a/test/FeeCalculatorLaunchParams.t.sol
+++ b/test/FeeCalculatorLaunchParams.t.sol
@@ -43,7 +43,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -74,7 +74,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -107,7 +107,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -130,7 +130,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -151,7 +151,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         vm.expectRevert("Fee must be greater than 0");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFees_DepositOfHundredWei_ShouldThrowError() public {
@@ -168,7 +168,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         vm.expectRevert("Fee must be greater than 0");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFees_DepositOfHundredThousandsPartOfOne_NonzeroFee() public {
@@ -182,7 +182,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -203,7 +203,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -243,7 +243,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -292,7 +292,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -322,7 +322,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -343,7 +343,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         vm.expectRevert("depositAmount must be > 0");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFees_CurrentGreaterThanTotal_ExceptionShouldBeThrown() public {
@@ -359,7 +359,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
         vm.expectRevert(
             "The total volume in the pool must be greater than or equal to the volume for an individual asset"
         );
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFees_EmptyPool_FeeCappedAt10Percent() public {
@@ -373,7 +373,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -393,7 +393,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         vm.expectRevert("Deposit outside range");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFees_TotalEqualCurrent_FeeCappedAt10Percent() public {
@@ -407,7 +407,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;
 
@@ -427,7 +427,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         vm.expectRevert("Deposit outside range");
-        feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+        feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
     }
 
     function testCalculateDepositFees_ZeroCurrent_NormalFees() public {
@@ -441,7 +441,7 @@ contract FeeCalculatorLaunchParamsTest is Test {
 
         // Act
         FeeDistribution memory feeDistribution =
-            feeCalculator.calculateDepositFees(address(mockToken), address(mockPool), depositAmount);
+            feeCalculator.calculateDepositFees(address(mockPool), address(mockToken), depositAmount);
         address[] memory recipients = feeDistribution.recipients;
         uint256[] memory fees = feeDistribution.shares;