@coti-io/coti-contracts 1.2.0 → 1.3.0

package/test/token/PrivateERC20/PrivacyBridge.fees.test.ts

@@ -1,327 +1,250 @@
 import hre from "hardhat"
 import { expect } from "chai"
 import { setupAccounts } from "../../utils/accounts"
-import { PrivacyBridgeERC20Mock, PrivateERC20Mock } from "../../../typechain-types"
+import {
+    CotiPriceConsumerMock,
+    ERC20DecimalsMock,
+    PrivacyBridgeERC20Mock,
+    PrivateERC20Mock,
+} from "../../../typechain-types"
 import { Wallet } from "@coti-io/coti-ethers"
-import { Contract } from "ethers"
+import { parseEther, parseUnits, ZeroAddress } from "ethers"
 import { txOpts } from "../../utils/privateErc20Helpers"
 
 const GAS_LIMIT = 12000000
 
-describe("PrivacyBridge Fees", function () {
+describe("PrivacyBridge Fees (dynamic native COTI)", function () {
     let bridge: PrivacyBridgeERC20Mock
     let bridgeAddress: string
     let privateToken: PrivateERC20Mock
     let privateTokenAddress: string
-    let publicToken: Contract
+    let publicToken: ERC20DecimalsMock
     let publicTokenAddress: string
+    let oracle: CotiPriceConsumerMock
     let owner: Wallet
     let user: Wallet
-    /** Fee recipient when only two funded accounts exist in `.env` (same as `owner`). */
     let feeRecipient: Wallet
 
-    const INITIAL_SUPPLY = 1000000n
-    const DEPOSIT_AMOUNT = 10000n
-    const ONE_PERCENT_FEE = 100n // 100 basis points = 1%
-    const TEN_PERCENT_FEE = 1000n // 1000 basis points = 10%
-    const MAX_FEE = 1000n
+    const INITIAL_SUPPLY = parseUnits("1000000", 6)
+    const DEPOSIT_AMOUNT = parseUnits("10000", 6)
+
+    async function syncOracleAndEstimateDepositFee(amount: bigint) {
+        await (await oracle.sync()).wait()
+        return bridge.estimateDepositFee(amount)
+    }
+
+    async function syncOracleAndEstimateWithdrawFee(amount: bigint) {
+        await (await oracle.sync()).wait()
+        return bridge.estimateWithdrawFee(amount)
+    }
 
     before(async function () {
         ;[owner, user] = await setupAccounts()
         feeRecipient = owner
 
-        // Deploy public ERC20 token (mock)
-        const ERC20Factory = await hre.ethers.getContractFactory("ERC20Mock")
-        publicToken = await ERC20Factory.connect(owner).deploy("Public Token", "PUB", txOpts)
+        const PublicFactory = await hre.ethers.getContractFactory("ERC20DecimalsMock")
+        publicToken = await PublicFactory.connect(owner).deploy("Public Token", "PUB", 6, txOpts)
         await publicToken.waitForDeployment()
         publicTokenAddress = await publicToken.getAddress()
 
-        // Mint tokens to owner and user
         await publicToken.mint(owner.address, INITIAL_SUPPLY, { gasLimit: GAS_LIMIT })
         await publicToken.mint(user.address, INITIAL_SUPPLY, { gasLimit: GAS_LIMIT })
 
-        // Deploy private ERC20 token
         const PrivateERC20Factory = await hre.ethers.getContractFactory("PrivateERC20Mock")
         privateToken = await PrivateERC20Factory.connect(owner).deploy(txOpts)
         await privateToken.waitForDeployment()
         privateTokenAddress = await privateToken.getAddress()
 
-        // Deploy bridge
+        const OracleFactory = await hre.ethers.getContractFactory("CotiPriceConsumerMock")
+        oracle = await OracleFactory.connect(owner).deploy(txOpts)
+        await oracle.waitForDeployment()
+        await (await oracle.setRate("COTI", parseEther("1"))).wait()
+        await (await oracle.setRate("USDC", parseEther("1"))).wait()
+        const oracleAddress = await oracle.getAddress()
+
         const BridgeFactory = await hre.ethers.getContractFactory("PrivacyBridgeERC20Mock")
-        bridge = await BridgeFactory.connect(owner).deploy(publicTokenAddress, privateTokenAddress, txOpts)
+        bridge = await BridgeFactory.connect(owner).deploy(
+            publicTokenAddress,
+            privateTokenAddress,
+            "USDC",
+            feeRecipient.address,
+            feeRecipient.address,
+            oracleAddress,
+            txOpts
+        )
         await bridge.waitForDeployment()
         bridgeAddress = await bridge.getAddress()
 
-        // Fund bridge with public tokens for withdrawals
         await publicToken.connect(owner).transfer(bridgeAddress, INITIAL_SUPPLY / 2n, { gasLimit: GAS_LIMIT })
+
+        await owner.sendTransaction({ to: user.address, value: parseEther("50") })
     })
 
-    describe("Fee Configuration", function () {
-        it("should have zero fees by default", async function () {
-            expect(await bridge.depositFeeBasisPoints()).to.equal(0n)
-            expect(await bridge.withdrawFeeBasisPoints()).to.equal(0n)
+    describe("Default dynamic fee parameters", function () {
+        it("exposes deposit/withdraw floor, percentage divisor scale, and caps", async function () {
+            expect(await bridge.depositFixedFee()).to.equal(parseEther("10"))
+            expect(await bridge.depositPercentageBps()).to.equal(500n)
+            expect(await bridge.depositMaxFee()).to.equal(parseEther("3000"))
+            expect(await bridge.withdrawFixedFee()).to.equal(parseEther("3"))
+            expect(await bridge.withdrawPercentageBps()).to.equal(250n)
+            expect(await bridge.FEE_DIVISOR()).to.equal(1_000_000n)
         })
+    })
 
-        it("should allow owner to set deposit fee", async function () {
-            const tx = await bridge.connect(owner).setDepositFee(ONE_PERCENT_FEE, { gasLimit: GAS_LIMIT })
-            await tx.wait()
-
-            expect(await bridge.depositFeeBasisPoints()).to.equal(ONE_PERCENT_FEE)
-            await expect(tx).to.emit(bridge, "FeeUpdated").withArgs("deposit", ONE_PERCENT_FEE)
+    describe("Oracle and estimates", function () {
+        it("reverts deploy when price oracle is zero", async function () {
+            const freshFactory = await hre.ethers.getContractFactory("PrivacyBridgeERC20Mock")
+            await expect(
+                freshFactory
+                    .connect(owner)
+                    .deploy(
+                        publicTokenAddress,
+                        privateTokenAddress,
+                        "USDC",
+                        feeRecipient.address,
+                        feeRecipient.address,
+                        ZeroAddress,
+                        txOpts
+                    )
+            ).to.be.revertedWithCustomError(bridge, "InvalidAddress")
         })
 
-        it("should allow owner to set withdrawal fee", async function () {
-            const tx = await bridge.connect(owner).setWithdrawFee(ONE_PERCENT_FEE, { gasLimit: GAS_LIMIT })
-            await tx.wait()
-
-            expect(await bridge.withdrawFeeBasisPoints()).to.equal(ONE_PERCENT_FEE)
-            await expect(tx).to.emit(bridge, "FeeUpdated").withArgs("withdraw", ONE_PERCENT_FEE)
+        it("reverts setMaxOracleAge(0)", async function () {
+            await expect(bridge.connect(owner).setMaxOracleAge(0n, { gasLimit: GAS_LIMIT })).to.be.revertedWithCustomError(
+                bridge,
+                "OracleMaxAgeZeroDisallowed"
+            )
         })
 
-        it("should allow setting fee to zero", async function () {
-            const tx = await bridge.connect(owner).setDepositFee(0n, { gasLimit: GAS_LIMIT })
-            await tx.wait()
-
-            expect(await bridge.depositFeeBasisPoints()).to.equal(0n)
+        it("estimateDepositFee returns fee and timestamps", async function () {
+            const [fee, cotiLu, tokenLu] = await syncOracleAndEstimateDepositFee(DEPOSIT_AMOUNT)
+            expect(fee).to.be.gt(0n)
+            expect(cotiLu).to.equal(tokenLu)
         })
+    })
 
-        it("should allow setting fee to maximum (10%)", async function () {
-            const tx = await bridge.connect(owner).setDepositFee(MAX_FEE, { gasLimit: GAS_LIMIT })
+    describe("Operator fee configuration", function () {
+        it("allows operator to set deposit dynamic fee and emits DynamicFeeUpdated", async function () {
+            const fixedFee = parseEther("2")
+            const pct = 1000n
+            const maxFee = parseEther("500")
+            const tx = await bridge.connect(owner).setDepositDynamicFee(fixedFee, pct, maxFee, { gasLimit: GAS_LIMIT })
             await tx.wait()
-
-            expect(await bridge.depositFeeBasisPoints()).to.equal(MAX_FEE)
-        })
-
-        it("should revert when fee exceeds maximum", async function () {
-            await expect(
-                bridge.connect(owner).setDepositFee(MAX_FEE + 1n, { gasLimit: GAS_LIMIT })
-            ).to.be.revertedWithCustomError(bridge, "InvalidFee")
+            expect(await bridge.depositFixedFee()).to.equal(fixedFee)
+            expect(await bridge.depositPercentageBps()).to.equal(pct)
+            expect(await bridge.depositMaxFee()).to.equal(maxFee)
+            await expect(tx)
+                .to.emit(bridge, "DynamicFeeUpdated")
+                .withArgs("deposit", fixedFee, pct, maxFee)
         })
 
-        it("should revert when non-owner tries to set deposit fee", async function () {
+        it("reverts when non-operator sets deposit dynamic fee", async function () {
+            const opRole = await bridge.OPERATOR_ROLE()
             await expect(
-                bridge.connect(user).setDepositFee(ONE_PERCENT_FEE, { gasLimit: GAS_LIMIT })
-            ).to.be.revertedWithCustomError(bridge, "OwnableUnauthorizedAccount")
+                bridge.connect(user).setDepositDynamicFee(parseEther("1"), 100n, parseEther("100"), {
+                    gasLimit: GAS_LIMIT,
+                })
+            )
+                .to.be.revertedWithCustomError(bridge, "AccessControlUnauthorizedAccount")
+                .withArgs(user.address, opRole)
         })
 
-        it("should revert when non-owner tries to set withdraw fee", async function () {
+        it("reverts InvalidFee when percentage exceeds MAX_FEE_UNITS", async function () {
+            const maxUnits = await bridge.MAX_FEE_UNITS()
             await expect(
-                bridge.connect(user).setWithdrawFee(ONE_PERCENT_FEE, { gasLimit: GAS_LIMIT })
-            ).to.be.revertedWithCustomError(bridge, "OwnableUnauthorizedAccount")
+                bridge.connect(owner).setDepositDynamicFee(parseEther("1"), maxUnits + 1n, parseEther("1000"), {
+                    gasLimit: GAS_LIMIT,
+                })
+            ).to.be.revertedWithCustomError(bridge, "InvalidFee")
         })
 
-        // Reset fees to zero for next tests
         after(async function () {
-            await bridge.connect(owner).setDepositFee(0n, { gasLimit: GAS_LIMIT })
-            await bridge.connect(owner).setWithdrawFee(0n, { gasLimit: GAS_LIMIT })
+            await bridge
+                .connect(owner)
+                .setDepositDynamicFee(parseEther("10"), 500n, parseEther("3000"), { gasLimit: GAS_LIMIT })
         })
     })
 
-    describe("Deposit with Fees", function () {
-        it("should deposit without fee when fee is zero", async function () {
-            const balanceBefore = await publicToken.balanceOf(user.address)
+    describe("Deposit with native COTI fee", function () {
+        it("collects dynamic native fee into accumulatedCotiFees and credits liability", async function () {
+            const feesBefore = await bridge.accumulatedCotiFees()
+            const liabilityBefore = await bridge.totalUserLiability()
 
-            await publicToken.connect(user).approve(bridgeAddress, DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
-            const tx = await bridge.connect(user).deposit(DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
-            await tx.wait()
-
-            const balanceAfter = await publicToken.balanceOf(user.address)
-            expect(balanceBefore - balanceAfter).to.equal(DEPOSIT_AMOUNT)
-
-            // User should receive full amount in private tokens
-            const ctBalance = await privateToken["balanceOf(address)"](user.address)
-            const privateBalance = await user.decryptValue256(ctBalance)
-            expect(privateBalance).to.equal(DEPOSIT_AMOUNT)
-
-            expect(await bridge.accumulatedFees()).to.equal(0n)
-        })
-
-        it("should deduct 1% fee on deposit", async function () {
-            // Set 1% fee
-            await bridge.connect(owner).setDepositFee(ONE_PERCENT_FEE, { gasLimit: GAS_LIMIT })
-
-            const expectedFee = (DEPOSIT_AMOUNT * ONE_PERCENT_FEE) / 10000n
-            const expectedAmount = DEPOSIT_AMOUNT - expectedFee
+            const [fee, cotiTs, tokenTs] = await syncOracleAndEstimateDepositFee(DEPOSIT_AMOUNT)
+            expect(fee).to.be.gt(0n)
 
             await publicToken.connect(user).approve(bridgeAddress, DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
-            const tx = await bridge.connect(user).deposit(DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
+            const tx = await bridge
+                .connect(user)
+                .deposit(DEPOSIT_AMOUNT, cotiTs, tokenTs, { gasLimit: GAS_LIMIT, value: fee })
             await tx.wait()
 
-            // User should receive amount minus fee
-            const ctBalance = await privateToken["balanceOf(address)"](user.address)
-            const privateBalance = await user.decryptValue256(ctBalance)
-            expect(privateBalance).to.equal(DEPOSIT_AMOUNT + expectedAmount) // Previous deposit + this one
-
-            expect(await bridge.accumulatedFees()).to.equal(expectedFee)
+            expect(await bridge.accumulatedCotiFees()).to.equal(feesBefore + fee)
+            expect(await bridge.totalUserLiability()).to.equal(liabilityBefore + DEPOSIT_AMOUNT)
+            await expect(tx).to.emit(bridge, "Deposit")
         })
 
-        it("should deduct 10% fee on deposit", async function () {
-            // Set 10% fee
-            await bridge.connect(owner).setDepositFee(TEN_PERCENT_FEE, { gasLimit: GAS_LIMIT })
-
-            const previousFees = await bridge.accumulatedFees()
-            const expectedFee = (DEPOSIT_AMOUNT * TEN_PERCENT_FEE) / 10000n
-            const expectedAmount = DEPOSIT_AMOUNT - expectedFee
-
+        it("reverts deposit when msg.value is below computed fee", async function () {
+            const [, cotiTs, tokenTs] = await syncOracleAndEstimateDepositFee(DEPOSIT_AMOUNT)
             await publicToken.connect(user).approve(bridgeAddress, DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
-            const tx = await bridge.connect(user).deposit(DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
-            await tx.wait()
-
-            expect(await bridge.accumulatedFees()).to.equal(previousFees + expectedFee)
-        })
-
-        // Reset fee to zero
-        after(async function () {
-            await bridge.connect(owner).setDepositFee(0n, { gasLimit: GAS_LIMIT })
+            await expect(
+                bridge.connect(user).deposit(DEPOSIT_AMOUNT, cotiTs, tokenTs, {
+                    gasLimit: GAS_LIMIT,
+                    value: 1n,
+                })
+            ).to.be.revertedWithCustomError(bridge, "InsufficientCotiFee")
         })
     })
 
-    describe("Withdraw with Fees (via onTokenReceived)", function () {
-        const WITHDRAW_AMOUNT = 5000n
-
-        before(async function () {
-            // Ensure user has private tokens to withdraw
-            const ctBalance = await privateToken["balanceOf(address)"](user.address)
-            const balance = await user.decryptValue256(ctBalance)
-            if (balance < WITHDRAW_AMOUNT) {
-                await publicToken.connect(user).approve(bridgeAddress, DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
-                await bridge.connect(user).deposit(DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
-            }
-        })
-
-        it("should withdraw without fee when fee is zero", async function () {
-            const publicBalanceBefore = await publicToken.balanceOf(user.address)
-
-            const tx = await privateToken.connect(user).transferAndCall(
-                bridgeAddress,
-                WITHDRAW_AMOUNT,
-                "0x",
-                { gasLimit: GAS_LIMIT }
-            )
+    describe("withdrawCotiFees", function () {
+        it("allows owner to sweep accumulated native fees to feeRecipient", async function () {
+            const accumulated = await bridge.accumulatedCotiFees()
+            expect(accumulated).to.be.gt(0n)
+            const recipientBalBefore = await hre.ethers.provider.getBalance(feeRecipient.address)
+            const tx = await bridge.connect(owner).withdrawCotiFees(accumulated, { gasLimit: GAS_LIMIT })
             await tx.wait()
-
-            const publicBalanceAfter = await publicToken.balanceOf(user.address)
-            expect(publicBalanceAfter - publicBalanceBefore).to.equal(WITHDRAW_AMOUNT)
-
-            // No fees accumulated
-            expect(await bridge.accumulatedFees()).to.be.greaterThan(0n) // From previous deposit tests
-        })
-
-        it("should deduct 1% fee on withdrawal", async function () {
-            // Set 1% fee
-            await bridge.connect(owner).setWithdrawFee(ONE_PERCENT_FEE, { gasLimit: GAS_LIMIT })
-
-            const previousFees = await bridge.accumulatedFees()
-            const expectedFee = (WITHDRAW_AMOUNT * ONE_PERCENT_FEE) / 10000n
-            const expectedAmount = WITHDRAW_AMOUNT - expectedFee
-
-            const publicBalanceBefore = await publicToken.balanceOf(user.address)
-
-            const tx = await privateToken.connect(user).transferAndCall(
-                bridgeAddress,
-                WITHDRAW_AMOUNT,
-                "0x",
-                { gasLimit: GAS_LIMIT }
-            )
-            await tx.wait()
-
-            const publicBalanceAfter = await publicToken.balanceOf(user.address)
-            expect(publicBalanceAfter - publicBalanceBefore).to.equal(expectedAmount)
-
-            expect(await bridge.accumulatedFees()).to.equal(previousFees + expectedFee)
+            const recipientBalAfter = await hre.ethers.provider.getBalance(feeRecipient.address)
+            expect(recipientBalAfter - recipientBalBefore).to.equal(accumulated)
+            expect(await bridge.accumulatedCotiFees()).to.equal(0n)
         })
 
-        it("should deduct 10% fee on withdrawal", async function () {
-            // Set 10% fee
-            await bridge.connect(owner).setWithdrawFee(TEN_PERCENT_FEE, { gasLimit: GAS_LIMIT })
-
-            const previousFees = await bridge.accumulatedFees()
-            const expectedFee = (WITHDRAW_AMOUNT * TEN_PERCENT_FEE) / 10000n
-            const expectedAmount = WITHDRAW_AMOUNT - expectedFee
-
-            const publicBalanceBefore = await publicToken.balanceOf(user.address)
-
-            const tx = await privateToken.connect(user).transferAndCall(
-                bridgeAddress,
-                WITHDRAW_AMOUNT,
-                "0x",
-                { gasLimit: GAS_LIMIT }
-            )
-            await tx.wait()
-
-            const publicBalanceAfter = await publicToken.balanceOf(user.address)
-            expect(publicBalanceAfter - publicBalanceBefore).to.equal(expectedAmount)
-
-            expect(await bridge.accumulatedFees()).to.equal(previousFees + expectedFee)
+        it("reverts withdrawCotiFees for non-owner", async function () {
+            await expect(
+                bridge.connect(user).withdrawCotiFees(1n, { gasLimit: GAS_LIMIT })
+            ).to.be.revertedWithCustomError(bridge, "OwnableUnauthorizedAccount")
         })
 
-        // Reset fee to zero
-        after(async function () {
-            await bridge.connect(owner).setWithdrawFee(0n, { gasLimit: GAS_LIMIT })
+        it("reverts withdrawCotiFees with zero amount", async function () {
+            await expect(
+                bridge.connect(owner).withdrawCotiFees(0n, { gasLimit: GAS_LIMIT })
+            ).to.be.revertedWithCustomError(bridge, "AmountZero")
         })
     })
 
-    describe("Fee Withdrawal", function () {
-        it("should allow owner to withdraw accumulated fees", async function () {
-            const accumulatedFees = await bridge.accumulatedFees()
-            expect(accumulatedFees).to.be.greaterThan(0n)
-
-            const recipientBalanceBefore = await publicToken.balanceOf(feeRecipient.address)
-
-            const tx = await bridge.connect(owner).withdrawFees(
-                feeRecipient.address,
-                accumulatedFees,
-                { gasLimit: GAS_LIMIT }
-            )
-            await tx.wait()
-
-            const recipientBalanceAfter = await publicToken.balanceOf(feeRecipient.address)
-            expect(recipientBalanceAfter - recipientBalanceBefore).to.equal(accumulatedFees)
-
-            expect(await bridge.accumulatedFees()).to.equal(0n)
-            await expect(tx).to.emit(bridge, "FeesWithdrawn").withArgs(feeRecipient.address, accumulatedFees)
-        })
-
-        it("should allow partial withdrawal of fees", async function () {
-            // Accumulate some fees first
-            await bridge.connect(owner).setDepositFee(ONE_PERCENT_FEE, { gasLimit: GAS_LIMIT })
+    describe("Withdraw path (native fee + public token)", function () {
+        before(async function () {
+            const [fee, cotiTs, tokenTs] = await syncOracleAndEstimateDepositFee(DEPOSIT_AMOUNT)
             await publicToken.connect(user).approve(bridgeAddress, DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
-            await bridge.connect(user).deposit(DEPOSIT_AMOUNT, { gasLimit: GAS_LIMIT })
-
-            const accumulatedFees = await bridge.accumulatedFees()
-            const withdrawAmount = accumulatedFees / 2n
-
-            await bridge.connect(owner).withdrawFees(feeRecipient.address, withdrawAmount, { gasLimit: GAS_LIMIT })
-
-            expect(await bridge.accumulatedFees()).to.equal(accumulatedFees - withdrawAmount)
-
-            // Reset
-            await bridge.connect(owner).setDepositFee(0n, { gasLimit: GAS_LIMIT })
+            await bridge.connect(user).deposit(DEPOSIT_AMOUNT, cotiTs, tokenTs, {
+                gasLimit: GAS_LIMIT,
+                value: fee,
+            })
         })
 
-        it("should revert when non-owner tries to withdraw fees", async function () {
-            await expect(
-                bridge.connect(user).withdrawFees(feeRecipient.address, 100n, { gasLimit: GAS_LIMIT })
-            ).to.be.revertedWithCustomError(bridge, "OwnableUnauthorizedAccount")
-        })
+        it("withdraw burns private and releases public after paying native fee", async function () {
+            const withdrawAmount = parseUnits("1000", 6)
+            const [wFee, cotiTs2, tokenTs2] = await syncOracleAndEstimateWithdrawFee(withdrawAmount)
 
-        it("should revert when withdrawing to zero address", async function () {
-            await expect(
-                bridge.connect(owner).withdrawFees(hre.ethers.ZeroAddress, 100n, { gasLimit: GAS_LIMIT })
-            ).to.be.revertedWithCustomError(bridge, "InvalidAddress")
-        })
+            await privateToken.connect(user).approve(bridgeAddress, withdrawAmount, { gasLimit: GAS_LIMIT })
 
-        it("should revert when withdrawing zero amount", async function () {
-            await expect(
-                bridge.connect(owner).withdrawFees(feeRecipient.address, 0n, { gasLimit: GAS_LIMIT })
-            ).to.be.revertedWithCustomError(bridge, "AmountZero")
-        })
-
-        it("should revert when withdrawing more than accumulated fees", async function () {
-            const accumulatedFees = await bridge.accumulatedFees()
-            await expect(
-                bridge.connect(owner).withdrawFees(feeRecipient.address, accumulatedFees + 1n, { gasLimit: GAS_LIMIT })
-            ).to.be.revertedWithCustomError(bridge, "InsufficientAccumulatedFees")
+            const publicBefore = await publicToken.balanceOf(user.address)
+            const tx = await bridge.connect(user).withdraw(withdrawAmount, cotiTs2, tokenTs2, {
+                gasLimit: GAS_LIMIT,
+                value: wFee,
+            })
+            await tx.wait()
+            const publicAfter = await publicToken.balanceOf(user.address)
+            expect(publicAfter - publicBefore).to.equal(withdrawAmount)
         })
     })
 })