    function setFeeInfo(FeeInfo calldata _newFeeInfo) external onlyOwner {
        if ( 
            _newFeeInfo.swapFeeDeployerBp > 10000 ||
            _newFeeInfo.swapFeeDecayBp > 10000 ||
            _newFeeInfo.swapFeeFinalBp > 10000 || 
            _newFeeInfo.swapFeeStartingBp > 10000 ||
            _newFeeInfo.swapFeeSellBp > 10000 ||
>>          _newFeeInfo.tokenizeFeeDestinationAddress == address(0) ||
            _newFeeInfo.swapFeeStartingBp < _newFeeInfo.swapFeeFinalBp || 
            _newFeeInfo.swapFeeDecayInterval == 0
        ) {
            revert InvalidSetting();
        }

        feeInfo = _newFeeInfo;
        emit FeeInfoSet(_newFeeInfo);
    }
    import { HardhatEthersSigner } from "@nomicfoundation/hardhat-ethers/signers";
    import { ethers as hhethers } from "hardhat";
    import {IERC20Metadata, UpsideMetaCoin, UpsideProtocol, UpsideStakingStub} from "../types";
+   import { expect } from "chai";

    describe("C4 PoC Test Suite", function () {
        ---snip---
        let user1: HardhatEthersSigner;
+       let user2: HardhatEthersSigner;
        ---snip---

        before(async function () {
            signers = await hhethers.getSigners();
            owner = signers[2];
            user1 = signers[0];
+           user2 = signers[1];
            ---snip---
        });

+       // the test below goes here
    });
  it("should send fees to original owner", async function () {
    const url1 = "https://openzeppelin.com";
    const url2 = "https://cantina.com";
    const liquidityTokenAddress = await liquidityToken.getAddress();
    const tokenizeFeeDestinationAddress = await owner.getAddress();
    const _mintAmount = hhethers.parseUnits("100", 6);
    const _feeAmount = hhethers.parseUnits("5", 6);

    // Configure fee parameters with current owner as the fee destination
    const newFeeInfo = {
      tokenizeFeeEnabled: true,
      tokenizeFeeDestinationAddress: tokenizeFeeDestinationAddress,
      swapFeeStartingBp: 9900,  // 99%
      swapFeeDecayBp: 100,      // 1%
      swapFeeDecayInterval: 6,  // 6 seconds
      swapFeeFinalBp: 100,      // 1%
      swapFeeDeployerBp: 1000,  // 10%
      swapFeeSellBp: 100,       // 1%
    };
  
    // Owner sets the fee configuration
    await upsideProtocol.connect(owner).setFeeInfo(newFeeInfo);

    // set tokenize fee to 5e6
    await upsideProtocol.connect(owner).setTokenizeFee(liquidityTokenAddress, _feeAmount);

    // mint liquidityToken to user1
    await liquidityToken.mint(await user1.getAddress(), _mintAmount);
    // assert that user1 received the minted tokens
    let user1LiquidityTokenBalance = await liquidityToken.balanceOf(await user1.getAddress());
    expect(user1LiquidityTokenBalance).to.be.eq(_mintAmount);

    // user1 performs tokenization (url1), fee should go to current fee destination (owner)
    await liquidityToken.connect(user1).approve(await upsideProtocol.getAddress(), _feeAmount);
    await upsideProtocol.connect(user1).tokenize(url1, liquidityTokenAddress);

    // Validate that the fee was received by the original owner
    let tokenizeFeeDestinationAddressBalance = await liquidityToken.balanceOf(tokenizeFeeDestinationAddress);
    expect(tokenizeFeeDestinationAddressBalance).to.be.eq(hhethers.parseUnits("5", 6));

    // Transfer ownership to user2
    await upsideProtocol.connect(owner).transferOwnership(await user2.getAddress());
    // asset that new ownership is assigned to user2
    expect(await upsideProtocol.owner()).to.be.eq(await user2.getAddress());

    // user1 performs a second tokenization (url2) after ownership transfer
    await liquidityToken.connect(user1).approve(await upsideProtocol.getAddress(), _feeAmount);
    await upsideProtocol.connect(user1).tokenize(url2, liquidityTokenAddress);

    // assert that the original owner still receives the fee post-ownership transfer
    let currentTokenizeFeeDestinationAddressBalance = await liquidityToken.balanceOf(await owner.getAddress());
    expect(currentTokenizeFeeDestinationAddressBalance).to.be.eq(hhethers.parseUnits("10", 6));
  });
