fmt

contracts/usdtb/USDtbMinting.sol

@@ -532,7 +532,8 @@ contract USDtbMinting is IUSDtbMinting, SingleAdminAccessControl, ReentrancyGuar
         : 10 ** (collateralDecimals - usdtbDecimals)
     );
 
-    normalizedCollateralAmount = usdtbDecimals > collateralDecimals ? collateralAmount * scale : collateralAmount / scale;
+    normalizedCollateralAmount =
+      usdtbDecimals > collateralDecimals ? collateralAmount * scale : collateralAmount / scale;
 
     uint128 difference = normalizedCollateralAmount > usdtbAmount
       ? normalizedCollateralAmount - usdtbAmount

test/foundry/USDtbMinting.utils.sol

@@ -13,8 +13,8 @@ contract USDtbMintingUtils is USDtbMintingBaseSetup {
     (,, uint128 maxMintPerBlock,) = USDtbMintingContract.tokenConfig(address(stETHToken));
 
     vm.assume(excessiveMintAmount > (maxMintPerBlock));
-    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route) =
-      mint_setup(excessiveMintAmount, _stETHToDeposit, stETHToken, 1, false);
+    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route)
+    = mint_setup(excessiveMintAmount, _stETHToDeposit, stETHToken, 1, false);
 
     vm.prank(minter);
     vm.expectRevert(MaxMintPerBlockExceeded);
@@ -45,8 +45,8 @@ contract USDtbMintingUtils is USDtbMintingBaseSetup {
   }
 
   function executeMint(IERC20 collateralAsset) public {
-    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route) =
-      mint_setup(_usdtbToMint, _stETHToDeposit, collateralAsset, 1, false);
+    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route)
+    = mint_setup(_usdtbToMint, _stETHToDeposit, collateralAsset, 1, false);
 
     vm.prank(minter);
     USDtbMintingContract.mint(order, route, takerSignature);

test/foundry/USDtbMintingBaseSetup.sol

@@ -475,8 +475,11 @@ contract USDtbMintingBaseSetup is Test, IUSDtbMintingEvents, IUSDtbDefinitions {
     uint128 nonce,
     bool multipleRedeem
   ) public returns (IUSDtbMinting.Order memory redeemOrder, IUSDtbMinting.Signature memory takerSignature2) {
-    (IUSDtbMinting.Order memory mintOrder, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route)
-    = mint_setup(usdtbAmount, collateralAmount, collateralAsset, nonce, true);
+    (
+      IUSDtbMinting.Order memory mintOrder,
+      IUSDtbMinting.Signature memory takerSignature,
+      IUSDtbMinting.Route memory route
+    ) = mint_setup(usdtbAmount, collateralAmount, collateralAsset, nonce, true);
 
     vm.prank(minter);
     USDtbMintingContract.mint(mintOrder, route, takerSignature);

test/foundry/test/USDtbMinting.ACL.t.sol

@@ -30,8 +30,11 @@ contract USDtbMintingACLTest is USDtbMintingUtils {
   }
 
   function test_fuzz_notMinter_cannot_mint(address nonMinter) public {
-    (IUSDtbMinting.Order memory mintOrder, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route)
-    = mint_setup(_usdtbToMint, _stETHToDeposit, stETHToken, 1, false);
+    (
+      IUSDtbMinting.Order memory mintOrder,
+      IUSDtbMinting.Signature memory takerSignature,
+      IUSDtbMinting.Route memory route
+    ) = mint_setup(_usdtbToMint, _stETHToDeposit, stETHToken, 1, false);
 
     vm.assume(nonMinter != minter);
     vm.startPrank(nonMinter);
@@ -242,8 +245,8 @@ contract USDtbMintingACLTest is USDtbMintingUtils {
     vm.startPrank(gatekeeper);
     USDtbMintingContract.disableMintRedeem();
 
-    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route) =
-      mint_setup(_usdtbToMint, _stETHToDeposit, stETHToken, 1, false);
+    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route)
+    = mint_setup(_usdtbToMint, _stETHToDeposit, stETHToken, 1, false);
 
     vm.prank(minter);
     vm.expectRevert(GlobalMaxMintPerBlockExceeded);

test/foundry/test/USDtbMinting.Delegate.t.sol

@@ -38,7 +38,8 @@ contract USDtbMintingDelegateTest is USDtbMintingUtils {
       "The delegation status should be accepted"
     );
 
-    IUSDtbMinting.Signature memory trader2Sig = signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
+    IUSDtbMinting.Signature memory trader2Sig =
+      signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
 
     assertEq(
       stETHToken.balanceOf(address(USDtbMintingContract)), 0, "Mismatch in Minting contract stETH balance before mint"
@@ -70,7 +71,8 @@ contract USDtbMintingDelegateTest is USDtbMintingUtils {
     USDtbMintingContract.confirmDelegatedSigner(benefactor);
 
     vm.prank(trader2);
-    IUSDtbMinting.Signature memory trader2Sig = signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
+    IUSDtbMinting.Signature memory trader2Sig =
+      signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
 
     assertEq(
       stETHToken.balanceOf(address(USDtbMintingContract)), 0, "Mismatch in Minting contract stETH balance before mint"
@@ -125,7 +127,8 @@ contract USDtbMintingDelegateTest is USDtbMintingUtils {
       "The delegation status should be accepted"
     );
 
-    IUSDtbMinting.Signature memory trader2Sig = signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
+    IUSDtbMinting.Signature memory trader2Sig =
+      signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
 
     assertEq(
       stETHToken.balanceOf(address(USDtbMintingContract)),
@@ -150,7 +153,8 @@ contract USDtbMintingDelegateTest is USDtbMintingUtils {
 
     bytes32 digest1 = USDtbMintingContract.hashOrder(order);
     vm.prank(trader2);
-    IUSDtbMinting.Signature memory trader2Sig = signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
+    IUSDtbMinting.Signature memory trader2Sig =
+      signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
 
     assertEq(
       stETHToken.balanceOf(address(USDtbMintingContract)),
@@ -222,7 +226,8 @@ contract USDtbMintingDelegateTest is USDtbMintingUtils {
 
     bytes32 digest1 = USDtbMintingContract.hashOrder(order);
     vm.prank(trader2);
-    IUSDtbMinting.Signature memory trader2Sig = signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
+    IUSDtbMinting.Signature memory trader2Sig =
+      signOrder(trader2PrivateKey, digest1, IUSDtbMinting.SignatureType.EIP712);
 
     assertEq(
       stETHToken.balanceOf(address(USDtbMintingContract)), 0, "Mismatch in Minting contract stETH balance before mint"

test/foundry/test/USDtbMinting.StableRatios.t.sol

@@ -65,8 +65,11 @@ contract USDtbMintingStableRatiosTest is USDtbMintingUtils {
     uint128 usdtAmountAtUpperLimit = 1010 * 10 ** 6; // 100 bps above the USDT amount that should be at the upper bps limit
     uint128 usdtAmountAtLowerLimit = 990 * 10 ** 6; // 100 bps below the USDT amount that should be at the lower bps limit
 
-    (IUSDtbMinting.Order memory orderLow, IUSDtbMinting.Signature memory signatureLow, IUSDtbMinting.Route memory routeLow)
-    = mint_setup(usdtbAmount, usdtAmountAtLowerLimit, USDTToken, 1, true);
+    (
+      IUSDtbMinting.Order memory orderLow,
+      IUSDtbMinting.Signature memory signatureLow,
+      IUSDtbMinting.Route memory routeLow
+    ) = mint_setup(usdtbAmount, usdtAmountAtLowerLimit, USDTToken, 1, true);
     vm.prank(minter);
     USDtbMintingContract.mint(orderLow, routeLow, signatureLow);
 
@@ -92,15 +95,21 @@ contract USDtbMintingStableRatiosTest is USDtbMintingUtils {
 
     uint128 usdtbAmount = 1000 * 10 ** 18; // 1,000 USDtb
     uint128 collateralGreaterBreachStableLimit = 1011 * 10 ** 6;
-    (IUSDtbMinting.Order memory aOrder, IUSDtbMinting.Signature memory aTakerSignature, IUSDtbMinting.Route memory aRoute)
-    = mint_setup(usdtbAmount, collateralGreaterBreachStableLimit, USDTToken, 1, true);
+    (
+      IUSDtbMinting.Order memory aOrder,
+      IUSDtbMinting.Signature memory aTakerSignature,
+      IUSDtbMinting.Route memory aRoute
+    ) = mint_setup(usdtbAmount, collateralGreaterBreachStableLimit, USDTToken, 1, true);
 
     vm.prank(minter);
     USDtbMintingContract.mint(aOrder, aRoute, aTakerSignature);
 
     uint128 collateralLessThanBreachesStableLimit = 989 * 10 ** 6;
-    (IUSDtbMinting.Order memory bOrder, IUSDtbMinting.Signature memory bTakerSignature, IUSDtbMinting.Route memory bRoute)
-    = mint_setup(usdtbAmount, collateralLessThanBreachesStableLimit, USDTToken, 2, true);
+    (
+      IUSDtbMinting.Order memory bOrder,
+      IUSDtbMinting.Signature memory bTakerSignature,
+      IUSDtbMinting.Route memory bRoute
+    ) = mint_setup(usdtbAmount, collateralLessThanBreachesStableLimit, USDTToken, 2, true);
 
     vm.expectRevert(InvalidStablePrice);
     vm.prank(minter);

test/foundry/test/USDtbMinting.blockLimits.t.sol

@@ -16,17 +16,23 @@ contract USDtbMintingBlockLimitsTest is USDtbMintingUtils {
     uint128 maxMintAmount = tokenConfig[0].maxMintPerBlock;
     uint128 firstMintAmount = maxMintAmount / 4;
     uint128 secondMintAmount = maxMintAmount / 2;
-    (IUSDtbMinting.Order memory aOrder, IUSDtbMinting.Signature memory aTakerSignature, IUSDtbMinting.Route memory aRoute)
-    = mint_setup(firstMintAmount, _stETHToDeposit, stETHToken, 1, false);
+    (
+      IUSDtbMinting.Order memory aOrder,
+      IUSDtbMinting.Signature memory aTakerSignature,
+      IUSDtbMinting.Route memory aRoute
+    ) = mint_setup(firstMintAmount, _stETHToDeposit, stETHToken, 1, false);
 
     vm.prank(minter);
     USDtbMintingContract.mint(aOrder, aRoute, aTakerSignature);
 
     vm.prank(owner);
     stETHToken.mint(_stETHToDeposit, benefactor);
 
-    (IUSDtbMinting.Order memory bOrder, IUSDtbMinting.Signature memory bTakerSignature, IUSDtbMinting.Route memory bRoute)
-    = mint_setup(secondMintAmount, _stETHToDeposit, stETHToken, 2, true);
+    (
+      IUSDtbMinting.Order memory bOrder,
+      IUSDtbMinting.Signature memory bTakerSignature,
+      IUSDtbMinting.Route memory bRoute
+    ) = mint_setup(secondMintAmount, _stETHToDeposit, stETHToken, 2, true);
 
     vm.prank(minter);
     USDtbMintingContract.mint(bOrder, bRoute, bTakerSignature);
@@ -46,8 +52,11 @@ contract USDtbMintingBlockLimitsTest is USDtbMintingUtils {
 
   function test_fuzz_mint_maxMint_perBlock_exceeded_revert(uint128 excessiveMintAmount) public {
     vm.assume(excessiveMintAmount > tokenConfig[0].maxMintPerBlock);
-    (IUSDtbMinting.Order memory mintOrder, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route)
-    = mint_setup(excessiveMintAmount, _stETHToDeposit, stETHToken, 1, false);
+    (
+      IUSDtbMinting.Order memory mintOrder,
+      IUSDtbMinting.Signature memory takerSignature,
+      IUSDtbMinting.Route memory route
+    ) = mint_setup(excessiveMintAmount, _stETHToDeposit, stETHToken, 1, false);
 
     // maker
     vm.startPrank(minter);
@@ -68,8 +77,8 @@ contract USDtbMintingBlockLimitsTest is USDtbMintingUtils {
 
   function test_fuzz_nextBlock_mint_is_zero(uint128 mintAmount) public {
     vm.assume(mintAmount < tokenConfig[0].maxMintPerBlock && mintAmount > 0);
-    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route) =
-      mint_setup(_usdtbToMint, _stETHToDeposit, stETHToken, 1, false);
+    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route)
+    = mint_setup(_usdtbToMint, _stETHToDeposit, stETHToken, 1, false);
 
     vm.prank(minter);
     USDtbMintingContract.mint(order, route, takerSignature);
@@ -100,8 +109,11 @@ contract USDtbMintingBlockLimitsTest is USDtbMintingUtils {
   function test_global_mint_limit_versus_local_perBlock() public {
     uint128 maxMintAmount = tokenConfig[0].maxMintPerBlock;
     uint128 firstMintAmount = maxMintAmount / 4;
-    (IUSDtbMinting.Order memory aOrder, IUSDtbMinting.Signature memory aTakerSignature, IUSDtbMinting.Route memory aRoute)
-    = mint_setup(firstMintAmount, _stETHToDeposit, stETHToken, 1, false);
+    (
+      IUSDtbMinting.Order memory aOrder,
+      IUSDtbMinting.Signature memory aTakerSignature,
+      IUSDtbMinting.Route memory aRoute
+    ) = mint_setup(firstMintAmount, _stETHToDeposit, stETHToken, 1, false);
 
     vm.startPrank(owner);
     stETHToken.mint(_stETHToDeposit, benefactor);

test/foundry/test/USDtbMinting.core.t.sol

@@ -114,8 +114,8 @@ contract USDtbMintingCoreTest is USDtbMintingUtils {
   function test_fuzz_mint_noSlippage(uint128 expectedAmount) public {
     vm.assume(expectedAmount > 0 && expectedAmount < _maxMintPerBlock);
 
-    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route) =
-      mint_setup(expectedAmount, _stETHToDeposit, stETHToken, 1, false);
+    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route)
+    = mint_setup(expectedAmount, _stETHToDeposit, stETHToken, 1, false);
 
     vm.recordLogs();
     vm.prank(minter);
@@ -364,8 +364,8 @@ contract USDtbMintingCoreTest is USDtbMintingUtils {
   }
 
   function test_expired_orders_revert() public {
-    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route) =
-      mint_setup(_usdtbToMint, _stETHToDeposit, stETHToken, 1, false);
+    (IUSDtbMinting.Order memory order, IUSDtbMinting.Signature memory takerSignature, IUSDtbMinting.Route memory route)
+    = mint_setup(_usdtbToMint, _stETHToDeposit, stETHToken, 1, false);
 
     vm.warp(block.timestamp + 11 minutes);