@coti-io/coti-contracts 1.1.0 → 1.2.0

package/contracts/utils/mpc/MpcInterface.sol

@@ -1,15 +1,18 @@
 // SPDX-License-Identifier: MIT
-
-pragma solidity ^0.8.19;
+pragma solidity 0.8.19;
 
 interface ExtendedOperations {
 
     function OnBoard(bytes1 metaData, uint256 ct) external returns (uint256 result);
+    function OnBoard(bytes1 metaData, uint256 ctHigh, uint256 ctLow) external returns (uint256 result);
     function OffBoard(bytes1 metaData, uint256 ct) external returns (uint256 result);
+    function OffBoard256(bytes1 metaData, uint256 gt) external returns (uint256 ctHigh, uint256 ctLow);
     function OffBoardToUser(bytes1 metaData, uint256 ct, bytes calldata addr) external returns (uint256 result);
+    function OffBoardToUser256(bytes1 metaData, uint256 ct, bytes calldata addr) external returns (uint256 ctHigh, uint256 ctLow);
     function SetPublic(bytes1 metaData, uint256 ct) external returns (uint256 result);
     function Rand(bytes1 metaData) external returns (uint256 result);
     function RandBoundedBits(bytes1 metaData, uint8 numBits) external returns (uint256 result);
+
     function Add(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
     function CheckedAdd(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 overflowBit, uint256 result);
     function Sub(bytes3 metaData, uint256 lhs, uint256 rhs) external returns (uint256 result);
@@ -37,8 +40,10 @@ interface ExtendedOperations {
     function Transfer(bytes4 metaData, uint256 a, uint256 b, uint256 amount) external returns (uint256 new_a, uint256 new_b, uint256 res);
     function TransferWithAllowance(bytes5 metaData, uint256 a, uint256 b, uint256 amount, uint256 allowance) external returns (uint256 new_a, uint256 new_b, uint256 res, uint256 new_allowance);
     function ValidateCiphertext(bytes1 metaData, uint256 ciphertext, bytes calldata signature) external returns (uint256 result);
+    function ValidateCiphertext(bytes1 metaData, uint256 ciphertextHigh, uint256 ciphertextLow, bytes calldata signature) external returns (uint256 result);
     function GetUserKey(bytes calldata signedEK) external returns (bytes memory encryptedKey);
     function SHA256Fixed432BitInput(uint256 amount, uint256 seed1, uint256 seed2, uint256 padding1, uint256 padding2, bytes calldata addr) external returns (bytes memory result);
 }
 
 address constant MPC_PRECOMPILE = address(0x0000000000000000000000000000000000000064);
+

package/hardhat/gasPriceBump.ts

@@ -0,0 +1,60 @@
+import { extendProvider } from "hardhat/config";
+import type { EIP1193Provider } from "hardhat/types";
+
+/** Networks where RPC fee hints are multiplied by this factor (130% = +30%). */
+const GAS_PRICE_MULTIPLIER_NUM = 130n;
+const GAS_PRICE_MULTIPLIER_DEN = 100n;
+
+const NETWORKS_WITH_BUMP = new Set(["coti-testnet", "coti-mainnet"]);
+
+function bumpHexFee(value: unknown): unknown {
+    if (typeof value !== "string" || !value.startsWith("0x")) {
+        return value;
+    }
+    const v = BigInt(value);
+    const bumped = (v * GAS_PRICE_MULTIPLIER_NUM) / GAS_PRICE_MULTIPLIER_DEN;
+    return "0x" + bumped.toString(16);
+}
+
+function bumpBlockFeeFields(block: unknown): unknown {
+    if (!block || typeof block !== "object") {
+        return block;
+    }
+    const b = block as Record<string, unknown>;
+    const out = { ...b };
+    if (typeof b.baseFeePerGas === "string") {
+        out.baseFeePerGas = bumpHexFee(b.baseFeePerGas);
+    }
+    return out;
+}
+
+extendProvider((provider: EIP1193Provider, _config, network: string) => {
+    if (!NETWORKS_WITH_BUMP.has(network)) {
+        return provider;
+    }
+
+    const originalRequest = provider.request.bind(provider);
+
+    const wrapped: EIP1193Provider = Object.assign(
+        Object.create(Object.getPrototypeOf(provider)),
+        provider,
+        {
+            request: async (args: { method: string; params?: readonly unknown[] | object }) => {
+                const result = await originalRequest(args);
+                const method = args.method;
+
+                if (method === "eth_gasPrice" || method === "eth_maxPriorityFeePerGas") {
+                    return bumpHexFee(result);
+                }
+
+                if (method === "eth_getBlockByNumber" || method === "eth_getBlockByHash") {
+                    return bumpBlockFeeFields(result);
+                }
+
+                return result;
+            },
+        }
+    );
+
+    return wrapped;
+});

package/hardhat.config.ts

@@ -1,36 +1,84 @@
 import { HardhatUserConfig } from "hardhat/config";
 import "@nomicfoundation/hardhat-toolbox";
+import "@nomicfoundation/hardhat-verify";
 
 import dotenv from "dotenv"
 dotenv.config()
 
+/** Bump estimated gas price / EIP-1559 fees by 30% on COTI networks (see hardhat/gasPriceBump.ts). */
+import "./hardhat/gasPriceBump"
+
+const accounts = process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [];
+
 const config: HardhatUserConfig = {
   defaultNetwork: "coti-testnet",
   solidity: {
-    version: "0.8.19",
-    settings: {
-      optimizer: {
-        enabled: true,
-        runs: 10000
+    compilers: [
+      {
+        version: "0.8.20",
+        settings: {
+          optimizer: {
+            enabled: true,
+            runs: 10000
+          },
+          metadata: {
+            // do not include the metadata hash, since this is machine dependent
+            // and we want all generated code to be deterministic
+            // https://docs.soliditylang.org/en/v0.7.6/metadata.html
+            bytecodeHash: 'none',
+          },
+        }
       },
-      metadata: {
-        // do not include the metadata hash, since this is machine dependent
-        // and we want all generated code to be deterministic
-        // https://docs.soliditylang.org/en/v0.7.6/metadata.html
-        bytecodeHash: 'none',
-      },
-    }
+      {
+        version: "0.8.19",
+        settings: {
+          optimizer: {
+            enabled: true,
+            runs: 10000
+          },
+          metadata: {
+            bytecodeHash: 'none',
+          },
+        }
+      }
+    ]
   },
   networks: {
     "coti-testnet": {
       url: "https://testnet.coti.io/rpc",
       chainId: 7082400,
+      accounts,
     },
     "coti-mainnet": {
       url: "https://mainnet.coti.io/rpc",
       chainId: 2632500,
+      accounts,
     },
   },
+  etherscan: {
+    apiKey: {
+      "coti-testnet": "placeholder",
+      "coti-mainnet": "placeholder",
+    },
+    customChains: [
+      {
+        network: "coti-testnet",
+        chainId: 7082400,
+        urls: {
+          apiURL: "https://testnet.cotiscan.io/api",
+          browserURL: "https://testnet.cotiscan.io/",
+        },
+      },
+      {
+        network: "coti-mainnet",
+        chainId: 2632500,
+        urls: {
+          apiURL: "https://cotiscan.io/api",
+          browserURL: "https://cotiscan.io/",
+        },
+      },
+    ],
+  },
   mocha: {
     timeout: 100000000
   },

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@coti-io/coti-contracts",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A library for smart contract development on the COTI network.",
   "author": "COTI Development",
   "repository": {
     "type": "git",
-    "url": "git://github.com/coti-io/coti-contracts.git"
+    "url": "https://github.com/coti-io/coti-contracts.git"
   },
   "homepage": "https://docs.coti.io/coti-v2-documentation/build-on-coti/tools/contracts-library",
   "keywords": [
@@ -19,11 +19,29 @@
     "on-chain-compute"
   ],
   "devDependencies": {
+    "@nomicfoundation/hardhat-chai-matchers": "^2.1.0",
+    "@nomicfoundation/hardhat-ethers": "^3.1.0",
+    "@nomicfoundation/hardhat-ignition": "^0.15.0",
+    "@nomicfoundation/hardhat-ignition-ethers": "^0.15.0",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
     "@nomicfoundation/hardhat-toolbox": "^5.0.0",
-    "hardhat": "^2.22.8"
+    "@nomicfoundation/hardhat-verify": "^2.0.1",
+    "@nomicfoundation/ignition-core": "^0.15.0",
+    "@typechain/ethers-v6": "^0.5.1",
+    "@typechain/hardhat": "^9.1.0",
+    "@types/chai": "^4.2.0",
+    "@types/mocha": "^10.0.10",
+    "chai": "^4.2.0",
+    "hardhat": "^2.22.8",
+    "hardhat-gas-reporter": "^1.0.8",
+    "solidity-coverage": "^0.8.16",
+    "ts-node": "^10.9.2",
+    "typechain": "^8.3.2",
+    "typescript": "^5.9.3"
   },
   "dependencies": {
     "@coti-io/coti-ethers": "^1.0.5",
+    "@coti-io/coti-sdk-typescript": "^1.0.6",
     "@openzeppelin/contracts": "^4.9.6",
     "dotenv": "^16.4.5"
   }

package/scripts/deploySoulboundNodeNFT.ts

@@ -0,0 +1,57 @@
+import { ethers } from "hardhat";
+
+async function main() {
+  const [deployer] = await ethers.getSigners();
+  if (!deployer) {
+    throw new Error(
+      "No deployer signer found. Set PRIVATE_KEY in your environment."
+    );
+  }
+
+  const owner = process.env.NFT_OWNER || deployer.address;
+  const name = process.env.NFT_NAME || "Soulbound Node NFT";
+  const symbol = process.env.NFT_SYMBOL || "SNODE";
+
+  console.log("Deploying SoulboundNodeNFT...");
+  console.log("Deployer:", deployer.address);
+  console.log("Owner:", owner);
+  console.log("Name:", name);
+  console.log("Symbol:", symbol);
+
+  const provider = deployer.provider;
+  if (!provider) {
+    throw new Error("No provider found for deployer signer.");
+  }
+
+  // COTI testnet RPC may not support "pending" block queries.
+  // Use legacy gas price + latest nonce + explicit gas limit to avoid
+  // pending-based fee/nonce/gas estimation lookups.
+  const gasPrice = BigInt(await provider.send("eth_gasPrice", []));
+  const nonce = await provider.getTransactionCount(deployer.address, "latest");
+  const gasLimit = BigInt(process.env.NFT_DEPLOY_GAS_LIMIT || "6000000");
+
+  const factory = await ethers.getContractFactory("SoulboundNodeNFT");
+  const deployTxReq = await factory.getDeployTransaction(name, symbol, owner);
+  if (!deployTxReq.data) {
+    throw new Error("Failed to build deploy transaction data.");
+  }
+
+  const sentTx = await deployer.sendTransaction({
+    data: deployTxReq.data,
+    gasPrice,
+    nonce,
+    gasLimit,
+  });
+  console.log("Deployment tx hash:", sentTx.hash);
+  const receipt = await sentTx.wait();
+  if (!receipt || !receipt.contractAddress) {
+    throw new Error("Deployment transaction mined but no contract address found.");
+  }
+
+  console.log("SoulboundNodeNFT deployed at:", receipt.contractAddress);
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exitCode = 1;
+});

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

@@ -0,0 +1,327 @@
+import hre from "hardhat"
+import { expect } from "chai"
+import { setupAccounts } from "../../utils/accounts"
+import { PrivacyBridgeERC20Mock, PrivateERC20Mock } from "../../../typechain-types"
+import { Wallet } from "@coti-io/coti-ethers"
+import { Contract } from "ethers"
+import { txOpts } from "../../utils/privateErc20Helpers"
+
+const GAS_LIMIT = 12000000
+
+describe("PrivacyBridge Fees", function () {
+    let bridge: PrivacyBridgeERC20Mock
+    let bridgeAddress: string
+    let privateToken: PrivateERC20Mock
+    let privateTokenAddress: string
+    let publicToken: Contract
+    let publicTokenAddress: string
+    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
+
+    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)
+        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 BridgeFactory = await hre.ethers.getContractFactory("PrivacyBridgeERC20Mock")
+        bridge = await BridgeFactory.connect(owner).deploy(publicTokenAddress, privateTokenAddress, 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 })
+    })
+
+    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)
+        })
+
+        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)
+        })
+
+        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("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("should allow setting fee to maximum (10%)", async function () {
+            const tx = await bridge.connect(owner).setDepositFee(MAX_FEE, { 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")
+        })
+
+        it("should revert when non-owner tries to set deposit fee", async function () {
+            await expect(
+                bridge.connect(user).setDepositFee(ONE_PERCENT_FEE, { gasLimit: GAS_LIMIT })
+            ).to.be.revertedWithCustomError(bridge, "OwnableUnauthorizedAccount")
+        })
+
+        it("should revert when non-owner tries to set withdraw fee", async function () {
+            await expect(
+                bridge.connect(user).setWithdrawFee(ONE_PERCENT_FEE, { gasLimit: GAS_LIMIT })
+            ).to.be.revertedWithCustomError(bridge, "OwnableUnauthorizedAccount")
+        })
+
+        // 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 })
+        })
+    })
+
+    describe("Deposit with Fees", function () {
+        it("should deposit without fee when fee is zero", async function () {
+            const balanceBefore = await publicToken.balanceOf(user.address)
+
+            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
+
+            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()
+
+            // 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)
+        })
+
+        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
+
+            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 })
+        })
+    })
+
+    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 }
+            )
+            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)
+        })
+
+        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)
+        })
+
+        // Reset fee to zero
+        after(async function () {
+            await bridge.connect(owner).setWithdrawFee(0n, { gasLimit: GAS_LIMIT })
+        })
+    })
+
+    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 })
+            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 })
+        })
+
+        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("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")
+        })
+
+        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")
+        })
+    })
+})