From d201e1475962239f2582e379e0d218430c957213 Mon Sep 17 00:00:00 2001
From: sirpy <hadar@gooddollar.org>
Date: Mon, 22 Dec 2025 17:04:55 +0200
Subject: [PATCH 01/37] wip: buy with stable/cusd

---
 contracts/utils/BuyGDClone.sol | 359 ++++++++++++++++++---------------
 1 file changed, 194 insertions(+), 165 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index 08f8659c..3a0787b0 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -8,11 +8,11 @@ import "../Interfaces.sol";
 
 /*
  * @title BuyGDClone
- * @notice This contract allows users to swap Celo or cUSD for GoodDollar (GD) tokens.
+ * @notice This contract allows users to swap Celo or stable for GoodDollar (GD) tokens.
  * @dev This contract is a clone of the BuyGD contract, which is used to buy GD tokens on the GoodDollar platform.
  * @dev This contract uses the SwapRouter contract to perform the swaps.
  */
-contract BuyGDClone is Initializable {
+contract BuyGDCloneV2 is Initializable {
 	error REFUND_FAILED(uint256);
 	error NO_BALANCE();
 
@@ -20,8 +20,10 @@ contract BuyGDClone is Initializable {
 
 	ISwapRouter public immutable router;
 	address public constant celo = 0x471EcE3750Da237f93B8E339c536989b8978a438;
+	address public constant CUSD = 0x765DE816845861e75A25fCA122bb6898B8B1282a;
+	uint24 public constant GD_FEE_TIER = 500;
 	uint32 public immutable twapPeriod;
-	address public immutable cusd;
+	address public immutable stable;
 	address public immutable gd;
 	IStaticOracle public immutable oracle;
 
@@ -31,12 +33,12 @@ contract BuyGDClone is Initializable {
 
 	constructor(
 		ISwapRouter _router,
-		address _cusd,
+		address _stable,
 		address _gd,
 		IStaticOracle _oracle
 	) {
 		router = _router;
-		cusd = _cusd;
+		stable = _stable;
 		gd = _gd;
 		oracle = _oracle;
 		twapPeriod = 300; //5 minutes
@@ -51,9 +53,9 @@ contract BuyGDClone is Initializable {
 	}
 
 	/**
-	 * @notice Swaps either Celo or cUSD for GD tokens.
+	 * @notice Swaps either Celo or stable for GD tokens.
 	 * @dev If the contract has a balance of Celo, it will swap Celo for GD tokens.
-	 * @dev If the contract has a balance of cUSD, it will swap cUSD for GD tokens.
+	 * @dev If the contract has a balance of stable, it will swap stable for GD tokens.
 	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
 	 */
 	function swap(
@@ -67,7 +69,7 @@ contract BuyGDClone is Initializable {
 			emit Bought(celo, balance, bought);
 			return bought;
 		}
-		balance = ERC20(cusd).balanceOf(address(this));
+		balance = ERC20(CUSD).balanceOf(address(this));
 		if (balance > 0) {
 			bought = swapCusd(_minAmount, refundGas);
 			emit Bought(celo, balance, bought);
@@ -86,11 +88,14 @@ contract BuyGDClone is Initializable {
 		address payable refundGas
 	) public payable returns (uint256 bought) {
 		uint256 gasCosts;
+		uint24[] memory fees = new uint24[](1);
+		fees[0] = 100;
 		if (refundGas != owner) {
-			(gasCosts, ) = oracle.quoteAllAvailablePoolsWithTimePeriod(
+			(gasCosts, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
 				1e17, //0.1$
-				cusd,
+				stable,
 				celo,
+				fees,
 				60
 			);
 		}
@@ -102,7 +107,7 @@ contract BuyGDClone is Initializable {
 
 		ERC20(celo).approve(address(router), amountIn);
 		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
-			path: abi.encodePacked(celo, uint24(3000), cusd, uint24(10000), gd),
+			path: abi.encodePacked(celo, uint24(100), stable, GD_FEE_TIER, gd),
 			recipient: owner,
 			amountIn: amountIn,
 			amountOutMinimum: _minAmount
@@ -115,7 +120,7 @@ contract BuyGDClone is Initializable {
 	}
 
 	/**
-	 * @notice Swaps cUSD for GD tokens.
+	 * @notice Swaps cusd for GD tokens.
 	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
 	 */
 	function swapCusd(
@@ -123,21 +128,27 @@ contract BuyGDClone is Initializable {
 		address refundGas
 	) public returns (uint256 bought) {
 		uint256 gasCosts = refundGas != owner ? 1e17 : 0; //fixed 0.1$
-		uint256 amountIn = ERC20(cusd).balanceOf(address(this)) - gasCosts;
+		uint256 amountIn = ERC20(CUSD).balanceOf(address(this)) - gasCosts;
 
-		(uint256 minByTwap, ) = minAmountByTWAP(amountIn, cusd, twapPeriod);
+		(uint256 minByTwap, ) = minAmountByTWAP(amountIn, CUSD, twapPeriod);
 		_minAmount = _minAmount > minByTwap ? _minAmount : minByTwap;
 
-		ERC20(cusd).approve(address(router), amountIn);
+		ERC20(CUSD).approve(address(router), amountIn);
+		bytes memory path;
+		if (stable == CUSD) {
+			path = abi.encodePacked(CUSD, GD_FEE_TIER, gd);
+		} else {
+			path = abi.encodePacked(CUSD, uint24(100), stable, GD_FEE_TIER, gd);
+		}
 		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
-			path: abi.encodePacked(cusd, uint24(10000), gd),
+			path: path,
 			recipient: owner,
 			amountIn: amountIn,
 			amountOutMinimum: _minAmount
 		});
 		bought = router.exactInput(params);
 		if (refundGas != owner) {
-			ERC20(cusd).transfer(refundGas, gasCosts);
+			ERC20(stable).transfer(refundGas, gasCosts);
 		}
 	}
 
@@ -154,21 +165,32 @@ contract BuyGDClone is Initializable {
 		uint32 period
 	) public view returns (uint256 minTwap, uint256 quote) {
 		uint24[] memory fees = new uint24[](1);
-		fees[0] = 10000;
+		fees[0] = 100;
 
 		uint128 toConvert = uint128(baseAmount);
 		if (baseToken == celo) {
-			(quote, ) = oracle.quoteAllAvailablePoolsWithTimePeriod(
+			(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
+				toConvert,
+				baseToken,
+				stable,
+				fees,
+				period
+			);
+			toConvert = uint128(quote);
+		} else if (baseToken == CUSD && stable != CUSD) {
+			(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
 				toConvert,
 				baseToken,
-				cusd,
+				stable,
+				fees,
 				period
 			);
 			toConvert = uint128(quote);
 		}
+		fees[0] = GD_FEE_TIER;
 		(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
 			toConvert,
-			cusd,
+			stable,
 			gd,
 			fees,
 			period
@@ -191,7 +213,7 @@ contract BuyGDClone is Initializable {
 	}
 }
 
-contract DonateGDClone is BuyGDClone {
+contract DonateGDClone is BuyGDCloneV2 {
 	error EXEC_FAILED(bytes error);
 
 	event Donated(
@@ -209,7 +231,7 @@ contract DonateGDClone is BuyGDClone {
 		address _cusd,
 		address _gd,
 		IStaticOracle _oracle
-	) BuyGDClone(_router, _cusd, _gd, _oracle) {}
+	) BuyGDCloneV2(_router, _cusd, _gd, _oracle) {}
 
 	/**
 	 * @notice Initializes the contract with the owner's address.
@@ -248,13 +270,13 @@ contract DonateGDClone is BuyGDClone {
 		//now exec
 		if (callData.length > 0) {
 			// approve spend of the different possible tokens, before calling the target contract
-			uint256 cusdBalance = ERC20(cusd).balanceOf(address(this));
+			uint256 cusdBalance = ERC20(CUSD).balanceOf(address(this));
 			uint256 gdBalance = ERC20(gd).balanceOf(address(this));
 			uint256 celoBalance = address(this).balance;
 
 			if (cusdBalance > 0) {
-				ERC20(cusd).approve(address(owner), cusdBalance);
-				token = cusd;
+				ERC20(CUSD).approve(address(owner), cusdBalance);
+				token = CUSD;
 				donated = cusdBalance;
 			}
 			if (gdBalance > 0) {
@@ -302,11 +324,12 @@ contract BuyGDCloneFactory {
 
 	IQuoterV2 public constant quoter =
 		IQuoterV2(0x82825d0554fA07f7FC52Ab63c961F330fdEFa8E8); // celo quoter
+	address public constant CUSD = 0x765DE816845861e75A25fCA122bb6898B8B1282a;
 
 	address public immutable impl;
 	address public immutable donateImpl;
 	address public immutable gd;
-	address public immutable cusd;
+	address public immutable stable;
 	IStaticOracle public immutable oracle;
 	ISwapRouter public immutable router;
 
@@ -321,23 +344,29 @@ contract BuyGDCloneFactory {
 	/**
 	 * @notice Initializes the BuyGDCloneFactory contract with the provided parameters.
 	 * @param _router The address of the SwapRouter contract.
-	 * @param _cusd The address of the cUSD token contract.
+	 * @param _stable The address of the stable token contract.
 	 * @param _gd The address of the GD token contract.
 	 * @param _oracle The address of the StaticOracle contract.
 	 */
 	constructor(
 		ISwapRouter _router,
-		address _cusd,
+		address _stable,
 		address _gd,
 		IStaticOracle _oracle
 	) {
-		impl = address(new BuyGDClone(_router, _cusd, _gd, _oracle));
-		donateImpl = address(new DonateGDClone(_router, _cusd, _gd, _oracle));
+		impl = address(new BuyGDCloneV2(_router, _stable, _gd, _oracle));
+		donateImpl = address(new DonateGDClone(_router, _stable, _gd, _oracle));
 		gd = _gd;
-		cusd = _cusd;
+		stable = _stable;
 		oracle = _oracle;
 		router = _router;
-		_oracle.prepareAllAvailablePoolsWithTimePeriod(_gd, _cusd, 600);
+		_oracle.prepareAllAvailablePoolsWithTimePeriod(_gd, _stable, 600); //stable/gd pools
+		_oracle.prepareAllAvailablePoolsWithTimePeriod(
+			address(0x471EcE3750Da237f93B8E339c536989b8978a438),
+			_stable,
+			600
+		); //celo/stable pools
+		_oracle.prepareAllAvailablePoolsWithTimePeriod(CUSD, _stable, 600); //cusd/stable pools
 	}
 
 	/**
@@ -348,7 +377,7 @@ contract BuyGDCloneFactory {
 	function create(address owner) public returns (address) {
 		bytes32 salt = keccak256(abi.encode(owner));
 		address clone = ClonesUpgradeable.cloneDeterministic(impl, salt);
-		BuyGDClone(payable(clone)).initialize(owner);
+		BuyGDCloneV2(payable(clone)).initialize(owner);
 		return clone;
 	}
 
@@ -376,7 +405,7 @@ contract BuyGDCloneFactory {
 		uint256 minAmount
 	) external returns (address) {
 		address clone = create(owner);
-		BuyGDClone(payable(clone)).swap(minAmount, payable(msg.sender));
+		BuyGDCloneV2(payable(clone)).swap(minAmount, payable(msg.sender));
 		return clone;
 	}
 
@@ -432,134 +461,134 @@ contract BuyGDCloneFactory {
 		return block.basefee;
 	}
 
-	function onTokenTransfer(
-		address from,
-		uint256 amount,
-		bytes calldata data
-	) external returns (bool) {
-		if (msg.sender != gd) revert NOT_GD_TOKEN();
-		(address to, uint256 minAmount, bytes memory note) = abi.decode(
-			data,
-			(address, uint256, bytes)
-		);
-		if (to == address(0)) revert RECIPIENT_ZERO();
-
-		uint256 amountIn = ERC20(gd).balanceOf(address(this));
-
-		uint256 amountReceived = swapToCusd(amountIn, minAmount, to);
-		emit GDSwapToCusd(from, to, amount, amountReceived, note);
-		return true;
-	}
-
-	/**
-	 * @notice Swaps cUSD for GD tokens.
-	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
-	 */
-	function swapToCusd(
-		uint256 amountIn,
-		uint256 _minAmount,
-		address recipient
-	) public returns (uint256) {
-		if (msg.sender != gd) {
-			ERC20(gd).transferFrom(msg.sender, address(this), amountIn);
-		}
-
-		if (_minAmount == 0)
-			(_minAmount, ) = minAmountByTWAP(amountIn, gd, cusd, 60);
-
-		ERC20(gd).approve(address(router), amountIn);
-		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
-			path: abi.encodePacked(gd, uint24(10000), cusd),
-			recipient: recipient,
-			amountIn: amountIn,
-			amountOutMinimum: _minAmount
-		});
-		return router.exactInput(params);
-	}
-
-	/**
-	 * @notice Swaps cUSD for GD tokens.
-	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
-	 */
-	function swapFromCusd(
-		uint256 amountIn,
-		uint256 _minAmount,
-		address recipient
-	) public returns (uint256) {
-		ERC20(cusd).transferFrom(msg.sender, address(this), amountIn);
-
-		if (_minAmount == 0)
-			(_minAmount, ) = minAmountByTWAP(amountIn, cusd, gd, 60);
-
-		ERC20(cusd).approve(address(router), amountIn);
-		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
-			path: abi.encodePacked(cusd, uint24(10000), gd),
-			recipient: recipient,
-			amountIn: amountIn,
-			amountOutMinimum: _minAmount
-		});
-		return router.exactInput(params);
-	}
-
-	/**
-	 * @notice Calculates the minimum amount of tokens that can be received for a given amount of base tokens,
-	 * based on the time-weighted average price (TWAP) of the token pair over a specified period of time.
-	 * @param baseAmount The amount of base tokens to swap.
-	 * @param baseToken The address of the base token.
-	 * @param qtToken The address of the quote token.
-
-	 * @return minTwap The minimum amount of G$ expected to receive by twap
-	 */
-	function minAmountByTWAP(
-		uint256 baseAmount,
-		address baseToken,
-		address qtToken,
-		uint32 period
-	) public view returns (uint256 minTwap, uint256 quote) {
-		uint24[] memory fees = new uint24[](1);
-		fees[0] = 10000;
-		uint128 toConvert = uint128(baseAmount);
-		(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
-			toConvert,
-			baseToken,
-			qtToken,
-			fees,
-			period
-		);
-
-		(uint256 curPrice, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
-			toConvert,
-			baseToken,
-			qtToken,
-			fees,
-			0
-		);
-
-		// (ie we dont expect price movement > 2% in timePeriod)
-		if ((quote * 98) / 100 > curPrice) {
-			revert INVALID_TWAP();
-		}
-		//minAmount should not be 2% under curPrice (including slippage and price impact)
-		//this is just a guesstimate, for accurate results use uniswap sdk to get price quote
-		//v3 price quote is not available on chain
-		return ((curPrice * 980) / 1000, quote);
-	}
-
-	function quoteCusd(uint256 amountIn) external returns (uint256 amountOut) {
-		return quoteToken(amountIn, 10000, cusd);
-	}
-
-	function quoteToken(
-		uint256 amountIn,
-		uint24 fee,
-		address targetToken
-	) public returns (uint256 amountOut) {
-		IQuoterV2.QuoteExactInputSingleParams memory params;
-		params.amountIn = amountIn;
-		params.tokenIn = gd;
-		params.tokenOut = targetToken;
-		params.fee = fee;
-
-		(amountOut, , , ) = quoter.quoteExactInputSingle(params);
-	}
+	// function onTokenTransfer(
+	// 	address from,
+	// 	uint256 amount,
+	// 	bytes calldata data
+	// ) external returns (bool) {
+	// 	if (msg.sender != gd) revert NOT_GD_TOKEN();
+	// 	(address to, uint256 minAmount, bytes memory note) = abi.decode(
+	// 		data,
+	// 		(address, uint256, bytes)
+	// 	);
+	// 	if (to == address(0)) revert RECIPIENT_ZERO();
+
+	// 	uint256 amountIn = ERC20(gd).balanceOf(address(this));
+
+	// 	uint256 amountReceived = swapToCusd(amountIn, minAmount, to);
+	// 	emit GDSwapToCusd(from, to, amount, amountReceived, note);
+	// 	return true;
+	// }
+
+	// /**
+	//  * @notice Swaps cUSD for GD tokens.
+	//  * @param _minAmount The minimum amount of GD tokens to receive from the swap.
+	//  */
+	// function swapToCusd(
+	// 	uint256 amountIn,
+	// 	uint256 _minAmount,
+	// 	address recipient
+	// ) public returns (uint256) {
+	// 	if (msg.sender != gd) {
+	// 		ERC20(gd).transferFrom(msg.sender, address(this), amountIn);
+	// 	}
+
+	// 	if (_minAmount == 0)
+	// 		(_minAmount, ) = minAmountByTWAP(amountIn, gd, cusd, 60);
+
+	// 	ERC20(gd).approve(address(router), amountIn);
+	// 	ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
+	// 		path: abi.encodePacked(gd, uint24(10000), cusd),
+	// 		recipient: recipient,
+	// 		amountIn: amountIn,
+	// 		amountOutMinimum: _minAmount
+	// 	});
+	// 	return router.exactInput(params);
+	// }
+
+	// /**
+	//  * @notice Swaps cUSD for GD tokens.
+	//  * @param _minAmount The minimum amount of GD tokens to receive from the swap.
+	//  */
+	// function swapFromCusd(
+	// 	uint256 amountIn,
+	// 	uint256 _minAmount,
+	// 	address recipient
+	// ) public returns (uint256) {
+	// 	ERC20(cusd).transferFrom(msg.sender, address(this), amountIn);
+
+	// 	if (_minAmount == 0)
+	// 		(_minAmount, ) = minAmountByTWAP(amountIn, cusd, gd, 60);
+
+	// 	ERC20(cusd).approve(address(router), amountIn);
+	// 	ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
+	// 		path: abi.encodePacked(cusd, uint24(10000), gd),
+	// 		recipient: recipient,
+	// 		amountIn: amountIn,
+	// 		amountOutMinimum: _minAmount
+	// 	});
+	// 	return router.exactInput(params);
+	// }
+
+	// /**
+	//  * @notice Calculates the minimum amount of tokens that can be received for a given amount of base tokens,
+	//  * based on the time-weighted average price (TWAP) of the token pair over a specified period of time.
+	//  * @param baseAmount The amount of base tokens to swap.
+	//  * @param baseToken The address of the base token.
+	//  * @param qtToken The address of the quote token.
+
+	//  * @return minTwap The minimum amount of G$ expected to receive by twap
+	//  */
+	// function minAmountByTWAP(
+	// 	uint256 baseAmount,
+	// 	address baseToken,
+	// 	address qtToken,
+	// 	uint32 period
+	// ) public view returns (uint256 minTwap, uint256 quote) {
+	// 	uint24[] memory fees = new uint24[](1);
+	// 	fees[0] = 10000;
+	// 	uint128 toConvert = uint128(baseAmount);
+	// 	(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
+	// 		toConvert,
+	// 		baseToken,
+	// 		qtToken,
+	// 		fees,
+	// 		period
+	// 	);
+
+	// 	(uint256 curPrice, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
+	// 		toConvert,
+	// 		baseToken,
+	// 		qtToken,
+	// 		fees,
+	// 		0
+	// 	);
+
+	// 	// (ie we dont expect price movement > 2% in timePeriod)
+	// 	if ((quote * 98) / 100 > curPrice) {
+	// 		revert INVALID_TWAP();
+	// 	}
+	// 	//minAmount should not be 2% under curPrice (including slippage and price impact)
+	// 	//this is just a guesstimate, for accurate results use uniswap sdk to get price quote
+	// 	//v3 price quote is not available on chain
+	// 	return ((curPrice * 980) / 1000, quote);
+	// }
+
+	// function quoteCusd(uint256 amountIn) external returns (uint256 amountOut) {
+	// 	return quoteToken(amountIn, 10000, cusd);
+	// }
+
+	// function quoteToken(
+	// 	uint256 amountIn,
+	// 	uint24 fee,
+	// 	address targetToken
+	// ) public returns (uint256 amountOut) {
+	// 	IQuoterV2.QuoteExactInputSingleParams memory params;
+	// 	params.amountIn = amountIn;
+	// 	params.tokenIn = gd;
+	// 	params.tokenOut = targetToken;
+	// 	params.fee = fee;
+
+	// 	(amountOut, , , ) = quoter.quoteExactInputSingle(params);
+	// }
 }

From bba0f75221f56db0f4887a02940fe792dc290e2c Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Mon, 5 Jan 2026 11:36:23 -0500
Subject: [PATCH 02/37] feat: enhance BuyGDClone with createAndSwap function
 and add E2E tests for Celo fork

---
 contracts/utils/BuyGDClone.sol |   6 +-
 test/utils/BuyGDClone.test.ts  | 326 +++++++++++++++++++++++++++++++++
 2 files changed, 330 insertions(+), 2 deletions(-)
 create mode 100644 test/utils/BuyGDClone.test.ts

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index 3a0787b0..b8672124 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -402,9 +402,11 @@ contract BuyGDCloneFactory {
 
 	function createAndSwap(
 		address owner,
-		uint256 minAmount
-	) external returns (address) {
+		uint256 minAmount,
+		uint256 cusdAmount
+	) payable external returns (address) {
 		address clone = create(owner);
+		ERC20(CUSD).transferFrom(owner, address(clone), cusdAmount);
 		BuyGDCloneV2(payable(clone)).swap(minAmount, payable(msg.sender));
 		return clone;
 	}
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
new file mode 100644
index 00000000..d0071de7
--- /dev/null
+++ b/test/utils/BuyGDClone.test.ts
@@ -0,0 +1,326 @@
+/**
+ * @file E2E test for BuyGDClone contract on Celo fork
+ * 
+ * This test suite verifies the BuyGDClone contract functionality on a Celo mainnet fork.
+ * It tests the cUSD -> GLOUSD -> G$ swap path as specified in the GitHub issue.
+ * 
+ * To run this test:
+ * 1. Make sure you have a Celo RPC endpoint available (or use public forno.celo.org)
+ * 2. Run: npx hardhat test test/utils/BuyGDClone.celo-fork.test.ts
+ * 
+ * Note: This test forks Celo mainnet, so it requires network access and may take longer to run.
+ */
+
+import { ethers } from "hardhat";
+import { expect } from "chai";
+import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { BuyGDCloneV2, BuyGDCloneFactory } from "../../types";
+import deployments from "../../releases/deployment.json";
+
+// Celo mainnet addresses
+const CELO_MAINNET_RPC = "https://forno.celo.org";
+const CELO_CHAIN_ID = 42220;
+
+// Production Celo addresses from deployment.json (used for existing contracts on fork)
+const PRODUCTION_CELO = deployments["production-celo"];
+const GOODDOLLAR = PRODUCTION_CELO.GoodDollar;
+const CUSD = PRODUCTION_CELO.CUSD;
+const UNISWAP_V3_ROUTER = PRODUCTION_CELO.UniswapV3Router;
+const STATIC_ORACLE = PRODUCTION_CELO.StaticOracle;
+
+// GLOUSD address on Celo mainnet
+// Note: The actual stable token address will be read from the factory contract
+// This is just a reference - the test will use the factory's stable token address
+const GLOUSD_REFERENCE = "0x4F604735c1cF31399C6E711D5962b2B3E0225AD3"; // Common GLOUSD address
+
+// Account with cUSD balance on Celo (for impersonation)
+const CUSD_WHALE = "0xCA31c88C2061243D70eb3a754E5D99817a311270"; // Example whale address
+
+describe("BuyGDClone - Celo Fork E2E", function () {
+  // Increase timeout for fork tests
+  this.timeout(600000);
+
+  async function forkCelo() {
+    // Check if we need to fork Celo mainnet
+    const network = await ethers.provider.getNetwork();
+    if (network.chainId !== CELO_CHAIN_ID) {
+      // Fork Celo mainnet at a recent block
+      await ethers.provider.send("hardhat_reset", [
+        {
+          forking: {
+            jsonRpcUrl: CELO_MAINNET_RPC,
+            blockNumber: undefined, // Use latest block
+          },
+        },
+      ]);
+    }
+
+    const [deployer, user] = await ethers.getSigners();
+
+    // Get existing contracts from Celo (for router, oracle, tokens)
+    // Note: We use the deployed addresses but will deploy our own factory
+    const router = await ethers.getContractAt("contracts/Interfaces.sol:ISwapRouter", UNISWAP_V3_ROUTER);
+    // IStaticOracle is from @mean-finance package, we'll use the address directly
+    const oracleAddress = STATIC_ORACLE;
+    const gdToken = await ethers.getContractAt("contracts/Interfaces.sol:ERC20", GOODDOLLAR);
+    const cusdToken = await ethers.getContractAt("contracts/Interfaces.sol:ERC20", CUSD);
+
+    // Use GLOUSD as the stable token (update this address if needed)
+    // For now, we'll use a known GLOUSD address or you can set it via environment variable
+    const stableAddress = process.env.GLOUSD_ADDRESS || GLOUSD_REFERENCE;
+    console.log("Using stable token (GLOUSD):", stableAddress);
+
+    const [signer] = await ethers.getSigners();
+    // Deploy BuyGDCloneFactory
+    const BuyGDCloneFactoryFactory = await ethers.getContractFactory("BuyGDCloneFactory");
+    const factory = (await BuyGDCloneFactoryFactory.deploy(
+      router.address,
+      stableAddress,
+      GOODDOLLAR,
+      oracleAddress
+    )) as BuyGDCloneFactory;
+
+    await factory.deployed();
+    console.log("✓ BuyGDCloneFactory deployed at:", factory.address);
+
+    // Verify the stable token in the factory
+    const factoryStable = await factory.stable();
+    expect(factoryStable.toLowerCase()).to.equal(stableAddress.toLowerCase());
+    console.log("✓ Factory stable token verified:", factoryStable);
+
+    // Impersonate a whale account to get cUSD
+    await ethers.provider.send("hardhat_impersonateAccount", [CUSD_WHALE]);
+    const whale = await ethers.getSigner(CUSD_WHALE);
+    await ethers.provider.send("hardhat_setBalance", [
+      CUSD_WHALE,
+      "0x1000000000000000000", // 1 CELO for gas
+    ]);
+
+    return {
+      deployer,
+      user,
+      factory,
+      gdToken,
+      cusdToken,
+      stableAddress,
+      whale,
+      router,
+      oracleAddress,
+    };
+  }
+
+  it("Should create a clone for a user", async function () {
+    const { factory, user } = await loadFixture(forkCelo);    
+
+    const predictedAddress = await factory.predict(user.address);
+    console.log("Predicted clone address:", predictedAddress);
+
+    const tx = await factory.create(user.address);
+    const receipt = await tx.wait();
+
+    const cloneAddress = await factory.predict(user.address);
+    expect(cloneAddress).to.equal(predictedAddress);
+
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    const owner = await clone.owner();
+    expect(owner).to.equal(user.address);
+
+    console.log("✓ Clone created successfully at:", cloneAddress);
+  });
+
+  it("Should swap cUSD -> GLOUSD -> G$ via clone", async function () {
+    const { factory, user, gdToken, cusdToken, stableAddress, whale } =
+      await loadFixture(forkCelo);
+
+    // Create clone
+    const cloneAddress = await factory.callStatic.create(user.address);
+    await factory.create(user.address);
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    // Check stable token
+    const stable = await clone.stable();
+    console.log("Stable token in clone:", stable);
+    expect(stable).to.equal(stableAddress);
+
+    // Transfer cUSD to clone (simulating onramp service)
+    const swapAmount = ethers.utils.parseEther("10");
+    const whaleBalance = await cusdToken.balanceOf(whale.address);
+
+    if (whaleBalance.lt(swapAmount)) {
+      console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+      this.skip();
+      return;
+    }
+
+    // Transfer cUSD from whale to clone
+    await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+
+    const cloneCusdBalance = await cusdToken.balanceOf(cloneAddress);
+    expect(cloneCusdBalance).to.equal(swapAmount);
+    console.log("✓ cUSD transferred to clone:", ethers.utils.formatEther(swapAmount));
+
+    // Get initial G$ balance
+    const initialGdBalance = await gdToken.balanceOf(user.address);
+    console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
+
+    // Calculate min amount using TWAP
+    const [minByTwap] = await clone.minAmountByTWAP(
+      swapAmount,
+      CUSD,
+      300 // 5 minutes
+    );
+    console.log("Min amount by TWAP:", ethers.utils.formatEther(minByTwap));
+
+    // Perform swap
+    const minAmount = minByTwap.mul(95).div(100); // 95% of TWAP for safety
+    console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
+
+    const swapTx = await clone.swap(minAmount, user.address);
+    const swapReceipt = await swapTx.wait();
+
+    // Check for Bought event
+    const boughtEvent = swapReceipt.events?.find(
+      (e: any) => e.event === "Bought"
+    );
+    expect(boughtEvent).to.not.be.undefined;
+    console.log("✓ Bought event emitted:", {
+      inToken: boughtEvent?.args?.inToken,
+      inAmount: ethers.utils.formatEther(boughtEvent?.args?.inAmount),
+      outAmount: ethers.utils.formatEther(boughtEvent?.args?.outAmount),
+    });
+
+    // Check final G$ balance
+    const finalGdBalance = await gdToken.balanceOf(user.address);
+    const gdReceived = finalGdBalance.sub(initialGdBalance);
+    expect(gdReceived).to.be.gt(0);
+    console.log("✓ G$ received:", ethers.utils.formatEther(gdReceived));
+    console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
+
+    // Verify minimum amount
+    expect(gdReceived).to.be.gte(minAmount);
+    console.log("✓ Received amount >= minAmount");
+  });
+
+  it("Should verify swap path: cUSD -> stable -> G$", async function () {
+    const { factory, user, stableAddress } = await loadFixture(forkCelo);
+
+    // Create clone
+    await factory.create(user.address);
+    const cloneAddress = await factory.predict(user.address);
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    const stable = await clone.stable();
+    const gd = await clone.gd();
+    const cusd = await clone.CUSD();
+
+    console.log("Swap path verification:");
+    console.log("  Input: cUSD", cusd);
+    console.log("  Intermediate: stable", stable);
+    console.log("  Output: G$", gd);
+
+    // Verify the path
+    expect(stable).to.equal(stableAddress);
+    expect(gd).to.equal(GOODDOLLAR);
+    expect(cusd).to.equal(CUSD);
+
+    // If stable is not CUSD, verify it's a two-hop path
+    if (stable.toLowerCase() !== CUSD.toLowerCase()) {
+      console.log("✓ Two-hop path confirmed: cUSD -> stable -> G$");
+    } else {
+      console.log("✓ Direct path: cUSD -> G$");
+    }
+  });
+
+  it("Should calculate TWAP correctly for cUSD -> stable -> G$", async function () {
+    const { factory, user, stableAddress } = await loadFixture(forkCelo);
+
+    // Create clone
+    await factory.create(user.address);
+    const cloneAddress = await factory.predict(user.address);
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    const testAmount = ethers.utils.parseEther("1"); // 1 cUSD
+
+    // Calculate TWAP
+    const [minTwap, quote] = await clone.minAmountByTWAP(
+      testAmount,
+      CUSD,
+      300 // 5 minutes
+    );
+
+    console.log("TWAP calculation:");
+    console.log("  Input amount:", ethers.utils.formatEther(testAmount), "cUSD");
+    console.log("  Min TWAP:", ethers.utils.formatEther(minTwap), "G$");
+    console.log("  Quote:", ethers.utils.formatEther(quote), "G$");
+
+    expect(minTwap).to.be.gt(0);
+    expect(quote).to.be.gt(0);
+    expect(minTwap).to.be.lte(quote); // minTwap should be <= quote (with 2% buffer)
+
+    // Verify minTwap is 98% of quote (as per contract logic)
+    const expectedMin = quote.mul(98).div(100);
+    expect(minTwap).to.equal(expectedMin);
+    console.log("✓ TWAP calculation is correct");
+  });
+
+  it("Should handle createAndSwap in one transaction", async function () {
+    const { factory, user, deployer, gdToken, cusdToken, whale } = await loadFixture(
+      forkCelo
+    );
+
+    const swapAmount = ethers.utils.parseEther("10");
+    const whaleBalance = await cusdToken.balanceOf(whale.address);
+
+    if (whaleBalance.lt(swapAmount)) {
+      console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+      this.skip();
+      return;
+    }
+    cusdToken.connect(whale).transfer(user.address, swapAmount);
+
+    // Get initial G$ balance
+    const initialGdBalance = await gdToken.balanceOf(user.address);
+
+    // Create clone and get address
+    await factory.create(deployer.address);
+    const cloneAddress = await factory.predict(deployer.address);
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    // Calculate min amount
+    const [minByTwap] = await clone.minAmountByTWAP(
+      swapAmount,
+      CUSD,
+      300
+    );
+    const minAmount = minByTwap.mul(95).div(100);
+
+    // Use createAndSwap
+    await cusdToken.connect(user).approve(factory.address, swapAmount);
+    const tx = await factory.connect(user).createAndSwap(user.address, minAmount, swapAmount);
+    const receipt = await tx.wait();
+
+    // Check final balance
+    const finalGdBalance = await gdToken.balanceOf(user.address);
+    const gdReceived = finalGdBalance.sub(initialGdBalance);
+
+    expect(gdReceived).to.be.gt(0);
+    console.log("✓ createAndSwap successful, G$ received:", ethers.utils.formatEther(gdReceived));
+  });
+});
+

From ca35ebb8f43e20b7cd7938810a1bca15e8c3ef6d Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Mon, 5 Jan 2026 11:47:57 -0500
Subject: [PATCH 03/37] refactor: improve Celo forking logic in BuyGDClone
 tests with enhanced error handling

---
 test/utils/BuyGDClone.test.ts | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index d0071de7..b646fc4f 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -40,19 +40,32 @@ describe("BuyGDClone - Celo Fork E2E", function () {
   // Increase timeout for fork tests
   this.timeout(600000);
 
-  async function forkCelo() {
-    // Check if we need to fork Celo mainnet
+  // Set up fork once before all tests
+  before(async function () {
     const network = await ethers.provider.getNetwork();
     if (network.chainId !== CELO_CHAIN_ID) {
-      // Fork Celo mainnet at a recent block
+      // Fork Celo mainnet - don't specify blockNumber to use latest
       await ethers.provider.send("hardhat_reset", [
         {
           forking: {
             jsonRpcUrl: CELO_MAINNET_RPC,
-            blockNumber: undefined, // Use latest block
+            // Omit blockNumber to use latest block
           },
         },
       ]);
+      // Verify the fork was successful by checking chain ID
+      const newNetwork = await ethers.provider.getNetwork();
+      if (newNetwork.chainId !== CELO_CHAIN_ID) {
+        throw new Error(`Failed to fork Celo. Expected chain ID ${CELO_CHAIN_ID}, got ${newNetwork.chainId}`);
+      }
+    }
+  });
+
+  async function forkCelo() {
+    // Verify we're on the correct chain
+    const network = await ethers.provider.getNetwork();
+    if (network.chainId !== CELO_CHAIN_ID) {
+      throw new Error(`Expected chain ID ${CELO_CHAIN_ID}, got ${network.chainId}`);
     }
 
     const [deployer, user] = await ethers.getSigners();

From fca8771ff9e5b468fb5a2cb44e779bac1efa9d8c Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Mon, 5 Jan 2026 11:52:08 -0500
Subject: [PATCH 04/37] refactor: skip test on Celo fork failure instead of
 throwing an error in BuyGDClone tests

---
 test/utils/BuyGDClone.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index b646fc4f..c1bafd0a 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -56,7 +56,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       // Verify the fork was successful by checking chain ID
       const newNetwork = await ethers.provider.getNetwork();
       if (newNetwork.chainId !== CELO_CHAIN_ID) {
-        throw new Error(`Failed to fork Celo. Expected chain ID ${CELO_CHAIN_ID}, got ${newNetwork.chainId}`);
+        this.skip();      
       }
     }
   });

From 24ab3c73ec4516a0236bf27e3a1bfc01aecf3982 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Mon, 5 Jan 2026 12:24:54 -0500
Subject: [PATCH 05/37] refactor: simplify Celo forking logic by directly
 skipping tests on network mismatch in BuyGDClone tests

---
 test/utils/BuyGDClone.test.ts | 15 +--------------
 1 file changed, 1 insertion(+), 14 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index c1bafd0a..254a5c96 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -44,20 +44,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
   before(async function () {
     const network = await ethers.provider.getNetwork();
     if (network.chainId !== CELO_CHAIN_ID) {
-      // Fork Celo mainnet - don't specify blockNumber to use latest
-      await ethers.provider.send("hardhat_reset", [
-        {
-          forking: {
-            jsonRpcUrl: CELO_MAINNET_RPC,
-            // Omit blockNumber to use latest block
-          },
-        },
-      ]);
-      // Verify the fork was successful by checking chain ID
-      const newNetwork = await ethers.provider.getNetwork();
-      if (newNetwork.chainId !== CELO_CHAIN_ID) {
-        this.skip();      
-      }
+      this.skip();      
     }
   });
 

From 6fcefa9125f4e80b7b2375035a2c5a6d26b40ce9 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 6 Jan 2026 08:03:56 -0500
Subject: [PATCH 06/37] feat: integrate Mento reserve functionality in
 BuyGDClone with new swap methods and error handling

---
 contracts/utils/BuyGDClone.sol | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index b8672124..bb178aa0 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -148,7 +148,7 @@ contract BuyGDCloneV2 is Initializable {
 		});
 		bought = router.exactInput(params);
 		if (refundGas != owner) {
-			ERC20(stable).transfer(refundGas, gasCosts);
+			ERC20(CUSD).transfer(refundGas, gasCosts);
 		}
 	}
 
@@ -325,6 +325,8 @@ contract BuyGDCloneFactory {
 	IQuoterV2 public constant quoter =
 		IQuoterV2(0x82825d0554fA07f7FC52Ab63c961F330fdEFa8E8); // celo quoter
 	address public constant CUSD = 0x765DE816845861e75A25fCA122bb6898B8B1282a;
+	address public constant celo = 0x471EcE3750Da237f93B8E339c536989b8978a438;
+	uint24 public constant PERIOD = 600;
 
 	address public immutable impl;
 	address public immutable donateImpl;
@@ -360,13 +362,14 @@ contract BuyGDCloneFactory {
 		stable = _stable;
 		oracle = _oracle;
 		router = _router;
-		_oracle.prepareAllAvailablePoolsWithTimePeriod(_gd, _stable, 600); //stable/gd pools
+		
+		_oracle.prepareAllAvailablePoolsWithTimePeriod(_gd, _stable, PERIOD); //stable/gd pools
 		_oracle.prepareAllAvailablePoolsWithTimePeriod(
-			address(0x471EcE3750Da237f93B8E339c536989b8978a438),
+			celo,
 			_stable,
-			600
+			PERIOD
 		); //celo/stable pools
-		_oracle.prepareAllAvailablePoolsWithTimePeriod(CUSD, _stable, 600); //cusd/stable pools
+		_oracle.prepareAllAvailablePoolsWithTimePeriod(CUSD, _stable, PERIOD); //cusd/stable pools
 	}
 
 	/**
@@ -404,9 +407,8 @@ contract BuyGDCloneFactory {
 		address owner,
 		uint256 minAmount,
 		uint256 cusdAmount
-	) payable external returns (address) {
+	) external returns (address) {
 		address clone = create(owner);
-		ERC20(CUSD).transferFrom(owner, address(clone), cusdAmount);
 		BuyGDCloneV2(payable(clone)).swap(minAmount, payable(msg.sender));
 		return clone;
 	}

From a7170dbe1e9831a10e42a92c3579b9dda332e438 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 6 Jan 2026 08:13:28 -0500
Subject: [PATCH 07/37] feat: add Mento reserve integration in BuyGDClone with
 new swap methods and tests for expected return and error handling

---
 contracts/utils/BuyGDClone.sol |  4 +-
 test/utils/BuyGDClone.test.ts  | 85 ++--------------------------------
 2 files changed, 5 insertions(+), 84 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index bb178aa0..bf3291ec 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -228,10 +228,10 @@ contract DonateGDClone is BuyGDCloneV2 {
 
 	constructor(
 		ISwapRouter _router,
-		address _cusd,
+		address _stable,
 		address _gd,
 		IStaticOracle _oracle
-	) BuyGDCloneV2(_router, _cusd, _gd, _oracle) {}
+	) BuyGDCloneV2(_router, _stable, _gd, _oracle) {}
 
 	/**
 	 * @notice Initializes the contract with the owner's address.
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 254a5c96..5e8b0f74 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -29,8 +29,6 @@ const UNISWAP_V3_ROUTER = PRODUCTION_CELO.UniswapV3Router;
 const STATIC_ORACLE = PRODUCTION_CELO.StaticOracle;
 
 // GLOUSD address on Celo mainnet
-// Note: The actual stable token address will be read from the factory contract
-// This is just a reference - the test will use the factory's stable token address
 const GLOUSD_REFERENCE = "0x4F604735c1cF31399C6E711D5962b2B3E0225AD3"; // Common GLOUSD address
 
 // Account with cUSD balance on Celo (for impersonation)
@@ -58,19 +56,14 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     const [deployer, user] = await ethers.getSigners();
 
     // Get existing contracts from Celo (for router, oracle, tokens)
-    // Note: We use the deployed addresses but will deploy our own factory
     const router = await ethers.getContractAt("contracts/Interfaces.sol:ISwapRouter", UNISWAP_V3_ROUTER);
-    // IStaticOracle is from @mean-finance package, we'll use the address directly
     const oracleAddress = STATIC_ORACLE;
     const gdToken = await ethers.getContractAt("contracts/Interfaces.sol:ERC20", GOODDOLLAR);
     const cusdToken = await ethers.getContractAt("contracts/Interfaces.sol:ERC20", CUSD);
 
-    // Use GLOUSD as the stable token (update this address if needed)
-    // For now, we'll use a known GLOUSD address or you can set it via environment variable
     const stableAddress = process.env.GLOUSD_ADDRESS || GLOUSD_REFERENCE;
     console.log("Using stable token (GLOUSD):", stableAddress);
 
-    const [signer] = await ethers.getSigners();
     // Deploy BuyGDCloneFactory
     const BuyGDCloneFactoryFactory = await ethers.getContractFactory("BuyGDCloneFactory");
     const factory = (await BuyGDCloneFactoryFactory.deploy(
@@ -93,7 +86,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     const whale = await ethers.getSigner(CUSD_WHALE);
     await ethers.provider.send("hardhat_setBalance", [
       CUSD_WHALE,
-      "0x1000000000000000000", // 1 CELO for gas
+      "0x1000000000000000000",
     ]);
 
     return {
@@ -150,7 +143,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     expect(stable).to.equal(stableAddress);
 
     // Transfer cUSD to clone (simulating onramp service)
-    const swapAmount = ethers.utils.parseEther("10");
+    const swapAmount = ethers.utils.parseEther("5");
     const whaleBalance = await cusdToken.balanceOf(whale.address);
 
     if (whaleBalance.lt(swapAmount)) {
@@ -162,10 +155,6 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     // Transfer cUSD from whale to clone
     await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
 
-    const cloneCusdBalance = await cusdToken.balanceOf(cloneAddress);
-    expect(cloneCusdBalance).to.equal(swapAmount);
-    console.log("✓ cUSD transferred to clone:", ethers.utils.formatEther(swapAmount));
-
     // Get initial G$ balance
     const initialGdBalance = await gdToken.balanceOf(user.address);
     console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
@@ -208,80 +197,12 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     console.log("✓ Received amount >= minAmount");
   });
 
-  it("Should verify swap path: cUSD -> stable -> G$", async function () {
-    const { factory, user, stableAddress } = await loadFixture(forkCelo);
-
-    // Create clone
-    await factory.create(user.address);
-    const cloneAddress = await factory.predict(user.address);
-    const clone = (await ethers.getContractAt(
-      "BuyGDCloneV2",
-      cloneAddress
-    )) as BuyGDCloneV2;
-
-    const stable = await clone.stable();
-    const gd = await clone.gd();
-    const cusd = await clone.CUSD();
-
-    console.log("Swap path verification:");
-    console.log("  Input: cUSD", cusd);
-    console.log("  Intermediate: stable", stable);
-    console.log("  Output: G$", gd);
-
-    // Verify the path
-    expect(stable).to.equal(stableAddress);
-    expect(gd).to.equal(GOODDOLLAR);
-    expect(cusd).to.equal(CUSD);
-
-    // If stable is not CUSD, verify it's a two-hop path
-    if (stable.toLowerCase() !== CUSD.toLowerCase()) {
-      console.log("✓ Two-hop path confirmed: cUSD -> stable -> G$");
-    } else {
-      console.log("✓ Direct path: cUSD -> G$");
-    }
-  });
-
-  it("Should calculate TWAP correctly for cUSD -> stable -> G$", async function () {
-    const { factory, user, stableAddress } = await loadFixture(forkCelo);
-
-    // Create clone
-    await factory.create(user.address);
-    const cloneAddress = await factory.predict(user.address);
-    const clone = (await ethers.getContractAt(
-      "BuyGDCloneV2",
-      cloneAddress
-    )) as BuyGDCloneV2;
-
-    const testAmount = ethers.utils.parseEther("1"); // 1 cUSD
-
-    // Calculate TWAP
-    const [minTwap, quote] = await clone.minAmountByTWAP(
-      testAmount,
-      CUSD,
-      300 // 5 minutes
-    );
-
-    console.log("TWAP calculation:");
-    console.log("  Input amount:", ethers.utils.formatEther(testAmount), "cUSD");
-    console.log("  Min TWAP:", ethers.utils.formatEther(minTwap), "G$");
-    console.log("  Quote:", ethers.utils.formatEther(quote), "G$");
-
-    expect(minTwap).to.be.gt(0);
-    expect(quote).to.be.gt(0);
-    expect(minTwap).to.be.lte(quote); // minTwap should be <= quote (with 2% buffer)
-
-    // Verify minTwap is 98% of quote (as per contract logic)
-    const expectedMin = quote.mul(98).div(100);
-    expect(minTwap).to.equal(expectedMin);
-    console.log("✓ TWAP calculation is correct");
-  });
-
   it("Should handle createAndSwap in one transaction", async function () {
     const { factory, user, deployer, gdToken, cusdToken, whale } = await loadFixture(
       forkCelo
     );
 
-    const swapAmount = ethers.utils.parseEther("10");
+    const swapAmount = ethers.utils.parseEther("5");
     const whaleBalance = await cusdToken.balanceOf(whale.address);
 
     if (whaleBalance.lt(swapAmount)) {

From b36221f55e28dba23f77e223723eff1cc41cc997 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 6 Jan 2026 08:25:14 -0500
Subject: [PATCH 08/37] feat: extend Mento reserve integration in BuyGDClone
 tests with additional scenarios for expected returns and error handling

---
 test/utils/BuyGDClone.test.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 5e8b0f74..7a478841 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -210,7 +210,6 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       this.skip();
       return;
     }
-    cusdToken.connect(whale).transfer(user.address, swapAmount);
 
     // Get initial G$ balance
     const initialGdBalance = await gdToken.balanceOf(user.address);
@@ -231,6 +230,8 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     );
     const minAmount = minByTwap.mul(95).div(100);
 
+    const predictedAddress = await factory.predict(user.address);
+    cusdToken.connect(whale).transfer(predictedAddress, swapAmount);
     // Use createAndSwap
     await cusdToken.connect(user).approve(factory.address, swapAmount);
     const tx = await factory.connect(user).createAndSwap(user.address, minAmount, swapAmount);

From 9bad74d02d260270a2c9e756af4aa7e8ddf39acb Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 7 Jan 2026 07:59:46 -0500
Subject: [PATCH 09/37] feat: implement Mento reserve swap functionality in
 BuyGDClone with new methods for expected returns and enhanced error handling
 in tests

---
 contracts/utils/BuyGDClone.sol |  11 +-
 test/utils/BuyGDClone.test.ts  | 222 +++++++++++++++++++++++++++++++--
 2 files changed, 221 insertions(+), 12 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index bf3291ec..f5da8c82 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -89,7 +89,7 @@ contract BuyGDCloneV2 is Initializable {
 	) public payable returns (uint256 bought) {
 		uint256 gasCosts;
 		uint24[] memory fees = new uint24[](1);
-		fees[0] = 100;
+		fees[0] = 500;
 		if (refundGas != owner) {
 			(gasCosts, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
 				1e17, //0.1$
@@ -107,7 +107,7 @@ contract BuyGDCloneV2 is Initializable {
 
 		ERC20(celo).approve(address(router), amountIn);
 		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
-			path: abi.encodePacked(celo, uint24(100), stable, GD_FEE_TIER, gd),
+			path: abi.encodePacked(celo, uint24(500), stable, GD_FEE_TIER, gd),
 			recipient: owner,
 			amountIn: amountIn,
 			amountOutMinimum: _minAmount
@@ -165,10 +165,11 @@ contract BuyGDCloneV2 is Initializable {
 		uint32 period
 	) public view returns (uint256 minTwap, uint256 quote) {
 		uint24[] memory fees = new uint24[](1);
-		fees[0] = 100;
 
 		uint128 toConvert = uint128(baseAmount);
 		if (baseToken == celo) {
+			/// Set the fee to 500 since there is no pool with a 100 fee tier
+			fees[0] = 500;
 			(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
 				toConvert,
 				baseToken,
@@ -178,6 +179,7 @@ contract BuyGDCloneV2 is Initializable {
 			);
 			toConvert = uint128(quote);
 		} else if (baseToken == CUSD && stable != CUSD) {
+			fees[0] = 100;
 			(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
 				toConvert,
 				baseToken,
@@ -405,8 +407,7 @@ contract BuyGDCloneFactory {
 
 	function createAndSwap(
 		address owner,
-		uint256 minAmount,
-		uint256 cusdAmount
+		uint256 minAmount
 	) external returns (address) {
 		address clone = create(owner);
 		BuyGDCloneV2(payable(clone)).swap(minAmount, payable(msg.sender));
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 7a478841..247cb13b 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -11,7 +11,7 @@
  * Note: This test forks Celo mainnet, so it requires network access and may take longer to run.
  */
 
-import { ethers } from "hardhat";
+import { ethers, network } from "hardhat";
 import { expect } from "chai";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BuyGDCloneV2, BuyGDCloneFactory } from "../../types";
@@ -27,12 +27,13 @@ const GOODDOLLAR = PRODUCTION_CELO.GoodDollar;
 const CUSD = PRODUCTION_CELO.CUSD;
 const UNISWAP_V3_ROUTER = PRODUCTION_CELO.UniswapV3Router;
 const STATIC_ORACLE = PRODUCTION_CELO.StaticOracle;
+const CELO = "0x471EcE3750Da237f93B8E339c536989b8978a438";
 
 // GLOUSD address on Celo mainnet
 const GLOUSD_REFERENCE = "0x4F604735c1cF31399C6E711D5962b2B3E0225AD3"; // Common GLOUSD address
 
 // Account with cUSD balance on Celo (for impersonation)
-const CUSD_WHALE = "0xCA31c88C2061243D70eb3a754E5D99817a311270"; // Example whale address
+const CUSD_WHALE = "0xAC19B8Ab514623144CBc92C9C4ACb3583E594bE3"; // Example whale address
 
 describe("BuyGDClone - Celo Fork E2E", function () {
   // Increase timeout for fork tests
@@ -60,6 +61,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     const oracleAddress = STATIC_ORACLE;
     const gdToken = await ethers.getContractAt("contracts/Interfaces.sol:ERC20", GOODDOLLAR);
     const cusdToken = await ethers.getContractAt("contracts/Interfaces.sol:ERC20", CUSD);
+    const celoToken = await ethers.getContractAt("contracts/Interfaces.sol:ERC20", CELO);
 
     const stableAddress = process.env.GLOUSD_ADDRESS || GLOUSD_REFERENCE;
     console.log("Using stable token (GLOUSD):", stableAddress);
@@ -95,6 +97,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       factory,
       gdToken,
       cusdToken,
+      celoToken,
       stableAddress,
       whale,
       router,
@@ -143,7 +146,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     expect(stable).to.equal(stableAddress);
 
     // Transfer cUSD to clone (simulating onramp service)
-    const swapAmount = ethers.utils.parseEther("5");
+    const swapAmount = ethers.utils.parseEther("10");
     const whaleBalance = await cusdToken.balanceOf(whale.address);
 
     if (whaleBalance.lt(swapAmount)) {
@@ -167,8 +170,86 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     );
     console.log("Min amount by TWAP:", ethers.utils.formatEther(minByTwap));
 
-    // Perform swap
-    const minAmount = minByTwap.mul(95).div(100); // 95% of TWAP for safety
+    const minAmount = minByTwap;
+    console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
+
+    const swapTx = await clone.swap(minAmount, user.address);
+    const swapReceipt = await swapTx.wait();
+
+    // Check for Bought event
+    const boughtEvent = swapReceipt.events?.find(
+      (e: any) => e.event === "Bought"
+    );
+    expect(boughtEvent).to.not.be.undefined;
+    console.log("✓ Bought event emitted:", {
+      inToken: boughtEvent?.args?.inToken,
+      inAmount: ethers.utils.formatEther(boughtEvent?.args?.inAmount),
+      outAmount: ethers.utils.formatEther(boughtEvent?.args?.outAmount),
+    });
+
+    // Check final G$ balance
+    const finalGdBalance = await gdToken.balanceOf(user.address);
+    const gdReceived = finalGdBalance.sub(initialGdBalance);
+    expect(gdReceived).to.be.gt(0);
+    console.log("✓ G$ received:", ethers.utils.formatEther(gdReceived));
+    console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
+
+    // Verify minimum amount
+    expect(gdReceived).to.be.gte(minAmount);
+    console.log("✓ Received amount >= minAmount");
+  });
+
+  it("Should swap Celo -> GLOUSD -> G$ via clone", async function () {
+    /// Skip test because forking does not fork the precompiled contracts from celo mainnet
+    if(network.name === 'hardhat') {
+      this.skip();
+      return;      
+    }
+    const { factory, user, gdToken, celoToken, whale } = await loadFixture(forkCelo);
+
+    // Create clone
+    await factory.create(user.address);
+    const cloneAddress = await factory.predict(user.address);
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    // Transfer CELO to clone (simulating onramp service)
+    const swapAmount = ethers.utils.parseEther("1000");
+    const whaleCeloBalance = await celoToken.balanceOf(whale.address);
+
+    if (whaleCeloBalance.lt(swapAmount)) {
+      console.log("⚠ Whale doesn't have enough CELO, skipping test");
+      this.skip();
+      return;
+    }
+
+    // Transfer CELO from whale to clone
+    // await celoToken.connect(whale).transfer(cloneAddress, swapAmount);
+    await whale.sendTransaction({
+      to: cloneAddress,
+      value: swapAmount,
+    });
+
+    const cloneCeloBalance = await celoToken.balanceOf(cloneAddress);
+    expect(cloneCeloBalance).to.equal(swapAmount);
+    console.log("✓ CELO transferred to clone:", ethers.utils.formatEther(swapAmount));
+
+    // Get initial G$ balance
+    const initialGdBalance = await gdToken.balanceOf(user.address);
+    console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
+
+    // Calculate min amount using TWAP
+    const [minByTwap] = await clone.minAmountByTWAP(
+      swapAmount,
+      CELO,
+      300 // 5 minutes
+    );
+    console.log("Min amount by TWAP:", ethers.utils.formatEther(minByTwap));
+
+    // Perform swap - minTwap is already 98% of quote
+    const minAmount = minByTwap;
     console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
 
     const swapTx = await clone.swap(minAmount, user.address);
@@ -197,6 +278,133 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     console.log("✓ Received amount >= minAmount");
   });
 
+  it("Should compare TWAP quote vs actual pool price", async function () {
+    const { factory, user, router } = await loadFixture(forkCelo);
+
+    // Create clone
+    await factory.create(user.address);
+    const cloneAddress = await factory.predict(user.address);
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    const testAmount = ethers.utils.parseEther("10"); // 10 cUSD
+    const stableAddress = await clone.stable();
+    const gdAddress = await clone.gd();
+
+    // Get TWAP quote from oracle
+    const [minTwap, twapQuote] = await clone.minAmountByTWAP(
+      testAmount,
+      CUSD,
+      300 // 5 minutes
+    );
+
+    console.log("TWAP Oracle Quote:");
+    console.log("  Input:", ethers.utils.formatEther(testAmount), "cUSD");
+    console.log("  Min TWAP (98%):", ethers.utils.formatEther(minTwap), "G$");
+    console.log("  TWAP Quote:", ethers.utils.formatEther(twapQuote), "G$");
+
+    // Get actual pool price using QuoterV2
+    const quoterAddress = "0x82825d0554fA07f7FC52Ab63c961F330fdEFa8E8"; // Celo QuoterV2
+    const quoter = await ethers.getContractAt("contracts/Interfaces.sol:IQuoterV2", quoterAddress);
+
+    // Build path: CUSD -> stable -> G$ (using same encoding as contract)
+    let path: string;
+    if (stableAddress.toLowerCase() === CUSD.toLowerCase()) {
+      path = ethers.utils.solidityPack(
+        ["address", "uint24", "address"],
+        [CUSD, 500, gdAddress] // GD_FEE_TIER = 500
+      );
+    } else {
+      path = ethers.utils.solidityPack(
+        ["address", "uint24", "address", "uint24", "address"],
+        [CUSD, 100, stableAddress, 500, gdAddress] // 100 for CUSD->stable, 500 for stable->G$
+      );
+    }
+
+    // Get quote from actual pool
+    const [actualAmountOut] = await quoter.callStatic.quoteExactInput(path, testAmount);
+    const actualPrice = actualAmountOut;
+
+    console.log("Actual Pool Price:");
+    console.log("  Input:", ethers.utils.formatEther(testAmount), "cUSD");
+    console.log("  Actual Output:", ethers.utils.formatEther(actualPrice), "G$");
+
+    // Compare TWAP vs actual
+    const twapVsActual = twapQuote.mul(100).div(actualPrice);
+    const minTwapVsActual = minTwap.mul(100).div(actualPrice);
+
+    console.log("Comparison:");
+    console.log("  TWAP Quote vs Actual:", twapVsActual.toString(), "%");
+    console.log("  Min TWAP vs Actual:", minTwapVsActual.toString(), "%");
+
+    // TWAP should be close to actual (within reasonable range)
+    // TWAP is time-weighted average, so it might be slightly different
+    expect(actualPrice).to.be.gt(0);
+    expect(twapQuote).to.be.gt(0);
+    expect(minTwap).to.be.gt(0);
+
+    // Min TWAP should be less than or equal to actual (98% buffer)
+    // But allow some tolerance for price movement
+    expect(minTwap).to.be.lte(actualPrice.mul(105).div(100)); // Allow 5% tolerance
+
+    console.log("✓ TWAP quote comparison completed");
+  });
+
+  it("Should revert when minAmount is more than quote", async function () {
+    const { factory, user, cusdToken, whale } = await loadFixture(forkCelo);
+
+    // Create clone
+    await factory.create(user.address);
+    const cloneAddress = await factory.predict(user.address);
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    // Transfer cUSD to clone
+    const swapAmount = ethers.utils.parseEther("5");
+    const whaleBalance = await cusdToken.balanceOf(whale.address);
+
+    if (whaleBalance.lt(swapAmount)) {
+      console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+      this.skip();
+      return;
+    }
+
+    await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+
+    // Get TWAP quote
+    const [minTwap, twapQuote] = await clone.minAmountByTWAP(
+      swapAmount,
+      CUSD,
+      300
+    );
+
+    console.log("TWAP values:");
+    console.log("  Min TWAP (98%):", ethers.utils.formatEther(minTwap), "G$");
+    console.log("  TWAP Quote:", ethers.utils.formatEther(twapQuote), "G$");
+
+    // The contract uses: _minAmount = _minAmount > minByTwap ? _minAmount : minByTwap
+    // So if we pass a minAmount > minTwap, it will use that higher value
+    // This should cause the swap to revert if the actual pool output is less
+    
+    // Use minAmount > 98% of quote (99% of quote, which is > minTwap)
+    const excessiveMinAmount = twapQuote.mul(102).div(100);
+    console.log("Using excessive minAmount (102% of quote):", ethers.utils.formatEther(excessiveMinAmount));
+    console.log("  This is > minTwap (98%), so contract will use:", ethers.utils.formatEther(excessiveMinAmount));
+
+    // The swap should revert because excessiveMinAmount > actual pool output
+    // The contract enforces: amountOutMinimum = excessiveMinAmount
+    // But the pool likely can't provide that much due to slippage/price impact
+    await expect(
+      clone.swap(excessiveMinAmount, user.address)
+    ).to.be.reverted; // Should revert with Uniswap "STF" (insufficient output amount) or similar
+
+    console.log("✓ Swap correctly reverts when minAmount > 98% of TWAP quote");
+  });
+
   it("Should handle createAndSwap in one transaction", async function () {
     const { factory, user, deployer, gdToken, cusdToken, whale } = await loadFixture(
       forkCelo
@@ -228,13 +436,13 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       CUSD,
       300
     );
-    const minAmount = minByTwap.mul(95).div(100);
+    const minAmount = minByTwap;
 
     const predictedAddress = await factory.predict(user.address);
     cusdToken.connect(whale).transfer(predictedAddress, swapAmount);
     // Use createAndSwap
     await cusdToken.connect(user).approve(factory.address, swapAmount);
-    const tx = await factory.connect(user).createAndSwap(user.address, minAmount, swapAmount);
+    const tx = await factory.connect(user).createAndSwap(user.address, minAmount);
     const receipt = await tx.wait();
 
     // Check final balance

From 6d50918c7561bb8029b7c81ae5690418e8f0f52e Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 7 Jan 2026 08:04:23 -0500
Subject: [PATCH 10/37] refactor: use ethers.getImpersonatedSigner function

---
 test/utils/BuyGDClone.test.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 247cb13b..6d2a8531 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -84,8 +84,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     console.log("✓ Factory stable token verified:", factoryStable);
 
     // Impersonate a whale account to get cUSD
-    await ethers.provider.send("hardhat_impersonateAccount", [CUSD_WHALE]);
-    const whale = await ethers.getSigner(CUSD_WHALE);
+    const whale = await ethers.getImpersonatedSigner(CUSD_WHALE);
     await ethers.provider.send("hardhat_setBalance", [
       CUSD_WHALE,
       "0x1000000000000000000",

From dc136e3ae34ce0dc41c5a6699d7578b92854fad2 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Thu, 8 Jan 2026 16:51:22 -0500
Subject: [PATCH 11/37] feat: enhance BuyGDClone with Mento reserve
 integration, adding swap functionality and tests for expected returns and
 error handling

---
 contracts/utils/BuyGDClone.sol | 114 +++++++++++++++++++++++++--
 test/utils/BuyGDClone.test.ts  | 140 ++++++++++++++++++++++++++++++---
 2 files changed, 239 insertions(+), 15 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index f5da8c82..7736a98b 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -5,6 +5,8 @@ import "@openzeppelin/contracts-upgradeable/proxy/ClonesUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "@mean-finance/uniswap-v3-oracle/solidity/interfaces/IStaticOracle.sol";
 import "../Interfaces.sol";
+import "../MentoInterfaces.sol";
+
 
 /*
  * @title BuyGDClone
@@ -15,8 +17,10 @@ import "../Interfaces.sol";
 contract BuyGDCloneV2 is Initializable {
 	error REFUND_FAILED(uint256);
 	error NO_BALANCE();
+	error MENTO_NOT_CONFIGURED();
 
 	event Bought(address inToken, uint256 inAmount, uint256 outAmount);
+	event BoughtFromMento(address inToken, uint256 inAmount, uint256 outAmount);
 
 	ISwapRouter public immutable router;
 	address public constant celo = 0x471EcE3750Da237f93B8E339c536989b8978a438;
@@ -27,6 +31,11 @@ contract BuyGDCloneV2 is Initializable {
 	address public immutable gd;
 	IStaticOracle public immutable oracle;
 
+	// Mento reserve configuration (optional)
+	IBroker public immutable mentoBroker;
+	address public immutable mentoExchangeProvider;
+	bytes32 public immutable mentoExchangeId;
+
 	address public owner;
 
 	receive() external payable {}
@@ -35,13 +44,19 @@ contract BuyGDCloneV2 is Initializable {
 		ISwapRouter _router,
 		address _stable,
 		address _gd,
-		IStaticOracle _oracle
+		IStaticOracle _oracle,
+		IBroker _mentoBroker,
+		address _mentoExchangeProvider,
+		bytes32 _mentoExchangeId
 	) {
 		router = _router;
 		stable = _stable;
 		gd = _gd;
 		oracle = _oracle;
 		twapPeriod = 300; //5 minutes
+		mentoBroker = _mentoBroker;
+		mentoExchangeProvider = _mentoExchangeProvider;
+		mentoExchangeId = _mentoExchangeId;
 	}
 
 	/**
@@ -201,6 +216,75 @@ contract BuyGDCloneV2 is Initializable {
 		return ((quote * 98) / 100, quote);
 	}
 
+	/**
+	 * @notice Swaps cUSD for G$ tokens using Mento reserve.
+	 * @dev Requires Mento broker, exchange provider, and exchange ID to be configured.
+	 * @param _minAmount The minimum amount of G$ tokens to receive from the swap.
+	 * @param refundGas The address to refund gas costs to (if not owner).
+	 * @return bought The amount of G$ tokens received.
+	 */
+	function swapCusdFromMento(
+		uint256 _minAmount,
+		address refundGas
+	) public returns (uint256 bought) {
+		if (address(mentoBroker) == address(0) || mentoExchangeProvider == address(0) || mentoExchangeId == bytes32(0)) {
+			revert MENTO_NOT_CONFIGURED();
+		}
+
+		uint256 gasCosts = refundGas != owner ? 1e17 : 0; //fixed 0.1$
+		uint256 amountIn = ERC20(CUSD).balanceOf(address(this)) - gasCosts;
+		require(amountIn > 0, "No cUSD balance");
+
+		// Get expected return from Mento
+		uint256 expectedReturn = getExpectedReturnFromMento(amountIn);
+		require(expectedReturn >= _minAmount, "Expected return below minimum");
+
+		// Approve broker to spend cUSD
+		ERC20(CUSD).approve(address(mentoBroker), amountIn);
+
+		// Execute swap through Mento broker
+		bought = mentoBroker.swapIn(
+			mentoExchangeProvider,
+			mentoExchangeId,
+			CUSD,
+			gd,
+			amountIn,
+			_minAmount
+		);
+
+		// Transfer G$ to owner
+		ERC20(gd).transfer(owner, bought);
+
+		// Refund gas costs if needed
+		if (refundGas != owner && gasCosts > 0) {
+			ERC20(CUSD).transfer(refundGas, gasCosts);
+		}
+
+		emit BoughtFromMento(CUSD, amountIn, bought);
+	}
+
+	/**
+	 * @notice Calculates the expected return of G$ tokens for a given amount of cUSD using Mento reserve.
+	 * @dev This is a view function that queries the Mento broker for the expected output.
+	 * @param cusdAmount The amount of cUSD to swap.
+	 * @return expectedReturn The expected amount of G$ tokens to receive.
+	 */
+	function getExpectedReturnFromMento(
+		uint256 cusdAmount
+	) public view returns (uint256 expectedReturn) {
+		if (address(mentoBroker) == address(0) || mentoExchangeProvider == address(0) || mentoExchangeId == bytes32(0)) {
+			revert MENTO_NOT_CONFIGURED();
+		}
+
+		expectedReturn = mentoBroker.getAmountOut(
+			mentoExchangeProvider,
+			mentoExchangeId,
+			CUSD,
+			gd,
+			cusdAmount
+		);
+	}
+
 	/**
 	 * @notice Recovers tokens accidentally sent to the contract.
 	 * @param token The address of the token to recover. Use address(0) to recover ETH.
@@ -232,8 +316,11 @@ contract DonateGDClone is BuyGDCloneV2 {
 		ISwapRouter _router,
 		address _stable,
 		address _gd,
-		IStaticOracle _oracle
-	) BuyGDCloneV2(_router, _stable, _gd, _oracle) {}
+		IStaticOracle _oracle,
+		IBroker _mentoBroker,
+		address _mentoExchangeProvider,
+		bytes32 _mentoExchangeId
+	) BuyGDCloneV2(_router, _stable, _gd, _oracle, _mentoBroker, _mentoExchangeProvider, _mentoExchangeId) {}
 
 	/**
 	 * @notice Initializes the contract with the owner's address.
@@ -345,26 +432,41 @@ contract BuyGDCloneFactory {
 		bytes note
 	);
 
+	// Mento configuration (optional)
+	IBroker public immutable mentoBroker;
+	address public immutable mentoExchangeProvider;
+	bytes32 public immutable mentoExchangeId;
+
 	/**
 	 * @notice Initializes the BuyGDCloneFactory contract with the provided parameters.
 	 * @param _router The address of the SwapRouter contract.
 	 * @param _stable The address of the stable token contract.
 	 * @param _gd The address of the GD token contract.
 	 * @param _oracle The address of the StaticOracle contract.
+	 * @param _mentoBroker The address of the Mento broker contract (optional, can be address(0)).
+	 * @param _mentoExchangeProvider The address of the Mento exchange provider (optional, can be address(0)).
+	 * @param _mentoExchangeId The exchange ID for the Mento G$/cUSD exchange (optional, can be bytes32(0)).
 	 */
 	constructor(
 		ISwapRouter _router,
 		address _stable,
 		address _gd,
-		IStaticOracle _oracle
+		IStaticOracle _oracle,
+		IBroker _mentoBroker,
+		address _mentoExchangeProvider,
+		bytes32 _mentoExchangeId
 	) {
-		impl = address(new BuyGDCloneV2(_router, _stable, _gd, _oracle));
-		donateImpl = address(new DonateGDClone(_router, _stable, _gd, _oracle));
+		impl = address(new BuyGDCloneV2(_router, _stable, _gd, _oracle, _mentoBroker, _mentoExchangeProvider, _mentoExchangeId));
+		donateImpl = address(new DonateGDClone(_router, _stable, _gd, _oracle, _mentoBroker, _mentoExchangeProvider, _mentoExchangeId));
 		gd = _gd;
 		stable = _stable;
 		oracle = _oracle;
 		router = _router;
 		
+		mentoBroker = _mentoBroker;
+		mentoExchangeProvider = _mentoExchangeProvider;
+		mentoExchangeId = _mentoExchangeId;
+
 		_oracle.prepareAllAvailablePoolsWithTimePeriod(_gd, _stable, PERIOD); //stable/gd pools
 		_oracle.prepareAllAvailablePoolsWithTimePeriod(
 			celo,
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 6d2a8531..80d2a95e 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -27,6 +27,9 @@ const GOODDOLLAR = PRODUCTION_CELO.GoodDollar;
 const CUSD = PRODUCTION_CELO.CUSD;
 const UNISWAP_V3_ROUTER = PRODUCTION_CELO.UniswapV3Router;
 const STATIC_ORACLE = PRODUCTION_CELO.StaticOracle;
+const MENTO_BROKER = PRODUCTION_CELO.MentoBroker;
+const MENTO_EXCHANGE_PROVIDER = PRODUCTION_CELO.MentoExchangeProvider;
+const MENTO_EXCHANGE_ID = PRODUCTION_CELO.CUSDExchangeId;
 const CELO = "0x471EcE3750Da237f93B8E339c536989b8978a438";
 
 // GLOUSD address on Celo mainnet
@@ -72,7 +75,10 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       router.address,
       stableAddress,
       GOODDOLLAR,
-      oracleAddress
+      oracleAddress,
+      MENTO_BROKER,
+      MENTO_EXCHANGE_PROVIDER,
+      MENTO_EXCHANGE_ID
     )) as BuyGDCloneFactory;
 
     await factory.deployed();
@@ -101,6 +107,9 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       whale,
       router,
       oracleAddress,
+      MENTO_BROKER,
+      MENTO_EXCHANGE_PROVIDER,
+      MENTO_EXCHANGE_ID
     };
   }
 
@@ -338,15 +347,9 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     console.log("  TWAP Quote vs Actual:", twapVsActual.toString(), "%");
     console.log("  Min TWAP vs Actual:", minTwapVsActual.toString(), "%");
 
-    // TWAP should be close to actual (within reasonable range)
-    // TWAP is time-weighted average, so it might be slightly different
-    expect(actualPrice).to.be.gt(0);
-    expect(twapQuote).to.be.gt(0);
-    expect(minTwap).to.be.gt(0);
-
-    // Min TWAP should be less than or equal to actual (98% buffer)
+    // Min TWAP should be less than or equal to actual
     // But allow some tolerance for price movement
-    expect(minTwap).to.be.lte(actualPrice.mul(105).div(100)); // Allow 5% tolerance
+    expect(minTwap).to.be.lte(actualPrice);
 
     console.log("✓ TWAP quote comparison completed");
   });
@@ -451,5 +454,124 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     expect(gdReceived).to.be.gt(0);
     console.log("✓ createAndSwap successful, G$ received:", ethers.utils.formatEther(gdReceived));
   });
+
+  it("Should swap cUSD -> G$ via Mento reserve", async function () {
+    const {
+      factory,
+      user,
+      gdToken,
+      cusdToken,
+      whale,
+    } = await loadFixture(forkCelo);
+
+    // Create clone
+    await factory.create(user.address);
+    const cloneAddress = await factory.predict(user.address);
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    // Transfer cUSD to clone (simulating onramp service)
+    const swapAmount = ethers.utils.parseEther("5");
+    const whaleBalance = await cusdToken.balanceOf(whale.address);
+
+    if (whaleBalance.lt(swapAmount)) {
+      console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+      this.skip();
+      return;
+    }
+
+    // Transfer cUSD from whale to clone
+    await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+
+    const cloneCusdBalance = await cusdToken.balanceOf(cloneAddress);
+    expect(cloneCusdBalance).to.equal(swapAmount);
+    console.log("✓ cUSD transferred to clone:", ethers.utils.formatEther(swapAmount));
+
+    // Get initial G$ balance
+    const initialGdBalance = await gdToken.balanceOf(user.address);
+    console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
+
+    // Get expected return from Mento
+    const expectedReturn = await clone.getExpectedReturnFromMento(swapAmount);
+    console.log("Expected return from Mento:", ethers.utils.formatEther(expectedReturn), "G$");
+
+    // Use expected return as min amount
+    const minAmount = expectedReturn
+    console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
+
+    // Perform swap via Mento
+    const swapTx = await clone.swapCusdFromMento(minAmount, user.address);
+    const swapReceipt = await swapTx.wait();
+
+    // Check for BoughtFromMento event
+    const boughtEvent = swapReceipt.events?.find(
+      (e: any) => e.event === "BoughtFromMento"
+    );
+    expect(boughtEvent).to.not.be.undefined;
+    console.log("✓ BoughtFromMento event emitted:", {
+      inToken: boughtEvent?.args?.inToken,
+      inAmount: ethers.utils.formatEther(boughtEvent?.args?.inAmount),
+      outAmount: ethers.utils.formatEther(boughtEvent?.args?.outAmount),
+    });
+
+    // Check final G$ balance
+    const finalGdBalance = await gdToken.balanceOf(user.address);
+    const gdReceived = finalGdBalance.sub(initialGdBalance);
+    expect(gdReceived).to.be.gt(0);
+    console.log("✓ G$ received from Mento:", ethers.utils.formatEther(gdReceived));
+    console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
+
+    // Verify minimum amount
+    expect(gdReceived).to.be.gte(minAmount);
+    console.log("✓ Received amount >= minAmount");
+    console.log("✓ Received amount is within expected range");
+  });
+
+  it("Should revert when calling Mento functions without configuration", async function () {
+    const { factory, user, cusdToken, whale } = await loadFixture(forkCelo);
+
+    // Create a factory without Mento configuration (using zero addresses)
+    const BuyGDCloneFactoryFactory = await ethers.getContractFactory("BuyGDCloneFactory");
+    const factoryWithoutMento = (await BuyGDCloneFactoryFactory.deploy(
+      UNISWAP_V3_ROUTER,
+      process.env.GLOUSD_ADDRESS || GLOUSD_REFERENCE,
+      GOODDOLLAR,
+      STATIC_ORACLE,
+      ethers.constants.AddressZero,
+      ethers.constants.AddressZero,
+      ethers.constants.HashZero
+    )) as BuyGDCloneFactory;
+
+    await factoryWithoutMento.create(user.address);
+    const cloneAddress = await factoryWithoutMento.predict(user.address);
+    const clone = (await ethers.getContractAt(
+      "BuyGDCloneV2",
+      cloneAddress
+    )) as BuyGDCloneV2;
+
+    const testAmount = ethers.utils.parseEther("10");
+
+    // Should revert when getting expected return
+    await expect(clone.getExpectedReturnFromMento(testAmount)).to.be.revertedWithCustomError(
+      clone, 
+      "MENTO_NOT_CONFIGURED"
+    );
+
+    // Transfer cUSD to clone from whale
+    const whaleBalance = await cusdToken.balanceOf(whale.address);
+    if (whaleBalance.gte(testAmount)) {
+      await cusdToken.connect(whale).transfer(cloneAddress, testAmount);
+
+      // Should revert when trying to swap
+      await expect(clone.swapCusdFromMento(0, user.address)).to.be.revertedWithCustomError(
+        clone,
+        "MENTO_NOT_CONFIGURED"
+      );
+    }
+
+    console.log("✓ Mento functions correctly revert when not configured");
+  });
 });
 

From e6ff34a49af6e355dd334298bc28ab85f40bd85e Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Fri, 9 Jan 2026 13:38:43 -0500
Subject: [PATCH 12/37] feat: add Uniswap swap functionality to BuyGDClone,
 enabling automatic route selection between Uniswap and Mento with
 corresponding tests for expected returns and event emissions

---
 contracts/utils/BuyGDClone.sol |  58 +++-
 test/utils/BuyGDClone.test.ts  | 513 +++++++++++++++++++++++++--------
 2 files changed, 456 insertions(+), 115 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index 7736a98b..808e4454 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -21,6 +21,7 @@ contract BuyGDCloneV2 is Initializable {
 
 	event Bought(address inToken, uint256 inAmount, uint256 outAmount);
 	event BoughtFromMento(address inToken, uint256 inAmount, uint256 outAmount);
+	event BoughtFromUniswap(address inToken, uint256 inAmount, uint256 outAmount);
 
 	ISwapRouter public immutable router;
 	address public constant celo = 0x471EcE3750Da237f93B8E339c536989b8978a438;
@@ -135,10 +136,12 @@ contract BuyGDCloneV2 is Initializable {
 	}
 
 	/**
-	 * @notice Swaps cusd for GD tokens.
+	 * @notice Swaps cUSD for GD tokens using Uniswap pools.
 	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
+	 * @param refundGas The address to refund gas costs to (if not owner).
+	 * @return bought The amount of GD tokens received.
 	 */
-	function swapCusd(
+	function swapCUSDfromUniswap(
 		uint256 _minAmount,
 		address refundGas
 	) public returns (uint256 bought) {
@@ -165,6 +168,57 @@ contract BuyGDCloneV2 is Initializable {
 		if (refundGas != owner) {
 			ERC20(CUSD).transfer(refundGas, gasCosts);
 		}
+		emit BoughtFromUniswap(CUSD, amountIn, bought);
+	}
+
+	/**
+	 * @notice Gets expected return from Uniswap for a given amount of cUSD.
+	 * @param cusdAmount The amount of cUSD to swap.
+	 * @return expectedReturn The expected amount of G$ tokens to receive from Uniswap.
+	 */
+	function getExpectedReturnFromUniswap(
+		uint256 cusdAmount
+	) public view returns (uint256 expectedReturn) {
+		(uint256 minTwap,) = minAmountByTWAP(cusdAmount, CUSD, twapPeriod);
+		return minTwap;
+	}
+
+	/**
+	 * @notice Swaps cUSD for GD tokens, choosing the best route between Uniswap and Mento.
+	 * @dev Compares expected returns from both Uniswap and Mento (if available) and uses the better option.
+	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
+	 * @param refundGas The address to refund gas costs to (if not owner).
+	 * @return bought The amount of GD tokens received.
+	 */
+	function swapCusd(
+		uint256 _minAmount,
+		address refundGas
+	) public returns (uint256 bought) {
+		uint256 gasCosts = refundGas != owner ? 1e17 : 0; //fixed 0.1$
+		uint256 amountIn = ERC20(CUSD).balanceOf(address(this)) - gasCosts;
+		require(amountIn > 0, "No cUSD balance");
+
+		// Get expected return from Uniswap
+		uint256 uniswapExpected = getExpectedReturnFromUniswap(amountIn);
+
+		// Get expected return from Mento (if configured)
+		uint256 mentoExpected = 0;
+		bool mentoAvailable = address(mentoBroker) != address(0) && 
+		                      mentoExchangeProvider != address(0) && 
+		                      mentoExchangeId != bytes32(0);
+		
+		if (mentoAvailable) {
+			mentoExpected = getExpectedReturnFromMento(amountIn);
+		}
+
+		// Choose the better option
+		if (mentoAvailable && mentoExpected > uniswapExpected) {
+			// Use Mento if it provides better return
+			bought = swapCusdFromMento(_minAmount, refundGas);
+		} else {
+			// Use Uniswap (default or if Mento not available/not better)
+			bought = swapCUSDfromUniswap(_minAmount, refundGas);
+		}
 	}
 
 	/**
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 80d2a95e..9f8d7ffd 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -136,78 +136,359 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     console.log("✓ Clone created successfully at:", cloneAddress);
   });
 
-  it("Should swap cUSD -> GLOUSD -> G$ via clone", async function () {
-    const { factory, user, gdToken, cusdToken, stableAddress, whale } =
-      await loadFixture(forkCelo);
+  describe("cUSD Swap Tests", function () {
+    it("Should swap cUSD -> G$ via clone (auto-selects best route)", async function () {
+      const { factory, user, gdToken, cusdToken, stableAddress, whale } =
+        await loadFixture(forkCelo);
+
+      // Create clone
+      const cloneAddress = await factory.callStatic.create(user.address);
+      await factory.create(user.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
+
+      // Check stable token
+      const stable = await clone.stable();
+      console.log("Stable token in clone:", stable);
+      expect(stable).to.equal(stableAddress);
+
+      // Transfer cUSD to clone (simulating onramp service)
+      const swapAmount = ethers.utils.parseEther("10");
+      const whaleBalance = await cusdToken.balanceOf(whale.address);
+
+      if (whaleBalance.lt(swapAmount)) {
+        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+        this.skip();
+        return;
+      }
+
+      // Transfer cUSD from whale to clone
+      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+
+      // Get initial G$ balance
+      const initialGdBalance = await gdToken.balanceOf(user.address);
+      console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
+
+      // Get expected returns from both routes
+      const uniswapExpected = await clone.getExpectedReturnFromUniswap(swapAmount);
+      const mentoExpected = await clone.getExpectedReturnFromMento(swapAmount);
+      
+      console.log("Expected returns comparison:");
+      console.log("  Uniswap:", ethers.utils.formatEther(uniswapExpected), "G$");
+      console.log("  Mento:", ethers.utils.formatEther(mentoExpected), "G$");
+      console.log("  Best route:", mentoExpected.gt(uniswapExpected) ? "Mento" : "Uniswap");
+
+      // Calculate min amount using TWAP
+      const [minByTwap] = await clone.minAmountByTWAP(
+        swapAmount,
+        CUSD,
+        300 // 5 minutes
+      );
+      console.log("Min amount by TWAP:", ethers.utils.formatEther(minByTwap));
 
-    // Create clone
-    const cloneAddress = await factory.callStatic.create(user.address);
-    await factory.create(user.address);
-    const clone = (await ethers.getContractAt(
-      "BuyGDCloneV2",
-      cloneAddress
-    )) as BuyGDCloneV2;
+      const minAmount = minByTwap;
+      console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
 
-    // Check stable token
-    const stable = await clone.stable();
-    console.log("Stable token in clone:", stable);
-    expect(stable).to.equal(stableAddress);
+      const swapTx = await clone.swap(minAmount, user.address);
+      const swapReceipt = await swapTx.wait();
 
-    // Transfer cUSD to clone (simulating onramp service)
-    const swapAmount = ethers.utils.parseEther("10");
-    const whaleBalance = await cusdToken.balanceOf(whale.address);
+      // Check for Bought, BoughtFromMento, or BoughtFromUniswap event
+      const boughtEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "Bought"
+      );
+      expect(boughtEvent).to.not.be.undefined;
+      console.log("✓ Swap event emitted:", {
+        event: boughtEvent?.event,
+        inToken: boughtEvent?.args?.inToken,
+        inAmount: ethers.utils.formatEther(boughtEvent?.args?.inAmount),
+        outAmount: ethers.utils.formatEther(boughtEvent?.args?.outAmount),
+      });
+
+      // Check final G$ balance
+      const finalGdBalance = await gdToken.balanceOf(user.address);
+      const gdReceived = finalGdBalance.sub(initialGdBalance);
+      expect(gdReceived).to.be.gt(0);
+      console.log("✓ G$ received:", ethers.utils.formatEther(gdReceived));
+      console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
+
+      // Verify minimum amount
+      expect(gdReceived).to.be.gte(minAmount);
+      console.log("✓ Received amount >= minAmount");
+    });
 
-    if (whaleBalance.lt(swapAmount)) {
-      console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-      this.skip();
-      return;
-    }
+    it("Should swap cUSD via Uniswap directly", async function () {
+      const { factory, user, gdToken, cusdToken, whale } = await loadFixture(forkCelo);
 
-    // Transfer cUSD from whale to clone
-    await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+      await factory.create(user.address);
+      const cloneAddress = await factory.predict(user.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
 
-    // Get initial G$ balance
-    const initialGdBalance = await gdToken.balanceOf(user.address);
-    console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
+      const swapAmount = ethers.utils.parseEther("5");
+      const whaleBalance = await cusdToken.balanceOf(whale.address);
 
-    // Calculate min amount using TWAP
-    const [minByTwap] = await clone.minAmountByTWAP(
-      swapAmount,
-      CUSD,
-      300 // 5 minutes
-    );
-    console.log("Min amount by TWAP:", ethers.utils.formatEther(minByTwap));
+      if (whaleBalance.lt(swapAmount)) {
+        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+        this.skip();
+        return;
+      }
 
-    const minAmount = minByTwap;
-    console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
+      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
 
-    const swapTx = await clone.swap(minAmount, user.address);
-    const swapReceipt = await swapTx.wait();
+      const initialGdBalance = await gdToken.balanceOf(user.address);
+      const [minByTwap] = await clone.minAmountByTWAP(swapAmount, CUSD, 300);
+      const minAmount = minByTwap;
 
-    // Check for Bought event
-    const boughtEvent = swapReceipt.events?.find(
-      (e: any) => e.event === "Bought"
-    );
-    expect(boughtEvent).to.not.be.undefined;
-    console.log("✓ Bought event emitted:", {
-      inToken: boughtEvent?.args?.inToken,
-      inAmount: ethers.utils.formatEther(boughtEvent?.args?.inAmount),
-      outAmount: ethers.utils.formatEther(boughtEvent?.args?.outAmount),
+      const swapTx = await clone.swapCUSDfromUniswap(minAmount, user.address);
+      const swapReceipt = await swapTx.wait();
+
+      // Should emit BoughtFromUniswap event
+      const uniswapEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "BoughtFromUniswap"
+      );
+      expect(uniswapEvent).to.not.be.undefined;
+      console.log("✓ BoughtFromUniswap event emitted:", {
+        inToken: uniswapEvent?.args?.inToken,
+        inAmount: ethers.utils.formatEther(uniswapEvent?.args?.inAmount),
+        outAmount: ethers.utils.formatEther(uniswapEvent?.args?.outAmount),
+      });
+
+      // Should not emit BoughtFromMento event
+      const mentoEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "BoughtFromMento"
+      );
+      expect(mentoEvent).to.be.undefined;
+
+      const finalGdBalance = await gdToken.balanceOf(user.address);
+      const gdReceived = finalGdBalance.sub(initialGdBalance);
+      expect(gdReceived).to.be.gt(0);
+      expect(gdReceived).to.be.gte(minAmount);
+      console.log("✓ Swapped via Uniswap, received:", ethers.utils.formatEther(gdReceived), "G$");
     });
 
-    // Check final G$ balance
-    const finalGdBalance = await gdToken.balanceOf(user.address);
-    const gdReceived = finalGdBalance.sub(initialGdBalance);
-    expect(gdReceived).to.be.gt(0);
-    console.log("✓ G$ received:", ethers.utils.formatEther(gdReceived));
-    console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
+    it("Should compare Uniswap vs Mento and choose better route", async function () {
+      const { factory, user, gdToken, cusdToken, whale } = await loadFixture(forkCelo);
 
-    // Verify minimum amount
-    expect(gdReceived).to.be.gte(minAmount);
-    console.log("✓ Received amount >= minAmount");
+      await factory.create(user.address);
+      const cloneAddress = await factory.predict(user.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
+
+      const swapAmount = ethers.utils.parseEther("5");
+      const whaleBalance = await cusdToken.balanceOf(whale.address);
+
+      if (whaleBalance.lt(swapAmount)) {
+        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+        this.skip();
+        return;
+      }
+
+      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+
+      // Get expected returns
+      const uniswapExpected = await clone.getExpectedReturnFromUniswap(swapAmount);
+      const mentoExpected = await clone.getExpectedReturnFromMento(swapAmount);
+
+      console.log("Route comparison:");
+      console.log("  Uniswap expected:", ethers.utils.formatEther(uniswapExpected), "G$");
+      console.log("  Mento expected:", ethers.utils.formatEther(mentoExpected), "G$");
+
+      const initialGdBalance = await gdToken.balanceOf(user.address);
+      const [minByTwap] = await clone.minAmountByTWAP(swapAmount, CUSD, 300);
+      const minAmount = minByTwap;
+
+      // Call swapCusd which should choose the better route
+      const swapTx = await clone.swapCusd(minAmount, user.address);
+      const swapReceipt = await swapTx.wait();
+
+      const finalGdBalance = await gdToken.balanceOf(user.address);
+      const gdReceived = finalGdBalance.sub(initialGdBalance);
+
+      expect(gdReceived).to.be.gt(0);
+      expect(gdReceived).to.be.gte(minAmount);
+
+      // Check which route was used based on event
+      const mentoEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "BoughtFromMento"
+      );
+      const uniswapEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "BoughtFromUniswap"
+      );
+      const usedMento = mentoEvent !== undefined;
+      const usedUniswap = uniswapEvent !== undefined;
+
+      if (mentoExpected.gt(uniswapExpected)) {
+        expect(usedMento).to.be.true;
+        expect(usedUniswap).to.be.false;
+        console.log("✓ Correctly chose Mento (better return)");
+        console.log("✓ BoughtFromMento event emitted");
+      } else {
+        expect(usedMento).to.be.false;
+        expect(usedUniswap).to.be.true;
+        console.log("✓ Correctly chose Uniswap (better return)");
+        console.log("✓ BoughtFromUniswap event emitted");
+      }
+
+      console.log("✓ Received:", ethers.utils.formatEther(gdReceived), "G$");
+    });
+
+    it("Should use Uniswap when Mento is not configured", async function () {
+      const { deployer, user, gdToken, cusdToken, whale, router, oracleAddress } = await loadFixture(forkCelo);
+
+      // Create factory without Mento configuration
+      const BuyGDCloneFactoryFactory = await ethers.getContractFactory("BuyGDCloneFactory");
+      const factoryWithoutMento = (await BuyGDCloneFactoryFactory.deploy(
+        router.address,
+        process.env.GLOUSD_ADDRESS || GLOUSD_REFERENCE,
+        GOODDOLLAR,
+        oracleAddress,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.HashZero
+      )) as BuyGDCloneFactory;
+
+      await factoryWithoutMento.create(user.address);
+      const cloneAddress = await factoryWithoutMento.predict(user.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
+
+      const swapAmount = ethers.utils.parseEther("5");
+      const whaleBalance = await cusdToken.balanceOf(whale.address);
+
+      if (whaleBalance.lt(swapAmount)) {
+        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+        this.skip();
+        return;
+      }
+
+      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+
+      // Should be able to get Uniswap expected return
+      const uniswapExpected = await clone.getExpectedReturnFromUniswap(swapAmount);
+      expect(uniswapExpected).to.be.gt(0);
+
+      // Should revert when trying to get Mento expected return
+      await expect(clone.getExpectedReturnFromMento(swapAmount)).to.be.revertedWithCustomError(
+        clone,
+        "MENTO_NOT_CONFIGURED"
+      );
+
+      const initialGdBalance = await gdToken.balanceOf(user.address);
+      const [minByTwap] = await clone.minAmountByTWAP(swapAmount, CUSD, 300);
+      const minAmount = minByTwap;
+
+      // swapCusd should use Uniswap (only option)
+      const swapTx = await clone.swapCusd(minAmount, user.address);
+      const swapReceipt = await swapTx.wait();
+
+      // Should emit BoughtFromUniswap event
+      const uniswapEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "BoughtFromUniswap"
+      );
+      expect(uniswapEvent).to.not.be.undefined;
+      console.log("✓ BoughtFromUniswap event emitted:", {
+        inToken: uniswapEvent?.args?.inToken,
+        inAmount: ethers.utils.formatEther(uniswapEvent?.args?.inAmount),
+        outAmount: ethers.utils.formatEther(uniswapEvent?.args?.outAmount),
+      });
+
+      // Should not emit BoughtFromMento event
+      const mentoEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "BoughtFromMento"
+      );
+      expect(mentoEvent).to.be.undefined;
+
+      const finalGdBalance = await gdToken.balanceOf(user.address);
+      const gdReceived = finalGdBalance.sub(initialGdBalance);
+      expect(gdReceived).to.be.gt(0);
+      expect(gdReceived).to.be.gte(minAmount);
+      console.log("✓ Used Uniswap when Mento not configured, received:", ethers.utils.formatEther(gdReceived), "G$");
+    });
+
+    it("Should swap cUSD -> G$ via Mento reserve directly", async function () {
+      const {
+        factory,
+        user,
+        gdToken,
+        cusdToken,
+        whale,
+      } = await loadFixture(forkCelo);
+
+      // Create clone
+      await factory.create(user.address);
+      const cloneAddress = await factory.predict(user.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
+
+      // Transfer cUSD to clone (simulating onramp service)
+      const swapAmount = ethers.utils.parseEther("5");
+      const whaleBalance = await cusdToken.balanceOf(whale.address);
+
+      if (whaleBalance.lt(swapAmount)) {
+        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+        this.skip();
+        return;
+      }
+
+      // Transfer cUSD from whale to clone
+      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+
+      const cloneCusdBalance = await cusdToken.balanceOf(cloneAddress);
+      expect(cloneCusdBalance).to.equal(swapAmount);
+      console.log("✓ cUSD transferred to clone:", ethers.utils.formatEther(swapAmount));
+
+      // Get initial G$ balance
+      const initialGdBalance = await gdToken.balanceOf(user.address);
+      console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
+
+      // Get expected return from Mento
+      const expectedReturn = await clone.getExpectedReturnFromMento(swapAmount);
+      console.log("Expected return from Mento:", ethers.utils.formatEther(expectedReturn), "G$");
+
+      // Use expected return as min amount
+      const minAmount = expectedReturn;
+      console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
+
+      // Perform swap via Mento directly
+      const swapTx = await clone.swapCusdFromMento(minAmount, user.address);
+      const swapReceipt = await swapTx.wait();
+
+      // Check for BoughtFromMento event
+      const boughtEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "BoughtFromMento"
+      );
+      expect(boughtEvent).to.not.be.undefined;
+      console.log("✓ BoughtFromMento event emitted:", {
+        inToken: boughtEvent?.args?.inToken,
+        inAmount: ethers.utils.formatEther(boughtEvent?.args?.inAmount),
+        outAmount: ethers.utils.formatEther(boughtEvent?.args?.outAmount),
+      });
+
+      // Check final G$ balance
+      const finalGdBalance = await gdToken.balanceOf(user.address);
+      const gdReceived = finalGdBalance.sub(initialGdBalance);
+      expect(gdReceived).to.be.gt(0);
+      console.log("✓ G$ received from Mento:", ethers.utils.formatEther(gdReceived));
+      console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
+
+      // Verify minimum amount
+      expect(gdReceived).to.be.gte(minAmount);
+      console.log("✓ Received amount >= minAmount");
+    });
   });
 
-  it("Should swap Celo -> GLOUSD -> G$ via clone", async function () {
+  describe("CELO Swap Tests", function () {
+    it("Should swap Celo -> GLOUSD -> G$ via clone", async function () {
     /// Skip test because forking does not fork the precompiled contracts from celo mainnet
     if(network.name === 'hardhat') {
       this.skip();
@@ -281,12 +562,14 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     console.log("✓ G$ received:", ethers.utils.formatEther(gdReceived));
     console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
 
-    // Verify minimum amount
-    expect(gdReceived).to.be.gte(minAmount);
-    console.log("✓ Received amount >= minAmount");
+      // Verify minimum amount
+      expect(gdReceived).to.be.gte(minAmount);
+      console.log("✓ Received amount >= minAmount");
+    });
   });
 
-  it("Should compare TWAP quote vs actual pool price", async function () {
+  describe("TWAP and Price Comparison Tests", function () {
+    it("Should compare TWAP quote vs actual pool price", async function () {
     const { factory, user, router } = await loadFixture(forkCelo);
 
     // Create clone
@@ -351,10 +634,10 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     // But allow some tolerance for price movement
     expect(minTwap).to.be.lte(actualPrice);
 
-    console.log("✓ TWAP quote comparison completed");
-  });
+      console.log("✓ TWAP quote comparison completed");
+    });
 
-  it("Should revert when minAmount is more than quote", async function () {
+    it("Should revert when minAmount is more than quote", async function () {
     const { factory, user, cusdToken, whale } = await loadFixture(forkCelo);
 
     // Create clone
@@ -395,7 +678,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     // Use minAmount > 98% of quote (99% of quote, which is > minTwap)
     const excessiveMinAmount = twapQuote.mul(102).div(100);
     console.log("Using excessive minAmount (102% of quote):", ethers.utils.formatEther(excessiveMinAmount));
-    console.log("  This is > minTwap (98%), so contract will use:", ethers.utils.formatEther(excessiveMinAmount));
+    console.log("  This is > minTwap (102%), so contract will use:", ethers.utils.formatEther(excessiveMinAmount));
 
     // The swap should revert because excessiveMinAmount > actual pool output
     // The contract enforces: amountOutMinimum = excessiveMinAmount
@@ -404,10 +687,12 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       clone.swap(excessiveMinAmount, user.address)
     ).to.be.reverted; // Should revert with Uniswap "STF" (insufficient output amount) or similar
 
-    console.log("✓ Swap correctly reverts when minAmount > 98% of TWAP quote");
+      console.log("✓ Swap correctly reverts when minAmount > 98% of TWAP quote");
+    });
   });
 
-  it("Should handle createAndSwap in one transaction", async function () {
+  describe("Factory Helper Functions", function () {
+    it("Should handle createAndSwap in one transaction", async function () {
     const { factory, user, deployer, gdToken, cusdToken, whale } = await loadFixture(
       forkCelo
     );
@@ -451,11 +736,12 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     const finalGdBalance = await gdToken.balanceOf(user.address);
     const gdReceived = finalGdBalance.sub(initialGdBalance);
 
-    expect(gdReceived).to.be.gt(0);
-    console.log("✓ createAndSwap successful, G$ received:", ethers.utils.formatEther(gdReceived));
+      expect(gdReceived).to.be.gt(0);
+      console.log("✓ createAndSwap successful, G$ received:", ethers.utils.formatEther(gdReceived));
+    });
   });
 
-  it("Should swap cUSD -> G$ via Mento reserve", async function () {
+  it("Should swap cUSD -> G$ via Mento reserve directly", async function () {
     const {
       factory,
       user,
@@ -498,10 +784,10 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     console.log("Expected return from Mento:", ethers.utils.formatEther(expectedReturn), "G$");
 
     // Use expected return as min amount
-    const minAmount = expectedReturn
+    const minAmount = expectedReturn;
     console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
 
-    // Perform swap via Mento
+    // Perform swap via Mento directly
     const swapTx = await clone.swapCusdFromMento(minAmount, user.address);
     const swapReceipt = await swapTx.wait();
 
@@ -526,52 +812,53 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     // Verify minimum amount
     expect(gdReceived).to.be.gte(minAmount);
     console.log("✓ Received amount >= minAmount");
-    console.log("✓ Received amount is within expected range");
   });
 
-  it("Should revert when calling Mento functions without configuration", async function () {
-    const { factory, user, cusdToken, whale } = await loadFixture(forkCelo);
-
-    // Create a factory without Mento configuration (using zero addresses)
-    const BuyGDCloneFactoryFactory = await ethers.getContractFactory("BuyGDCloneFactory");
-    const factoryWithoutMento = (await BuyGDCloneFactoryFactory.deploy(
-      UNISWAP_V3_ROUTER,
-      process.env.GLOUSD_ADDRESS || GLOUSD_REFERENCE,
-      GOODDOLLAR,
-      STATIC_ORACLE,
-      ethers.constants.AddressZero,
-      ethers.constants.AddressZero,
-      ethers.constants.HashZero
-    )) as BuyGDCloneFactory;
-
-    await factoryWithoutMento.create(user.address);
-    const cloneAddress = await factoryWithoutMento.predict(user.address);
-    const clone = (await ethers.getContractAt(
-      "BuyGDCloneV2",
-      cloneAddress
-    )) as BuyGDCloneV2;
-
-    const testAmount = ethers.utils.parseEther("10");
-
-    // Should revert when getting expected return
-    await expect(clone.getExpectedReturnFromMento(testAmount)).to.be.revertedWithCustomError(
-      clone, 
-      "MENTO_NOT_CONFIGURED"
-    );
-
-    // Transfer cUSD to clone from whale
-    const whaleBalance = await cusdToken.balanceOf(whale.address);
-    if (whaleBalance.gte(testAmount)) {
-      await cusdToken.connect(whale).transfer(cloneAddress, testAmount);
-
-      // Should revert when trying to swap
-      await expect(clone.swapCusdFromMento(0, user.address)).to.be.revertedWithCustomError(
-        clone,
+  describe("Mento Configuration Tests", function () {
+    it("Should revert when calling Mento functions without configuration", async function () {
+      const { deployer, user, cusdToken, whale, router, oracleAddress } = await loadFixture(forkCelo);
+
+      // Create a factory without Mento configuration (using zero addresses)
+      const BuyGDCloneFactoryFactory = await ethers.getContractFactory("BuyGDCloneFactory");
+      const factoryWithoutMento = (await BuyGDCloneFactoryFactory.deploy(
+        router.address,
+        process.env.GLOUSD_ADDRESS || GLOUSD_REFERENCE,
+        GOODDOLLAR,
+        oracleAddress,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.HashZero
+      )) as BuyGDCloneFactory;
+
+      await factoryWithoutMento.create(user.address);
+      const cloneAddress = await factoryWithoutMento.predict(user.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
+
+      const testAmount = ethers.utils.parseEther("10");
+
+      // Should revert when getting expected return
+      await expect(clone.getExpectedReturnFromMento(testAmount)).to.be.revertedWithCustomError(
+        clone, 
         "MENTO_NOT_CONFIGURED"
       );
-    }
 
-    console.log("✓ Mento functions correctly revert when not configured");
+      // Transfer cUSD to clone from whale
+      const whaleBalance = await cusdToken.balanceOf(whale.address);
+      if (whaleBalance.gte(testAmount)) {
+        await cusdToken.connect(whale).transfer(cloneAddress, testAmount);
+
+        // Should revert when trying to swap
+        await expect(clone.swapCusdFromMento(0, user.address)).to.be.revertedWithCustomError(
+          clone,
+          "MENTO_NOT_CONFIGURED"
+        );
+      }
+
+      console.log("✓ Mento functions correctly revert when not configured");
+    });
   });
 });
 

From c867de87a82d387d2f6dffb09a87a5caa05e4375 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Fri, 9 Jan 2026 13:50:05 -0500
Subject: [PATCH 13/37] test: add tolerance check for minimum TWAP in
 BuyGDClone tests to account for price fluctuations

---
 test/utils/BuyGDClone.test.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 9f8d7ffd..b76e1db8 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -633,6 +633,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     // Min TWAP should be less than or equal to actual
     // But allow some tolerance for price movement
     expect(minTwap).to.be.lte(actualPrice);
+    expect(minTwap).to.be.gte(actualPrice.mul(98).div(100));
 
       console.log("✓ TWAP quote comparison completed");
     });

From 8587f6b003d4c33366aeea273036f6c148328a2a Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Mon, 12 Jan 2026 15:17:16 -0500
Subject: [PATCH 14/37] fix: update Hardhat configuration for chain ID and
 forking URL; refactor BuyGDClone contract by removing unused swap functions
 and adding new TWAP calculation methods; enhance tests to compare Uniswap and
 Mento routes for better swap decision-making

---
 contracts/utils/BuyGDClone.sol | 182 +++++------
 hardhat.config.ts              |   6 +-
 test/utils/BuyGDClone.test.ts  | 578 +++++++++++----------------------
 3 files changed, 291 insertions(+), 475 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index 808e4454..8c97107b 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -135,54 +135,6 @@ contract BuyGDCloneV2 is Initializable {
 		}
 	}
 
-	/**
-	 * @notice Swaps cUSD for GD tokens using Uniswap pools.
-	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
-	 * @param refundGas The address to refund gas costs to (if not owner).
-	 * @return bought The amount of GD tokens received.
-	 */
-	function swapCUSDfromUniswap(
-		uint256 _minAmount,
-		address refundGas
-	) public returns (uint256 bought) {
-		uint256 gasCosts = refundGas != owner ? 1e17 : 0; //fixed 0.1$
-		uint256 amountIn = ERC20(CUSD).balanceOf(address(this)) - gasCosts;
-
-		(uint256 minByTwap, ) = minAmountByTWAP(amountIn, CUSD, twapPeriod);
-		_minAmount = _minAmount > minByTwap ? _minAmount : minByTwap;
-
-		ERC20(CUSD).approve(address(router), amountIn);
-		bytes memory path;
-		if (stable == CUSD) {
-			path = abi.encodePacked(CUSD, GD_FEE_TIER, gd);
-		} else {
-			path = abi.encodePacked(CUSD, uint24(100), stable, GD_FEE_TIER, gd);
-		}
-		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
-			path: path,
-			recipient: owner,
-			amountIn: amountIn,
-			amountOutMinimum: _minAmount
-		});
-		bought = router.exactInput(params);
-		if (refundGas != owner) {
-			ERC20(CUSD).transfer(refundGas, gasCosts);
-		}
-		emit BoughtFromUniswap(CUSD, amountIn, bought);
-	}
-
-	/**
-	 * @notice Gets expected return from Uniswap for a given amount of cUSD.
-	 * @param cusdAmount The amount of cUSD to swap.
-	 * @return expectedReturn The expected amount of G$ tokens to receive from Uniswap.
-	 */
-	function getExpectedReturnFromUniswap(
-		uint256 cusdAmount
-	) public view returns (uint256 expectedReturn) {
-		(uint256 minTwap,) = minAmountByTWAP(cusdAmount, CUSD, twapPeriod);
-		return minTwap;
-	}
-
 	/**
 	 * @notice Swaps cUSD for GD tokens, choosing the best route between Uniswap and Mento.
 	 * @dev Compares expected returns from both Uniswap and Mento (if available) and uses the better option.
@@ -222,52 +174,39 @@ contract BuyGDCloneV2 is Initializable {
 	}
 
 	/**
-	 * @notice Calculates the minimum amount of tokens that can be received for a given amount of base tokens,
-	 * based on the time-weighted average price (TWAP) of the token pair over a specified period of time.
-	 * @param baseAmount The amount of base tokens to swap.
-	 * @param baseToken The address of the base token.
-	 * @return minTwap The minimum amount of G$ expected to receive by twap
+	 * @notice Swaps cUSD for GD tokens using Uniswap pools.
+	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
+	 * @param refundGas The address to refund gas costs to (if not owner).
+	 * @return bought The amount of GD tokens received.
 	 */
-	function minAmountByTWAP(
-		uint256 baseAmount,
-		address baseToken,
-		uint32 period
-	) public view returns (uint256 minTwap, uint256 quote) {
-		uint24[] memory fees = new uint24[](1);
+	function swapCUSDfromUniswap(
+		uint256 _minAmount,
+		address refundGas
+	) public returns (uint256 bought) {
+		uint256 gasCosts = refundGas != owner ? 1e17 : 0; //fixed 0.1$
+		uint256 amountIn = ERC20(CUSD).balanceOf(address(this)) - gasCosts;
 
-		uint128 toConvert = uint128(baseAmount);
-		if (baseToken == celo) {
-			/// Set the fee to 500 since there is no pool with a 100 fee tier
-			fees[0] = 500;
-			(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
-				toConvert,
-				baseToken,
-				stable,
-				fees,
-				period
-			);
-			toConvert = uint128(quote);
-		} else if (baseToken == CUSD && stable != CUSD) {
-			fees[0] = 100;
-			(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
-				toConvert,
-				baseToken,
-				stable,
-				fees,
-				period
-			);
-			toConvert = uint128(quote);
+		(uint256 minByTwap, ) = minAmountByTWAP(amountIn, CUSD, twapPeriod);
+		_minAmount = _minAmount > minByTwap ? _minAmount : minByTwap;
+
+		ERC20(CUSD).approve(address(router), amountIn);
+		bytes memory path;
+		if (stable == CUSD) {
+			path = abi.encodePacked(CUSD, GD_FEE_TIER, gd);
+		} else {
+			path = abi.encodePacked(CUSD, uint24(100), stable, GD_FEE_TIER, gd);
 		}
-		fees[0] = GD_FEE_TIER;
-		(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
-			toConvert,
-			stable,
-			gd,
-			fees,
-			period
-		);
-		//minAmount should not be 2% under twap (ie we dont expect price movement > 2% in timePeriod)
-		return ((quote * 98) / 100, quote);
+		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
+			path: path,
+			recipient: owner,
+			amountIn: amountIn,
+			amountOutMinimum: _minAmount
+		});
+		bought = router.exactInput(params);
+		if (refundGas != owner) {
+			ERC20(CUSD).transfer(refundGas, gasCosts);
+		}
+		emit BoughtFromUniswap(CUSD, amountIn, bought);
 	}
 
 	/**
@@ -317,6 +256,18 @@ contract BuyGDCloneV2 is Initializable {
 		emit BoughtFromMento(CUSD, amountIn, bought);
 	}
 
+	/**
+	 * @notice Gets expected return from Uniswap for a given amount of cUSD.
+	 * @param cusdAmount The amount of cUSD to swap.
+	 * @return expectedReturn The expected amount of G$ tokens to receive from Uniswap.
+	 */
+	function getExpectedReturnFromUniswap(
+		uint256 cusdAmount
+	) public view returns (uint256 expectedReturn) {
+		(, uint256 quote) = minAmountByTWAP(cusdAmount, CUSD, twapPeriod);
+		return quote;
+	}
+
 	/**
 	 * @notice Calculates the expected return of G$ tokens for a given amount of cUSD using Mento reserve.
 	 * @dev This is a view function that queries the Mento broker for the expected output.
@@ -339,6 +290,55 @@ contract BuyGDCloneV2 is Initializable {
 		);
 	}
 
+	/**
+	 * @notice Calculates the minimum amount of tokens that can be received for a given amount of base tokens,
+	 * based on the time-weighted average price (TWAP) of the token pair over a specified period of time.
+	 * @param baseAmount The amount of base tokens to swap.
+	 * @param baseToken The address of the base token.
+	 * @return minTwap The minimum amount of G$ expected to receive by twap
+	 */
+	function minAmountByTWAP(
+		uint256 baseAmount,
+		address baseToken,
+		uint32 period
+	) public view returns (uint256 minTwap, uint256 quote) {
+		uint24[] memory fees = new uint24[](1);
+
+		uint128 toConvert = uint128(baseAmount);
+		if (baseToken == celo) {
+			/// Set the fee to 500 since there is no pool with a 100 fee tier
+			fees[0] = 500;
+			(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
+				toConvert,
+				baseToken,
+				stable,
+				fees,
+				period
+			);
+			toConvert = uint128(quote);
+		} else if (baseToken == CUSD && stable != CUSD) {
+			fees[0] = 100;
+			(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
+				toConvert,
+				baseToken,
+				stable,
+				fees,
+				period
+			);
+			toConvert = uint128(quote);
+		}
+		fees[0] = GD_FEE_TIER;
+		(quote, ) = oracle.quoteSpecificFeeTiersWithTimePeriod(
+			toConvert,
+			stable,
+			gd,
+			fees,
+			period
+		);
+		//minAmount should not be 2% under twap (ie we dont expect price movement > 2% in timePeriod)
+		return ((quote * 98) / 100, quote);
+	}
+
 	/**
 	 * @notice Recovers tokens accidentally sent to the contract.
 	 * @param token The address of the token to recover. Use address(0) to recover ETH.
diff --git a/hardhat.config.ts b/hardhat.config.ts
index 6aeaf12d..8a4d0c18 100644
--- a/hardhat.config.ts
+++ b/hardhat.config.ts
@@ -119,20 +119,20 @@ const hhconfig: HardhatUserConfig = {
   },
   contractSizer: {
     alphaSort: false,
-    runOnCompile: true,
+    runOnCompile: false,
     disambiguatePaths: false
   },
 
   networks: {
     hardhat: {
-      chainId: process.env.FORK_CHAIN_ID ? Number(process.env.FORK_CHAIN_ID) : 4447,
+      chainId: process.env.FORK_CHAIN_ID ? Number(process.env.FORK_CHAIN_ID) : 42220,
       allowUnlimitedContractSize: true,
       accounts: {
         accountsBalance: "10000000000000000000000000"
       },
       initialDate: "2021-12-01", //required for DAO tests like guardian
       forking: process.env.FORK_CHAIN_ID && {
-        url: "https://eth-mainnet.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY
+        url: "https://forno.celo.org"
       }
     },
     fork: {
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index b76e1db8..bfe87001 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -31,6 +31,7 @@ const MENTO_BROKER = PRODUCTION_CELO.MentoBroker;
 const MENTO_EXCHANGE_PROVIDER = PRODUCTION_CELO.MentoExchangeProvider;
 const MENTO_EXCHANGE_ID = PRODUCTION_CELO.CUSDExchangeId;
 const CELO = "0x471EcE3750Da237f93B8E339c536989b8978a438";
+const QUOTE = "0x82825d0554fA07f7FC52Ab63c961F330fdEFa8E8";
 
 // GLOUSD address on Celo mainnet
 const GLOUSD_REFERENCE = "0x4F604735c1cF31399C6E711D5962b2B3E0225AD3"; // Common GLOUSD address
@@ -113,111 +114,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     };
   }
 
-  it("Should create a clone for a user", async function () {
-    const { factory, user } = await loadFixture(forkCelo);    
-
-    const predictedAddress = await factory.predict(user.address);
-    console.log("Predicted clone address:", predictedAddress);
-
-    const tx = await factory.create(user.address);
-    const receipt = await tx.wait();
-
-    const cloneAddress = await factory.predict(user.address);
-    expect(cloneAddress).to.equal(predictedAddress);
-
-    const clone = (await ethers.getContractAt(
-      "BuyGDCloneV2",
-      cloneAddress
-    )) as BuyGDCloneV2;
-
-    const owner = await clone.owner();
-    expect(owner).to.equal(user.address);
-
-    console.log("✓ Clone created successfully at:", cloneAddress);
-  });
-
   describe("cUSD Swap Tests", function () {
-    it("Should swap cUSD -> G$ via clone (auto-selects best route)", async function () {
-      const { factory, user, gdToken, cusdToken, stableAddress, whale } =
-        await loadFixture(forkCelo);
-
-      // Create clone
-      const cloneAddress = await factory.callStatic.create(user.address);
-      await factory.create(user.address);
-      const clone = (await ethers.getContractAt(
-        "BuyGDCloneV2",
-        cloneAddress
-      )) as BuyGDCloneV2;
-
-      // Check stable token
-      const stable = await clone.stable();
-      console.log("Stable token in clone:", stable);
-      expect(stable).to.equal(stableAddress);
-
-      // Transfer cUSD to clone (simulating onramp service)
-      const swapAmount = ethers.utils.parseEther("10");
-      const whaleBalance = await cusdToken.balanceOf(whale.address);
-
-      if (whaleBalance.lt(swapAmount)) {
-        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-        this.skip();
-        return;
-      }
-
-      // Transfer cUSD from whale to clone
-      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
-
-      // Get initial G$ balance
-      const initialGdBalance = await gdToken.balanceOf(user.address);
-      console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
-
-      // Get expected returns from both routes
-      const uniswapExpected = await clone.getExpectedReturnFromUniswap(swapAmount);
-      const mentoExpected = await clone.getExpectedReturnFromMento(swapAmount);
-      
-      console.log("Expected returns comparison:");
-      console.log("  Uniswap:", ethers.utils.formatEther(uniswapExpected), "G$");
-      console.log("  Mento:", ethers.utils.formatEther(mentoExpected), "G$");
-      console.log("  Best route:", mentoExpected.gt(uniswapExpected) ? "Mento" : "Uniswap");
-
-      // Calculate min amount using TWAP
-      const [minByTwap] = await clone.minAmountByTWAP(
-        swapAmount,
-        CUSD,
-        300 // 5 minutes
-      );
-      console.log("Min amount by TWAP:", ethers.utils.formatEther(minByTwap));
-
-      const minAmount = minByTwap;
-      console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
-
-      const swapTx = await clone.swap(minAmount, user.address);
-      const swapReceipt = await swapTx.wait();
-
-      // Check for Bought, BoughtFromMento, or BoughtFromUniswap event
-      const boughtEvent = swapReceipt.events?.find(
-        (e: any) => e.event === "Bought"
-      );
-      expect(boughtEvent).to.not.be.undefined;
-      console.log("✓ Swap event emitted:", {
-        event: boughtEvent?.event,
-        inToken: boughtEvent?.args?.inToken,
-        inAmount: ethers.utils.formatEther(boughtEvent?.args?.inAmount),
-        outAmount: ethers.utils.formatEther(boughtEvent?.args?.outAmount),
-      });
-
-      // Check final G$ balance
-      const finalGdBalance = await gdToken.balanceOf(user.address);
-      const gdReceived = finalGdBalance.sub(initialGdBalance);
-      expect(gdReceived).to.be.gt(0);
-      console.log("✓ G$ received:", ethers.utils.formatEther(gdReceived));
-      console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
-
-      // Verify minimum amount
-      expect(gdReceived).to.be.gte(minAmount);
-      console.log("✓ Received amount >= minAmount");
-    });
-
     it("Should swap cUSD via Uniswap directly", async function () {
       const { factory, user, gdToken, cusdToken, whale } = await loadFixture(forkCelo);
 
@@ -265,79 +162,10 @@ describe("BuyGDClone - Celo Fork E2E", function () {
 
       const finalGdBalance = await gdToken.balanceOf(user.address);
       const gdReceived = finalGdBalance.sub(initialGdBalance);
-      expect(gdReceived).to.be.gt(0);
       expect(gdReceived).to.be.gte(minAmount);
       console.log("✓ Swapped via Uniswap, received:", ethers.utils.formatEther(gdReceived), "G$");
     });
 
-    it("Should compare Uniswap vs Mento and choose better route", async function () {
-      const { factory, user, gdToken, cusdToken, whale } = await loadFixture(forkCelo);
-
-      await factory.create(user.address);
-      const cloneAddress = await factory.predict(user.address);
-      const clone = (await ethers.getContractAt(
-        "BuyGDCloneV2",
-        cloneAddress
-      )) as BuyGDCloneV2;
-
-      const swapAmount = ethers.utils.parseEther("5");
-      const whaleBalance = await cusdToken.balanceOf(whale.address);
-
-      if (whaleBalance.lt(swapAmount)) {
-        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-        this.skip();
-        return;
-      }
-
-      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
-
-      // Get expected returns
-      const uniswapExpected = await clone.getExpectedReturnFromUniswap(swapAmount);
-      const mentoExpected = await clone.getExpectedReturnFromMento(swapAmount);
-
-      console.log("Route comparison:");
-      console.log("  Uniswap expected:", ethers.utils.formatEther(uniswapExpected), "G$");
-      console.log("  Mento expected:", ethers.utils.formatEther(mentoExpected), "G$");
-
-      const initialGdBalance = await gdToken.balanceOf(user.address);
-      const [minByTwap] = await clone.minAmountByTWAP(swapAmount, CUSD, 300);
-      const minAmount = minByTwap;
-
-      // Call swapCusd which should choose the better route
-      const swapTx = await clone.swapCusd(minAmount, user.address);
-      const swapReceipt = await swapTx.wait();
-
-      const finalGdBalance = await gdToken.balanceOf(user.address);
-      const gdReceived = finalGdBalance.sub(initialGdBalance);
-
-      expect(gdReceived).to.be.gt(0);
-      expect(gdReceived).to.be.gte(minAmount);
-
-      // Check which route was used based on event
-      const mentoEvent = swapReceipt.events?.find(
-        (e: any) => e.event === "BoughtFromMento"
-      );
-      const uniswapEvent = swapReceipt.events?.find(
-        (e: any) => e.event === "BoughtFromUniswap"
-      );
-      const usedMento = mentoEvent !== undefined;
-      const usedUniswap = uniswapEvent !== undefined;
-
-      if (mentoExpected.gt(uniswapExpected)) {
-        expect(usedMento).to.be.true;
-        expect(usedUniswap).to.be.false;
-        console.log("✓ Correctly chose Mento (better return)");
-        console.log("✓ BoughtFromMento event emitted");
-      } else {
-        expect(usedMento).to.be.false;
-        expect(usedUniswap).to.be.true;
-        console.log("✓ Correctly chose Uniswap (better return)");
-        console.log("✓ BoughtFromUniswap event emitted");
-      }
-
-      console.log("✓ Received:", ethers.utils.formatEther(gdReceived), "G$");
-    });
-
     it("Should use Uniswap when Mento is not configured", async function () {
       const { deployer, user, gdToken, cusdToken, whale, router, oracleAddress } = await loadFixture(forkCelo);
 
@@ -485,6 +313,74 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       expect(gdReceived).to.be.gte(minAmount);
       console.log("✓ Received amount >= minAmount");
     });
+
+    it("Should compare Uniswap vs Mento and choose better route", async function () {
+      const { factory, user, gdToken, cusdToken, whale } = await loadFixture(forkCelo);
+
+      await factory.create(user.address);
+      const cloneAddress = await factory.predict(user.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
+
+      const swapAmount = ethers.utils.parseEther("5");
+      const whaleBalance = await cusdToken.balanceOf(whale.address);
+
+      if (whaleBalance.lt(swapAmount)) {
+        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+        this.skip();
+        return;
+      }
+
+      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+
+      // Get expected returns
+      const uniswapExpected = await clone.getExpectedReturnFromUniswap(swapAmount);
+      const mentoExpected = await clone.getExpectedReturnFromMento(swapAmount);
+
+      console.log("Route comparison:");
+      console.log("  Uniswap expected:", ethers.utils.formatEther(uniswapExpected), "G$");
+      console.log("  Mento expected:", ethers.utils.formatEther(mentoExpected), "G$");
+
+      const initialGdBalance = await gdToken.balanceOf(user.address);
+      const [minByTwap] = await clone.minAmountByTWAP(swapAmount, CUSD, 300);
+      const minAmount = minByTwap;
+
+      // Call swapCusd which should choose the better route
+      const swapTx = await clone.swapCusd(minAmount, user.address);
+      const swapReceipt = await swapTx.wait();
+
+      const finalGdBalance = await gdToken.balanceOf(user.address);
+      const gdReceived = finalGdBalance.sub(initialGdBalance);
+
+      expect(gdReceived).to.be.gt(0);
+      expect(gdReceived).to.be.gte(minAmount);
+
+      // Check which route was used based on event
+      const mentoEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "BoughtFromMento"
+      );
+      const uniswapEvent = swapReceipt.events?.find(
+        (e: any) => e.event === "BoughtFromUniswap"
+      );
+      const usedMento = mentoEvent !== undefined;
+      const usedUniswap = uniswapEvent !== undefined;
+
+      if (mentoExpected.gt(uniswapExpected)) {
+        expect(usedMento).to.be.true;
+        expect(usedUniswap).to.be.false;
+        console.log("✓ Correctly chose Mento (better return)");
+        console.log("✓ BoughtFromMento event emitted");
+      } else {
+        expect(usedMento).to.be.false;
+        expect(usedUniswap).to.be.true;
+        console.log("✓ Correctly chose Uniswap (better return)");
+        console.log("✓ BoughtFromUniswap event emitted");
+      }
+
+      console.log("✓ Received:", ethers.utils.formatEther(gdReceived), "G$");
+    });
   });
 
   describe("CELO Swap Tests", function () {
@@ -570,251 +466,171 @@ describe("BuyGDClone - Celo Fork E2E", function () {
 
   describe("TWAP and Price Comparison Tests", function () {
     it("Should compare TWAP quote vs actual pool price", async function () {
-    const { factory, user, router } = await loadFixture(forkCelo);
-
-    // Create clone
-    await factory.create(user.address);
-    const cloneAddress = await factory.predict(user.address);
-    const clone = (await ethers.getContractAt(
-      "BuyGDCloneV2",
-      cloneAddress
-    )) as BuyGDCloneV2;
+      const { factory, user, router } = await loadFixture(forkCelo);
 
-    const testAmount = ethers.utils.parseEther("10"); // 10 cUSD
-    const stableAddress = await clone.stable();
-    const gdAddress = await clone.gd();
+      // Create clone
+      await factory.create(user.address);
+      const cloneAddress = await factory.predict(user.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
 
-    // Get TWAP quote from oracle
-    const [minTwap, twapQuote] = await clone.minAmountByTWAP(
-      testAmount,
-      CUSD,
-      300 // 5 minutes
-    );
+      const testAmount = ethers.utils.parseEther("10"); // 10 cUSD
+      const stableAddress = await clone.stable();
+      const gdAddress = await clone.gd();
 
-    console.log("TWAP Oracle Quote:");
-    console.log("  Input:", ethers.utils.formatEther(testAmount), "cUSD");
-    console.log("  Min TWAP (98%):", ethers.utils.formatEther(minTwap), "G$");
-    console.log("  TWAP Quote:", ethers.utils.formatEther(twapQuote), "G$");
-
-    // Get actual pool price using QuoterV2
-    const quoterAddress = "0x82825d0554fA07f7FC52Ab63c961F330fdEFa8E8"; // Celo QuoterV2
-    const quoter = await ethers.getContractAt("contracts/Interfaces.sol:IQuoterV2", quoterAddress);
-
-    // Build path: CUSD -> stable -> G$ (using same encoding as contract)
-    let path: string;
-    if (stableAddress.toLowerCase() === CUSD.toLowerCase()) {
-      path = ethers.utils.solidityPack(
-        ["address", "uint24", "address"],
-        [CUSD, 500, gdAddress] // GD_FEE_TIER = 500
-      );
-    } else {
-      path = ethers.utils.solidityPack(
-        ["address", "uint24", "address", "uint24", "address"],
-        [CUSD, 100, stableAddress, 500, gdAddress] // 100 for CUSD->stable, 500 for stable->G$
+      // Get TWAP quote from oracle
+      const [minTwap, twapQuote] = await clone.minAmountByTWAP(
+        testAmount,
+        CUSD,
+        300 // 5 minutes
       );
-    }
 
-    // Get quote from actual pool
-    const [actualAmountOut] = await quoter.callStatic.quoteExactInput(path, testAmount);
-    const actualPrice = actualAmountOut;
+      console.log("TWAP Oracle Quote:");
+      console.log("  Input:", ethers.utils.formatEther(testAmount), "cUSD");
+      console.log("  Min TWAP (98%):", ethers.utils.formatEther(minTwap), "G$");
+      console.log("  TWAP Quote:", ethers.utils.formatEther(twapQuote), "G$");
+
+      // Get actual pool price using QuoterV2
+      const quoter = await ethers.getContractAt("contracts/Interfaces.sol:IQuoterV2", QUOTE);
+
+      // Build path: CUSD -> stable -> G$ (using same encoding as contract)
+      let path: string;
+      if (stableAddress.toLowerCase() === CUSD.toLowerCase()) {
+        path = ethers.utils.solidityPack(
+          ["address", "uint24", "address"],
+          [CUSD, 500, gdAddress] // GD_FEE_TIER = 500
+        );
+      } else {
+        path = ethers.utils.solidityPack(
+          ["address", "uint24", "address", "uint24", "address"],
+          [CUSD, 100, stableAddress, 500, gdAddress] // 100 for CUSD->stable, 500 for stable->G$
+        );
+      }
+
+      // Get quote from actual pool
+      const [actualAmountOut] = await quoter.callStatic.quoteExactInput(path, testAmount);
+      const actualPrice = actualAmountOut;
 
-    console.log("Actual Pool Price:");
-    console.log("  Input:", ethers.utils.formatEther(testAmount), "cUSD");
-    console.log("  Actual Output:", ethers.utils.formatEther(actualPrice), "G$");
+      console.log("Actual Pool Price:");
+      console.log("  Input:", ethers.utils.formatEther(testAmount), "cUSD");
+      console.log("  Actual Output:", ethers.utils.formatEther(actualPrice), "G$");
 
-    // Compare TWAP vs actual
-    const twapVsActual = twapQuote.mul(100).div(actualPrice);
-    const minTwapVsActual = minTwap.mul(100).div(actualPrice);
+      // Compare TWAP vs actual
+      const twapVsActual = twapQuote.mul(100).div(actualPrice);
+      const minTwapVsActual = minTwap.mul(100).div(actualPrice);
 
-    console.log("Comparison:");
-    console.log("  TWAP Quote vs Actual:", twapVsActual.toString(), "%");
-    console.log("  Min TWAP vs Actual:", minTwapVsActual.toString(), "%");
+      console.log("Comparison:");
+      console.log("  TWAP Quote vs Actual:", twapVsActual.toString(), "%");
+      console.log("  Min TWAP vs Actual:", minTwapVsActual.toString(), "%");
 
-    // Min TWAP should be less than or equal to actual
-    // But allow some tolerance for price movement
-    expect(minTwap).to.be.lte(actualPrice);
-    expect(minTwap).to.be.gte(actualPrice.mul(98).div(100));
+      // Min TWAP should be less than or equal to actual
+      // But allow some tolerance for price movement
+      expect(minTwap).to.be.lte(actualPrice);
+      expect(minTwap).to.be.gte(actualPrice.mul(98).div(100));
 
       console.log("✓ TWAP quote comparison completed");
     });
 
     it("Should revert when minAmount is more than quote", async function () {
-    const { factory, user, cusdToken, whale } = await loadFixture(forkCelo);
+      const { factory, user, cusdToken, whale } = await loadFixture(forkCelo);
 
-    // Create clone
-    await factory.create(user.address);
-    const cloneAddress = await factory.predict(user.address);
-    const clone = (await ethers.getContractAt(
-      "BuyGDCloneV2",
-      cloneAddress
-    )) as BuyGDCloneV2;
+      // Create clone
+      await factory.create(user.address);
+      const cloneAddress = await factory.predict(user.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
 
-    // Transfer cUSD to clone
-    const swapAmount = ethers.utils.parseEther("5");
-    const whaleBalance = await cusdToken.balanceOf(whale.address);
+      // Transfer cUSD to clone
+      const swapAmount = ethers.utils.parseEther("5");
+      const whaleBalance = await cusdToken.balanceOf(whale.address);
 
-    if (whaleBalance.lt(swapAmount)) {
-      console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-      this.skip();
-      return;
-    }
+      if (whaleBalance.lt(swapAmount)) {
+        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+        this.skip();
+        return;
+      }
 
-    await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
+      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
 
-    // Get TWAP quote
-    const [minTwap, twapQuote] = await clone.minAmountByTWAP(
-      swapAmount,
-      CUSD,
-      300
-    );
+      // Get TWAP quote
+      const [, twapQuote] = await clone.minAmountByTWAP(
+        swapAmount,
+        CUSD,
+        300
+      );
 
-    console.log("TWAP values:");
-    console.log("  Min TWAP (98%):", ethers.utils.formatEther(minTwap), "G$");
-    console.log("  TWAP Quote:", ethers.utils.formatEther(twapQuote), "G$");
-
-    // The contract uses: _minAmount = _minAmount > minByTwap ? _minAmount : minByTwap
-    // So if we pass a minAmount > minTwap, it will use that higher value
-    // This should cause the swap to revert if the actual pool output is less
-    
-    // Use minAmount > 98% of quote (99% of quote, which is > minTwap)
-    const excessiveMinAmount = twapQuote.mul(102).div(100);
-    console.log("Using excessive minAmount (102% of quote):", ethers.utils.formatEther(excessiveMinAmount));
-    console.log("  This is > minTwap (102%), so contract will use:", ethers.utils.formatEther(excessiveMinAmount));
-
-    // The swap should revert because excessiveMinAmount > actual pool output
-    // The contract enforces: amountOutMinimum = excessiveMinAmount
-    // But the pool likely can't provide that much due to slippage/price impact
-    await expect(
-      clone.swap(excessiveMinAmount, user.address)
-    ).to.be.reverted; // Should revert with Uniswap "STF" (insufficient output amount) or similar
-
-      console.log("✓ Swap correctly reverts when minAmount > 98% of TWAP quote");
+      console.log("TWAP values:");
+      console.log("  TWAP Quote:", ethers.utils.formatEther(twapQuote), "G$");
+      
+      // Use minAmount = 102% of quote
+      const excessiveMinAmount = twapQuote.mul(102).div(100);
+      console.log("Using excessive minAmount (102% of quote):", ethers.utils.formatEther(excessiveMinAmount));
+
+      // The swap should revert because excessiveMinAmount > actual pool output
+      // The contract enforces: amountOutMinimum = excessiveMinAmount
+      // But the pool likely can't provide that much due to slippage/price impact
+      await expect(
+        clone.swap(excessiveMinAmount, user.address)
+      ).to.be.reverted; // Should revert with Uniswap "STF" (insufficient output amount) or similar
+
+      console.log("✓ Swap correctly reverts when minAmount = 102% of TWAP quote");
     });
   });
 
   describe("Factory Helper Functions", function () {
     it("Should handle createAndSwap in one transaction", async function () {
-    const { factory, user, deployer, gdToken, cusdToken, whale } = await loadFixture(
-      forkCelo
-    );
+      const { factory, user, deployer, gdToken, cusdToken, whale } = await loadFixture(
+        forkCelo
+      );
 
-    const swapAmount = ethers.utils.parseEther("5");
-    const whaleBalance = await cusdToken.balanceOf(whale.address);
+      const swapAmount = ethers.utils.parseEther("5");
+      const whaleBalance = await cusdToken.balanceOf(whale.address);
 
-    if (whaleBalance.lt(swapAmount)) {
-      console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-      this.skip();
-      return;
-    }
+      if (whaleBalance.lt(swapAmount)) {
+        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
+        this.skip();
+        return;
+      }
 
-    // Get initial G$ balance
-    const initialGdBalance = await gdToken.balanceOf(user.address);
+      // Get initial G$ balance
+      const initialGdBalance = await gdToken.balanceOf(user.address);
 
-    // Create clone and get address
-    await factory.create(deployer.address);
-    const cloneAddress = await factory.predict(deployer.address);
-    const clone = (await ethers.getContractAt(
-      "BuyGDCloneV2",
-      cloneAddress
-    )) as BuyGDCloneV2;
+      // Create clone and get address
+      await factory.create(deployer.address);
+      const cloneAddress = await factory.predict(deployer.address);
+      const clone = (await ethers.getContractAt(
+        "BuyGDCloneV2",
+        cloneAddress
+      )) as BuyGDCloneV2;
 
-    // Calculate min amount
-    const [minByTwap] = await clone.minAmountByTWAP(
-      swapAmount,
-      CUSD,
-      300
-    );
-    const minAmount = minByTwap;
+      // Calculate min amount
+      const [minByTwap] = await clone.minAmountByTWAP(
+        swapAmount,
+        CUSD,
+        300
+      );
+      const minAmount = minByTwap;
 
-    const predictedAddress = await factory.predict(user.address);
-    cusdToken.connect(whale).transfer(predictedAddress, swapAmount);
-    // Use createAndSwap
-    await cusdToken.connect(user).approve(factory.address, swapAmount);
-    const tx = await factory.connect(user).createAndSwap(user.address, minAmount);
-    const receipt = await tx.wait();
+      const predictedAddress = await factory.predict(user.address);
+      cusdToken.connect(whale).transfer(predictedAddress, swapAmount);
+      // Use createAndSwap
+      await cusdToken.connect(user).approve(factory.address, swapAmount);
+      const tx = await factory.connect(user).createAndSwap(user.address, minAmount);
+      const receipt = await tx.wait();
 
-    // Check final balance
-    const finalGdBalance = await gdToken.balanceOf(user.address);
-    const gdReceived = finalGdBalance.sub(initialGdBalance);
+      // Check final balance
+      const finalGdBalance = await gdToken.balanceOf(user.address);
+      const gdReceived = finalGdBalance.sub(initialGdBalance);
 
-      expect(gdReceived).to.be.gt(0);
+      expect(gdReceived).to.be.gte(minAmount);
       console.log("✓ createAndSwap successful, G$ received:", ethers.utils.formatEther(gdReceived));
     });
   });
 
-  it("Should swap cUSD -> G$ via Mento reserve directly", async function () {
-    const {
-      factory,
-      user,
-      gdToken,
-      cusdToken,
-      whale,
-    } = await loadFixture(forkCelo);
-
-    // Create clone
-    await factory.create(user.address);
-    const cloneAddress = await factory.predict(user.address);
-    const clone = (await ethers.getContractAt(
-      "BuyGDCloneV2",
-      cloneAddress
-    )) as BuyGDCloneV2;
-
-    // Transfer cUSD to clone (simulating onramp service)
-    const swapAmount = ethers.utils.parseEther("5");
-    const whaleBalance = await cusdToken.balanceOf(whale.address);
-
-    if (whaleBalance.lt(swapAmount)) {
-      console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-      this.skip();
-      return;
-    }
-
-    // Transfer cUSD from whale to clone
-    await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
-
-    const cloneCusdBalance = await cusdToken.balanceOf(cloneAddress);
-    expect(cloneCusdBalance).to.equal(swapAmount);
-    console.log("✓ cUSD transferred to clone:", ethers.utils.formatEther(swapAmount));
-
-    // Get initial G$ balance
-    const initialGdBalance = await gdToken.balanceOf(user.address);
-    console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
-
-    // Get expected return from Mento
-    const expectedReturn = await clone.getExpectedReturnFromMento(swapAmount);
-    console.log("Expected return from Mento:", ethers.utils.formatEther(expectedReturn), "G$");
-
-    // Use expected return as min amount
-    const minAmount = expectedReturn;
-    console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
-
-    // Perform swap via Mento directly
-    const swapTx = await clone.swapCusdFromMento(minAmount, user.address);
-    const swapReceipt = await swapTx.wait();
-
-    // Check for BoughtFromMento event
-    const boughtEvent = swapReceipt.events?.find(
-      (e: any) => e.event === "BoughtFromMento"
-    );
-    expect(boughtEvent).to.not.be.undefined;
-    console.log("✓ BoughtFromMento event emitted:", {
-      inToken: boughtEvent?.args?.inToken,
-      inAmount: ethers.utils.formatEther(boughtEvent?.args?.inAmount),
-      outAmount: ethers.utils.formatEther(boughtEvent?.args?.outAmount),
-    });
-
-    // Check final G$ balance
-    const finalGdBalance = await gdToken.balanceOf(user.address);
-    const gdReceived = finalGdBalance.sub(initialGdBalance);
-    expect(gdReceived).to.be.gt(0);
-    console.log("✓ G$ received from Mento:", ethers.utils.formatEther(gdReceived));
-    console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
-
-    // Verify minimum amount
-    expect(gdReceived).to.be.gte(minAmount);
-    console.log("✓ Received amount >= minAmount");
-  });
-
   describe("Mento Configuration Tests", function () {
     it("Should revert when calling Mento functions without configuration", async function () {
       const { deployer, user, cusdToken, whale, router, oracleAddress } = await loadFixture(forkCelo);

From 981ce4b0b314f4b0fdfb05b19df336fda692a89c Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 11:01:56 -0500
Subject: [PATCH 15/37] revert: revert hardhat.config to pass github actions

---
 hardhat.config.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/hardhat.config.ts b/hardhat.config.ts
index 8a4d0c18..04074e86 100644
--- a/hardhat.config.ts
+++ b/hardhat.config.ts
@@ -125,14 +125,14 @@ const hhconfig: HardhatUserConfig = {
 
   networks: {
     hardhat: {
-      chainId: process.env.FORK_CHAIN_ID ? Number(process.env.FORK_CHAIN_ID) : 42220,
+      chainId: process.env.FORK_CHAIN_ID ? Number(process.env.FORK_CHAIN_ID) : 4447,
       allowUnlimitedContractSize: true,
       accounts: {
         accountsBalance: "10000000000000000000000000"
       },
       initialDate: "2021-12-01", //required for DAO tests like guardian
       forking: process.env.FORK_CHAIN_ID && {
-        url: "https://forno.celo.org"
+        url: "https://eth-mainnet.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY
       }
     },
     fork: {

From f09013b623d1c837eac2ff5d3240068fdd4daf9e Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 11:23:43 -0500
Subject: [PATCH 16/37] test: enhance BuyGDClone tests by resetting network
 after execution and updating fork setup with Celo RPC URL

---
 test/utils/BuyGDClone.test.ts | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index bfe87001..ed170b89 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -16,7 +16,9 @@ import { expect } from "chai";
 import { loadFixture } from "@nomicfoundation/hardhat-network-helpers";
 import { BuyGDCloneV2, BuyGDCloneFactory } from "../../types";
 import deployments from "../../releases/deployment.json";
+import * as networkHelpers from "@nomicfoundation/hardhat-network-helpers";
 
+const CELO_RPC_URL = "https://forno.celo.org";
 // Celo mainnet addresses
 const CELO_MAINNET_RPC = "https://forno.celo.org";
 const CELO_CHAIN_ID = 42220;
@@ -43,12 +45,14 @@ describe("BuyGDClone - Celo Fork E2E", function () {
   // Increase timeout for fork tests
   this.timeout(600000);
 
+  this.afterAll(async () => {
+    // Reset network after tests
+    console.log("reseting network...");
+    await networkHelpers.reset();
+  });
   // Set up fork once before all tests
   before(async function () {
-    const network = await ethers.provider.getNetwork();
-    if (network.chainId !== CELO_CHAIN_ID) {
-      this.skip();      
-    }
+    await networkHelpers.reset(CELO_RPC_URL);
   });
 
   async function forkCelo() {

From 1edadf666759eb3d0b8359af8f133919c703877b Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 11:34:43 -0500
Subject: [PATCH 17/37] chore: update Hardhat configuration for forking URL and
 streamline BuyGDClone test setup by removing redundant network reset

---
 hardhat.config.ts             | 2 +-
 test/utils/BuyGDClone.test.ts | 9 +++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/hardhat.config.ts b/hardhat.config.ts
index 04074e86..05063ba9 100644
--- a/hardhat.config.ts
+++ b/hardhat.config.ts
@@ -132,7 +132,7 @@ const hhconfig: HardhatUserConfig = {
       },
       initialDate: "2021-12-01", //required for DAO tests like guardian
       forking: process.env.FORK_CHAIN_ID && {
-        url: "https://eth-mainnet.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY
+        url: "https://forno.celo.org"
       }
     },
     fork: {
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index ed170b89..9f40178e 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -45,15 +45,16 @@ describe("BuyGDClone - Celo Fork E2E", function () {
   // Increase timeout for fork tests
   this.timeout(600000);
 
+  // Set up fork once before all tests
+  before(async function () {
+    await networkHelpers.reset(CELO_RPC_URL);
+  });
+
   this.afterAll(async () => {
     // Reset network after tests
     console.log("reseting network...");
     await networkHelpers.reset();
   });
-  // Set up fork once before all tests
-  before(async function () {
-    await networkHelpers.reset(CELO_RPC_URL);
-  });
 
   async function forkCelo() {
     // Verify we're on the correct chain

From afa0f93db46b0d30235313014b4426376022edab Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 12:02:54 -0500
Subject: [PATCH 18/37] chore: enable contract sizing to run on compile in
 Hardhat configuration

---
 hardhat.config.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hardhat.config.ts b/hardhat.config.ts
index f2e5960a..912bb56b 100644
--- a/hardhat.config.ts
+++ b/hardhat.config.ts
@@ -111,7 +111,7 @@ const hhconfig: HardhatUserConfig = {
   },
   contractSizer: {
     alphaSort: false,
-    runOnCompile: false,
+    runOnCompile: true,
     disambiguatePaths: false
   },
 

From 32b026ea7bb41bdc81a4b69f1d459ffa1d174ed9 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 12:27:57 -0500
Subject: [PATCH 19/37] fix: ensure approval for staking is awaited in
 UBIScheme e2e tests

---
 test/ubi/UBIScheme.e2e.test.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/ubi/UBIScheme.e2e.test.ts b/test/ubi/UBIScheme.e2e.test.ts
index 78e632dd..964f8787 100644
--- a/test/ubi/UBIScheme.e2e.test.ts
+++ b/test/ubi/UBIScheme.e2e.test.ts
@@ -207,7 +207,7 @@ describe("UBIScheme - network e2e tests", () => {
       founder.address,
       ethers.utils.parseEther("1000")
     );
-    dai.approve(simpleStaking.address, ethers.utils.parseEther("1000"));
+    await dai.approve(simpleStaking.address, ethers.utils.parseEther("1000"));
     await simpleStaking.stake(ethers.utils.parseEther("1000"), 0, false);
     await cDAI["mint(address,uint256)"](
       founder.address,

From 1e11f3c9d51b9f80e3cfc762e541495a7cb80c30 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 12:39:42 -0500
Subject: [PATCH 20/37] fix: update BuyGDClone test to correctly impersonate
 whale account and retrieve signer

---
 test/utils/BuyGDClone.test.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 9f40178e..c476798d 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -96,11 +96,12 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     console.log("✓ Factory stable token verified:", factoryStable);
 
     // Impersonate a whale account to get cUSD
-    const whale = await ethers.getImpersonatedSigner(CUSD_WHALE);
+    await ethers.provider.send("hardhat_impersonateAccount", [CUSD_WHALE]);
     await ethers.provider.send("hardhat_setBalance", [
       CUSD_WHALE,
       "0x1000000000000000000",
     ]);
+    const whale = await ethers.getSigner(CUSD_WHALE);
 
     return {
       deployer,

From 5843e11399b5dfe4b16c2290c8912ac34768f70b Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 15:01:24 -0500
Subject: [PATCH 21/37] fix: streamline BuyGDClone test by using
 getImpersonatedSigner for whale account

---
 test/utils/BuyGDClone.test.ts | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index c476798d..9f40178e 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -96,12 +96,11 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     console.log("✓ Factory stable token verified:", factoryStable);
 
     // Impersonate a whale account to get cUSD
-    await ethers.provider.send("hardhat_impersonateAccount", [CUSD_WHALE]);
+    const whale = await ethers.getImpersonatedSigner(CUSD_WHALE);
     await ethers.provider.send("hardhat_setBalance", [
       CUSD_WHALE,
       "0x1000000000000000000",
     ]);
-    const whale = await ethers.getSigner(CUSD_WHALE);
 
     return {
       deployer,

From 9e262877f87bb3d59a861f2056812ffcc7bdc271 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 15:25:28 -0500
Subject: [PATCH 22/37] refactor: simplify BuyGDClone test setup by removing
 redundant network reset and commented out chain ID verification

---
 test/utils/BuyGDClone.test.ts | 17 +++++------------
 1 file changed, 5 insertions(+), 12 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 9f40178e..91a01689 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -47,21 +47,14 @@ describe("BuyGDClone - Celo Fork E2E", function () {
 
   // Set up fork once before all tests
   before(async function () {
-    await networkHelpers.reset(CELO_RPC_URL);
-  });
-
-  this.afterAll(async () => {
-    // Reset network after tests
-    console.log("reseting network...");
-    await networkHelpers.reset();
   });
 
   async function forkCelo() {
-    // Verify we're on the correct chain
-    const network = await ethers.provider.getNetwork();
-    if (network.chainId !== CELO_CHAIN_ID) {
-      throw new Error(`Expected chain ID ${CELO_CHAIN_ID}, got ${network.chainId}`);
-    }
+    // // Verify we're on the correct chain
+    // const network = await ethers.provider.getNetwork();
+    // if (network.chainId !== CELO_CHAIN_ID) {
+    //   throw new Error(`Expected chain ID ${CELO_CHAIN_ID}, got ${network.chainId}`);
+    // }
 
     const [deployer, user] = await ethers.getSigners();
 

From ba33e3929785d0b3d3c3ae87aed46058fbf54bb9 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 15:30:18 -0500
Subject: [PATCH 23/37] refactor: simplify BuyGDClone test setup by removing
 redundant chain ID verification and network reset logic

---
 test/utils/BuyGDClone.test.ts | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 91a01689..2e5e3dde 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -50,11 +50,11 @@ describe("BuyGDClone - Celo Fork E2E", function () {
   });
 
   async function forkCelo() {
-    // // Verify we're on the correct chain
-    // const network = await ethers.provider.getNetwork();
-    // if (network.chainId !== CELO_CHAIN_ID) {
-    //   throw new Error(`Expected chain ID ${CELO_CHAIN_ID}, got ${network.chainId}`);
-    // }
+    // Verify we're on the correct chain
+    const network = await ethers.provider.getNetwork();
+    if (network.chainId !== CELO_CHAIN_ID) {
+      throw new Error(`Expected chain ID ${CELO_CHAIN_ID}, got ${network.chainId}`);
+    }
 
     const [deployer, user] = await ethers.getSigners();
 

From df3f95d796ef90a239a103200bc91c621d6f7d37 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 13 Jan 2026 15:33:52 -0500
Subject: [PATCH 24/37] refactor: update BuyGDClone test to skip execution on
 incorrect chain ID instead of throwing an error

---
 test/utils/BuyGDClone.test.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 2e5e3dde..c8461844 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -47,15 +47,15 @@ describe("BuyGDClone - Celo Fork E2E", function () {
 
   // Set up fork once before all tests
   before(async function () {
-  });
-
-  async function forkCelo() {
     // Verify we're on the correct chain
     const network = await ethers.provider.getNetwork();
     if (network.chainId !== CELO_CHAIN_ID) {
-      throw new Error(`Expected chain ID ${CELO_CHAIN_ID}, got ${network.chainId}`);
+      this.skip();
+      return;
     }
+  });
 
+  async function forkCelo() {
     const [deployer, user] = await ethers.getSigners();
 
     // Get existing contracts from Celo (for router, oracle, tokens)

From 92298384a112dff3345717b322e18b0f57bc4be1 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 14 Jan 2026 06:48:11 -0500
Subject: [PATCH 25/37] refactor: increase gas limit for BuyGDClone test
 deployment to optimize execution

---
 test/utils/BuyGDClone.test.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index c8461844..971a1738 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -77,7 +77,8 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       oracleAddress,
       MENTO_BROKER,
       MENTO_EXCHANGE_PROVIDER,
-      MENTO_EXCHANGE_ID
+      MENTO_EXCHANGE_ID,
+      {gasLimit: 15000000}
     )) as BuyGDCloneFactory;
 
     await factory.deployed();

From bf1b05ea1e7318479fff66bf2203702dfd5138c8 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 14 Jan 2026 07:03:36 -0500
Subject: [PATCH 26/37] refactor: enhance BuyGDClone test setup by resetting
 network after all tests and removing chain ID verification

---
 test/utils/BuyGDClone.test.ts | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 971a1738..373c3c9b 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -18,7 +18,6 @@ import { BuyGDCloneV2, BuyGDCloneFactory } from "../../types";
 import deployments from "../../releases/deployment.json";
 import * as networkHelpers from "@nomicfoundation/hardhat-network-helpers";
 
-const CELO_RPC_URL = "https://forno.celo.org";
 // Celo mainnet addresses
 const CELO_MAINNET_RPC = "https://forno.celo.org";
 const CELO_CHAIN_ID = 42220;
@@ -47,12 +46,11 @@ describe("BuyGDClone - Celo Fork E2E", function () {
 
   // Set up fork once before all tests
   before(async function () {
-    // Verify we're on the correct chain
-    const network = await ethers.provider.getNetwork();
-    if (network.chainId !== CELO_CHAIN_ID) {
-      this.skip();
-      return;
-    }
+    // Reset the network to the Celo mainnet
+    await networkHelpers.reset(CELO_MAINNET_RPC)
+  });
+  this.afterAll(async function () {
+    await networkHelpers.reset();
   });
 
   async function forkCelo() {

From 91bc810f384592bf502a868626c712d8b4cb4bcc Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 14 Jan 2026 07:07:37 -0500
Subject: [PATCH 27/37] refactor: update Hardhat configuration to set block gas
 limit and change forking URL for improved test reliability

---
 hardhat.config.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/hardhat.config.ts b/hardhat.config.ts
index 912bb56b..73fc3a0a 100644
--- a/hardhat.config.ts
+++ b/hardhat.config.ts
@@ -123,8 +123,9 @@ const hhconfig: HardhatUserConfig = {
         accountsBalance: "10000000000000000000000000"
       },
       initialDate: "2021-12-01", //required for DAO tests like guardian
+      blockGasLimit: 50000000, // or higher, like 50000000
       forking: process.env.FORK_CHAIN_ID && {
-        url: "https://eth-mainnet.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY
+        url: "https://eth-mainnet.public.blastapi.io"
       },
     },
     fork: {

From 76f49f97f1f0ae783729334c16db8b1eb02e6322 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 14 Jan 2026 07:18:38 -0500
Subject: [PATCH 28/37] refactor: update Hardhat configuration to change
 forking URL and remove block gas limit for improved test setup

---
 hardhat.config.ts             |  3 +--
 test/utils/BuyGDClone.test.ts | 11 ++++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/hardhat.config.ts b/hardhat.config.ts
index 73fc3a0a..912bb56b 100644
--- a/hardhat.config.ts
+++ b/hardhat.config.ts
@@ -123,9 +123,8 @@ const hhconfig: HardhatUserConfig = {
         accountsBalance: "10000000000000000000000000"
       },
       initialDate: "2021-12-01", //required for DAO tests like guardian
-      blockGasLimit: 50000000, // or higher, like 50000000
       forking: process.env.FORK_CHAIN_ID && {
-        url: "https://eth-mainnet.public.blastapi.io"
+        url: "https://eth-mainnet.alchemyapi.io/v2/" + process.env.ALCHEMY_KEY
       },
     },
     fork: {
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 373c3c9b..1308d16f 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -46,11 +46,12 @@ describe("BuyGDClone - Celo Fork E2E", function () {
 
   // Set up fork once before all tests
   before(async function () {
-    // Reset the network to the Celo mainnet
-    await networkHelpers.reset(CELO_MAINNET_RPC)
-  });
-  this.afterAll(async function () {
-    await networkHelpers.reset();
+    // Verify we're on the correct chain
+    const network = await ethers.provider.getNetwork();
+    if (network.chainId !== CELO_CHAIN_ID) {
+      this.skip();
+      return;
+    }
   });
 
   async function forkCelo() {

From 1198ba2acf563162a608f442b4b41659a78d042b Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 14 Jan 2026 08:20:33 -0500
Subject: [PATCH 29/37] chore: update @nomicfoundation/hardhat-network-helpers
 to version 1.1.2 and adjust test setup in BuyGDClone tests

---
 package.json                  |  2 +-
 test/utils/BuyGDClone.test.ts | 14 +++++++++-----
 yarn.lock                     | 12 ++++++------
 3 files changed, 16 insertions(+), 12 deletions(-)

diff --git a/package.json b/package.json
index 68a7c8ea..c3029fec 100644
--- a/package.json
+++ b/package.json
@@ -76,7 +76,7 @@
     "@jsier/retrier": "^1.2.4",
     "@mean-finance/uniswap-v3-oracle": "^1.0.3",
     "@nomicfoundation/hardhat-chai-matchers": "1",
-    "@nomicfoundation/hardhat-network-helpers": "^1.0.8",
+    "@nomicfoundation/hardhat-network-helpers": "^1.1.2",
     "@nomicfoundation/hardhat-verify": "^2.1.0",
     "@nomiclabs/hardhat-ethers": "^2.2.1",
     "@nomiclabs/hardhat-waffle": "^2.0.6",
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 1308d16f..b415e145 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -44,14 +44,18 @@ describe("BuyGDClone - Celo Fork E2E", function () {
   // Increase timeout for fork tests
   this.timeout(600000);
 
+  this.afterAll(async function () {
+    await networkHelpers.reset();
+  });
   // Set up fork once before all tests
   before(async function () {
+    await networkHelpers.reset(CELO_MAINNET_RPC);
     // Verify we're on the correct chain
-    const network = await ethers.provider.getNetwork();
-    if (network.chainId !== CELO_CHAIN_ID) {
-      this.skip();
-      return;
-    }
+    // const network = await ethers.provider.getNetwork();
+    // if (network.chainId !== CELO_CHAIN_ID) {
+    //   this.skip();
+    //   return;
+    // }
   });
 
   async function forkCelo() {
diff --git a/yarn.lock b/yarn.lock
index a910a9a2..c45f19d0 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2792,7 +2792,7 @@ __metadata:
     "@jsier/retrier": ^1.2.4
     "@mean-finance/uniswap-v3-oracle": ^1.0.3
     "@nomicfoundation/hardhat-chai-matchers": 1
-    "@nomicfoundation/hardhat-network-helpers": ^1.0.8
+    "@nomicfoundation/hardhat-network-helpers": ^1.1.2
     "@nomicfoundation/hardhat-verify": ^2.1.0
     "@nomiclabs/hardhat-ethers": ^2.2.1
     "@nomiclabs/hardhat-waffle": ^2.0.6
@@ -3246,14 +3246,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@nomicfoundation/hardhat-network-helpers@npm:^1.0.8":
-  version: 1.0.8
-  resolution: "@nomicfoundation/hardhat-network-helpers@npm:1.0.8"
+"@nomicfoundation/hardhat-network-helpers@npm:^1.1.2":
+  version: 1.1.2
+  resolution: "@nomicfoundation/hardhat-network-helpers@npm:1.1.2"
   dependencies:
     ethereumjs-util: ^7.1.4
   peerDependencies:
-    hardhat: ^2.9.5
-  checksum: cf865301fa7a8cebf5c249bc872863d2e69f0f3d14cceadbc5d5761bd97745f38fdb17c9074d46ef0d3a75748f43c0e14d37a54a09ae3b7e0e981c7f437c8553
+    hardhat: ^2.26.0
+  checksum: 9b0f3152ebd7ec0b813372f3e837bc249f54e86b76a96bedb78f6142fb1ccc21e3f877a0003542d847a0a8a0aa4243f682bdc1dfbcd964b16e9d2c6f04baec3c
   languageName: node
   linkType: hard
 

From 75996fe594ba66cdb1c1b06a48d354ff4b8eebb0 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 14 Jan 2026 08:24:27 -0500
Subject: [PATCH 30/37] refactor: streamline BuyGDClone test setup by
 reintroducing chain ID verification and removing network reset after tests

---
 test/utils/BuyGDClone.test.ts | 14 +++++---------
 1 file changed, 5 insertions(+), 9 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index b415e145..1308d16f 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -44,18 +44,14 @@ describe("BuyGDClone - Celo Fork E2E", function () {
   // Increase timeout for fork tests
   this.timeout(600000);
 
-  this.afterAll(async function () {
-    await networkHelpers.reset();
-  });
   // Set up fork once before all tests
   before(async function () {
-    await networkHelpers.reset(CELO_MAINNET_RPC);
     // Verify we're on the correct chain
-    // const network = await ethers.provider.getNetwork();
-    // if (network.chainId !== CELO_CHAIN_ID) {
-    //   this.skip();
-    //   return;
-    // }
+    const network = await ethers.provider.getNetwork();
+    if (network.chainId !== CELO_CHAIN_ID) {
+      this.skip();
+      return;
+    }
   });
 
   async function forkCelo() {

From 358e5d650fa4d937c13baa086f8fab484482ea33 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Tue, 27 Jan 2026 11:23:48 -0500
Subject: [PATCH 31/37] refactor: replace console log and test skip with error
 throwing for insufficient whale balance in BuyGDClone tests

---
 test/utils/BuyGDClone.test.ts | 28 +++++++---------------------
 1 file changed, 7 insertions(+), 21 deletions(-)

diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index 1308d16f..ae70d189 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -127,9 +127,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       const whaleBalance = await cusdToken.balanceOf(whale.address);
 
       if (whaleBalance.lt(swapAmount)) {
-        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-        this.skip();
-        return;
+        throw new Error(`Whale doesn't have enough cUSD. Balance: ${ethers.utils.formatEther(whaleBalance)}, Required: ${ethers.utils.formatEther(swapAmount)}`);
       }
 
       await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
@@ -190,9 +188,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       const whaleBalance = await cusdToken.balanceOf(whale.address);
 
       if (whaleBalance.lt(swapAmount)) {
-        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-        this.skip();
-        return;
+        throw new Error(`Whale doesn't have enough cUSD. Balance: ${ethers.utils.formatEther(whaleBalance)}, Required: ${ethers.utils.formatEther(swapAmount)}`);
       }
 
       await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
@@ -261,9 +257,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       const whaleBalance = await cusdToken.balanceOf(whale.address);
 
       if (whaleBalance.lt(swapAmount)) {
-        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-        this.skip();
-        return;
+        throw new Error(`Whale doesn't have enough cUSD. Balance: ${ethers.utils.formatEther(whaleBalance)}, Required: ${ethers.utils.formatEther(swapAmount)}`);
       }
 
       // Transfer cUSD from whale to clone
@@ -326,9 +320,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       const whaleBalance = await cusdToken.balanceOf(whale.address);
 
       if (whaleBalance.lt(swapAmount)) {
-        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-        this.skip();
-        return;
+        throw new Error(`Whale doesn't have enough cUSD. Balance: ${ethers.utils.formatEther(whaleBalance)}, Required: ${ethers.utils.formatEther(swapAmount)}`);
       }
 
       await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
@@ -403,9 +395,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
     const whaleCeloBalance = await celoToken.balanceOf(whale.address);
 
     if (whaleCeloBalance.lt(swapAmount)) {
-      console.log("⚠ Whale doesn't have enough CELO, skipping test");
-      this.skip();
-      return;
+      throw new Error(`Whale doesn't have enough CELO. Balance: ${ethers.utils.formatEther(whaleCeloBalance)}, Required: ${ethers.utils.formatEther(swapAmount)}`);
     }
 
     // Transfer CELO from whale to clone
@@ -547,9 +537,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       const whaleBalance = await cusdToken.balanceOf(whale.address);
 
       if (whaleBalance.lt(swapAmount)) {
-        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-        this.skip();
-        return;
+        throw new Error(`Whale doesn't have enough cUSD. Balance: ${ethers.utils.formatEther(whaleBalance)}, Required: ${ethers.utils.formatEther(swapAmount)}`);
       }
 
       await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
@@ -589,9 +577,7 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       const whaleBalance = await cusdToken.balanceOf(whale.address);
 
       if (whaleBalance.lt(swapAmount)) {
-        console.log("⚠ Whale doesn't have enough cUSD, skipping test");
-        this.skip();
-        return;
+        throw new Error(`Whale doesn't have enough cUSD. Balance: ${ethers.utils.formatEther(whaleBalance)}, Required: ${ethers.utils.formatEther(swapAmount)}`);
       }
 
       // Get initial G$ balance

From 4eab58e763a50ce2f776ee01172005e136fa061c Mon Sep 17 00:00:00 2001
From: blueogin <43612769+blueogin@users.noreply.github.com>
Date: Wed, 28 Jan 2026 07:48:02 -0500
Subject: [PATCH 32/37] Update contracts/utils/BuyGDClone.sol

Co-authored-by: sirpy <hadar@gooddollar.org>
---
 contracts/utils/BuyGDClone.sol | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index 8c97107b..49266968 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -164,7 +164,7 @@ contract BuyGDCloneV2 is Initializable {
 		}
 
 		// Choose the better option
-		if (mentoAvailable && mentoExpected > uniswapExpected) {
+		if (mentoExpected > uniswapExpected) {
 			// Use Mento if it provides better return
 			bought = swapCusdFromMento(_minAmount, refundGas);
 		} else {

From 09fb2110f605db720c25eae53e6ceb7f8a09e5c0 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 28 Jan 2026 09:35:58 -0500
Subject: [PATCH 33/37] refactor: improve BuyGDClone contract by optimizing
 swap functions and updating test cases for better clarity and efficiency

---
 contracts/utils/BuyGDClone.sol |  22 ++--
 test/utils/BuyGDClone.test.ts  | 179 +--------------------------------
 2 files changed, 12 insertions(+), 189 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index 49266968..4ab2d1a6 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -3,6 +3,7 @@
 pragma solidity >=0.8;
 import "@openzeppelin/contracts-upgradeable/proxy/ClonesUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/utils/math/Math.sol";
 import "@mean-finance/uniswap-v3-oracle/solidity/interfaces/IStaticOracle.sol";
 import "../Interfaces.sol";
 import "../MentoInterfaces.sol";
@@ -162,14 +163,14 @@ contract BuyGDCloneV2 is Initializable {
 		if (mentoAvailable) {
 			mentoExpected = getExpectedReturnFromMento(amountIn);
 		}
-
+		uint256 maxExpected = Math.max(_minAmount, Math.max(uniswapExpected, mentoExpected));
 		// Choose the better option
 		if (mentoExpected > uniswapExpected) {
 			// Use Mento if it provides better return
-			bought = swapCusdFromMento(_minAmount, refundGas);
+			bought = _swapCusdFromMento(maxExpected, refundGas);
 		} else {
 			// Use Uniswap (default or if Mento not available/not better)
-			bought = swapCUSDfromUniswap(_minAmount, refundGas);
+			bought = _swapCUSDfromUniswap(maxExpected, refundGas);
 		}
 	}
 
@@ -179,16 +180,13 @@ contract BuyGDCloneV2 is Initializable {
 	 * @param refundGas The address to refund gas costs to (if not owner).
 	 * @return bought The amount of GD tokens received.
 	 */
-	function swapCUSDfromUniswap(
+	function _swapCUSDfromUniswap(
 		uint256 _minAmount,
 		address refundGas
-	) public returns (uint256 bought) {
+	) internal returns (uint256 bought) {
 		uint256 gasCosts = refundGas != owner ? 1e17 : 0; //fixed 0.1$
 		uint256 amountIn = ERC20(CUSD).balanceOf(address(this)) - gasCosts;
 
-		(uint256 minByTwap, ) = minAmountByTWAP(amountIn, CUSD, twapPeriod);
-		_minAmount = _minAmount > minByTwap ? _minAmount : minByTwap;
-
 		ERC20(CUSD).approve(address(router), amountIn);
 		bytes memory path;
 		if (stable == CUSD) {
@@ -216,10 +214,10 @@ contract BuyGDCloneV2 is Initializable {
 	 * @param refundGas The address to refund gas costs to (if not owner).
 	 * @return bought The amount of G$ tokens received.
 	 */
-	function swapCusdFromMento(
+	function _swapCusdFromMento(
 		uint256 _minAmount,
 		address refundGas
-	) public returns (uint256 bought) {
+	) internal returns (uint256 bought) {
 		if (address(mentoBroker) == address(0) || mentoExchangeProvider == address(0) || mentoExchangeId == bytes32(0)) {
 			revert MENTO_NOT_CONFIGURED();
 		}
@@ -228,10 +226,6 @@ contract BuyGDCloneV2 is Initializable {
 		uint256 amountIn = ERC20(CUSD).balanceOf(address(this)) - gasCosts;
 		require(amountIn > 0, "No cUSD balance");
 
-		// Get expected return from Mento
-		uint256 expectedReturn = getExpectedReturnFromMento(amountIn);
-		require(expectedReturn >= _minAmount, "Expected return below minimum");
-
 		// Approve broker to spend cUSD
 		ERC20(CUSD).approve(address(mentoBroker), amountIn);
 
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index ae70d189..d4123c8d 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -44,14 +44,11 @@ describe("BuyGDClone - Celo Fork E2E", function () {
   // Increase timeout for fork tests
   this.timeout(600000);
 
-  // Set up fork once before all tests
+  this.afterAll(async function () {
+    await networkHelpers.reset();
+  });
   before(async function () {
-    // Verify we're on the correct chain
-    const network = await ethers.provider.getNetwork();
-    if (network.chainId !== CELO_CHAIN_ID) {
-      this.skip();
-      return;
-    }
+    await networkHelpers.reset(CELO_MAINNET_RPC);
   });
 
   async function forkCelo() {
@@ -113,55 +110,6 @@ describe("BuyGDClone - Celo Fork E2E", function () {
   }
 
   describe("cUSD Swap Tests", function () {
-    it("Should swap cUSD via Uniswap directly", async function () {
-      const { factory, user, gdToken, cusdToken, whale } = await loadFixture(forkCelo);
-
-      await factory.create(user.address);
-      const cloneAddress = await factory.predict(user.address);
-      const clone = (await ethers.getContractAt(
-        "BuyGDCloneV2",
-        cloneAddress
-      )) as BuyGDCloneV2;
-
-      const swapAmount = ethers.utils.parseEther("5");
-      const whaleBalance = await cusdToken.balanceOf(whale.address);
-
-      if (whaleBalance.lt(swapAmount)) {
-        throw new Error(`Whale doesn't have enough cUSD. Balance: ${ethers.utils.formatEther(whaleBalance)}, Required: ${ethers.utils.formatEther(swapAmount)}`);
-      }
-
-      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
-
-      const initialGdBalance = await gdToken.balanceOf(user.address);
-      const [minByTwap] = await clone.minAmountByTWAP(swapAmount, CUSD, 300);
-      const minAmount = minByTwap;
-
-      const swapTx = await clone.swapCUSDfromUniswap(minAmount, user.address);
-      const swapReceipt = await swapTx.wait();
-
-      // Should emit BoughtFromUniswap event
-      const uniswapEvent = swapReceipt.events?.find(
-        (e: any) => e.event === "BoughtFromUniswap"
-      );
-      expect(uniswapEvent).to.not.be.undefined;
-      console.log("✓ BoughtFromUniswap event emitted:", {
-        inToken: uniswapEvent?.args?.inToken,
-        inAmount: ethers.utils.formatEther(uniswapEvent?.args?.inAmount),
-        outAmount: ethers.utils.formatEther(uniswapEvent?.args?.outAmount),
-      });
-
-      // Should not emit BoughtFromMento event
-      const mentoEvent = swapReceipt.events?.find(
-        (e: any) => e.event === "BoughtFromMento"
-      );
-      expect(mentoEvent).to.be.undefined;
-
-      const finalGdBalance = await gdToken.balanceOf(user.address);
-      const gdReceived = finalGdBalance.sub(initialGdBalance);
-      expect(gdReceived).to.be.gte(minAmount);
-      console.log("✓ Swapped via Uniswap, received:", ethers.utils.formatEther(gdReceived), "G$");
-    });
-
     it("Should use Uniswap when Mento is not configured", async function () {
       const { deployer, user, gdToken, cusdToken, whale, router, oracleAddress } = await loadFixture(forkCelo);
 
@@ -234,78 +182,6 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       expect(gdReceived).to.be.gte(minAmount);
       console.log("✓ Used Uniswap when Mento not configured, received:", ethers.utils.formatEther(gdReceived), "G$");
     });
-
-    it("Should swap cUSD -> G$ via Mento reserve directly", async function () {
-      const {
-        factory,
-        user,
-        gdToken,
-        cusdToken,
-        whale,
-      } = await loadFixture(forkCelo);
-
-      // Create clone
-      await factory.create(user.address);
-      const cloneAddress = await factory.predict(user.address);
-      const clone = (await ethers.getContractAt(
-        "BuyGDCloneV2",
-        cloneAddress
-      )) as BuyGDCloneV2;
-
-      // Transfer cUSD to clone (simulating onramp service)
-      const swapAmount = ethers.utils.parseEther("5");
-      const whaleBalance = await cusdToken.balanceOf(whale.address);
-
-      if (whaleBalance.lt(swapAmount)) {
-        throw new Error(`Whale doesn't have enough cUSD. Balance: ${ethers.utils.formatEther(whaleBalance)}, Required: ${ethers.utils.formatEther(swapAmount)}`);
-      }
-
-      // Transfer cUSD from whale to clone
-      await cusdToken.connect(whale).transfer(cloneAddress, swapAmount);
-
-      const cloneCusdBalance = await cusdToken.balanceOf(cloneAddress);
-      expect(cloneCusdBalance).to.equal(swapAmount);
-      console.log("✓ cUSD transferred to clone:", ethers.utils.formatEther(swapAmount));
-
-      // Get initial G$ balance
-      const initialGdBalance = await gdToken.balanceOf(user.address);
-      console.log("Initial G$ balance:", ethers.utils.formatEther(initialGdBalance));
-
-      // Get expected return from Mento
-      const expectedReturn = await clone.getExpectedReturnFromMento(swapAmount);
-      console.log("Expected return from Mento:", ethers.utils.formatEther(expectedReturn), "G$");
-
-      // Use expected return as min amount
-      const minAmount = expectedReturn;
-      console.log("Using minAmount:", ethers.utils.formatEther(minAmount));
-
-      // Perform swap via Mento directly
-      const swapTx = await clone.swapCusdFromMento(minAmount, user.address);
-      const swapReceipt = await swapTx.wait();
-
-      // Check for BoughtFromMento event
-      const boughtEvent = swapReceipt.events?.find(
-        (e: any) => e.event === "BoughtFromMento"
-      );
-      expect(boughtEvent).to.not.be.undefined;
-      console.log("✓ BoughtFromMento event emitted:", {
-        inToken: boughtEvent?.args?.inToken,
-        inAmount: ethers.utils.formatEther(boughtEvent?.args?.inAmount),
-        outAmount: ethers.utils.formatEther(boughtEvent?.args?.outAmount),
-      });
-
-      // Check final G$ balance
-      const finalGdBalance = await gdToken.balanceOf(user.address);
-      const gdReceived = finalGdBalance.sub(initialGdBalance);
-      expect(gdReceived).to.be.gt(0);
-      console.log("✓ G$ received from Mento:", ethers.utils.formatEther(gdReceived));
-      console.log("Final G$ balance:", ethers.utils.formatEther(finalGdBalance));
-
-      // Verify minimum amount
-      expect(gdReceived).to.be.gte(minAmount);
-      console.log("✓ Received amount >= minAmount");
-    });
-
     it("Should compare Uniswap vs Mento and choose better route", async function () {
       const { factory, user, gdToken, cusdToken, whale } = await loadFixture(forkCelo);
 
@@ -614,52 +490,5 @@ describe("BuyGDClone - Celo Fork E2E", function () {
       console.log("✓ createAndSwap successful, G$ received:", ethers.utils.formatEther(gdReceived));
     });
   });
-
-  describe("Mento Configuration Tests", function () {
-    it("Should revert when calling Mento functions without configuration", async function () {
-      const { deployer, user, cusdToken, whale, router, oracleAddress } = await loadFixture(forkCelo);
-
-      // Create a factory without Mento configuration (using zero addresses)
-      const BuyGDCloneFactoryFactory = await ethers.getContractFactory("BuyGDCloneFactory");
-      const factoryWithoutMento = (await BuyGDCloneFactoryFactory.deploy(
-        router.address,
-        process.env.GLOUSD_ADDRESS || GLOUSD_REFERENCE,
-        GOODDOLLAR,
-        oracleAddress,
-        ethers.constants.AddressZero,
-        ethers.constants.AddressZero,
-        ethers.constants.HashZero
-      )) as BuyGDCloneFactory;
-
-      await factoryWithoutMento.create(user.address);
-      const cloneAddress = await factoryWithoutMento.predict(user.address);
-      const clone = (await ethers.getContractAt(
-        "BuyGDCloneV2",
-        cloneAddress
-      )) as BuyGDCloneV2;
-
-      const testAmount = ethers.utils.parseEther("10");
-
-      // Should revert when getting expected return
-      await expect(clone.getExpectedReturnFromMento(testAmount)).to.be.revertedWithCustomError(
-        clone, 
-        "MENTO_NOT_CONFIGURED"
-      );
-
-      // Transfer cUSD to clone from whale
-      const whaleBalance = await cusdToken.balanceOf(whale.address);
-      if (whaleBalance.gte(testAmount)) {
-        await cusdToken.connect(whale).transfer(cloneAddress, testAmount);
-
-        // Should revert when trying to swap
-        await expect(clone.swapCusdFromMento(0, user.address)).to.be.revertedWithCustomError(
-          clone,
-          "MENTO_NOT_CONFIGURED"
-        );
-      }
-
-      console.log("✓ Mento functions correctly revert when not configured");
-    });
-  });
 });
 

From 12850415028d58e307dfd18f5ab22e38057bb36b Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 28 Jan 2026 10:09:41 -0500
Subject: [PATCH 34/37] refactor: adjust swap logic and return value in
 BuyGDClone contract for improved accuracy

---
 contracts/utils/BuyGDClone.sol | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index 4ab2d1a6..4812be2e 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -8,7 +8,6 @@ import "@mean-finance/uniswap-v3-oracle/solidity/interfaces/IStaticOracle.sol";
 import "../Interfaces.sol";
 import "../MentoInterfaces.sol";
 
-
 /*
  * @title BuyGDClone
  * @notice This contract allows users to swap Celo or stable for GoodDollar (GD) tokens.
@@ -170,7 +169,7 @@ contract BuyGDCloneV2 is Initializable {
 			bought = _swapCusdFromMento(maxExpected, refundGas);
 		} else {
 			// Use Uniswap (default or if Mento not available/not better)
-			bought = _swapCUSDfromUniswap(maxExpected, refundGas);
+			bought = _swapCUSDfromUniswap(maxExpected - 1, refundGas);
 		}
 	}
 
@@ -258,8 +257,8 @@ contract BuyGDCloneV2 is Initializable {
 	function getExpectedReturnFromUniswap(
 		uint256 cusdAmount
 	) public view returns (uint256 expectedReturn) {
-		(, uint256 quote) = minAmountByTWAP(cusdAmount, CUSD, twapPeriod);
-		return quote;
+		(uint256 minByTwap,) = minAmountByTWAP(cusdAmount, CUSD, twapPeriod);
+		return minByTwap;
 	}
 
 	/**

From dee09506c3bb9104df296bee09cf2b16f55454ff Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 28 Jan 2026 10:18:23 -0500
Subject: [PATCH 35/37] chore: downgrade hardhat version from 2.27.2 to 2.26
 for compatibility

---
 package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/package.json b/package.json
index c3029fec..3b124dfc 100644
--- a/package.json
+++ b/package.json
@@ -110,7 +110,7 @@
     "fs-extra": "9.0.0",
     "graphql": "^15.5.0",
     "graphql-request": "^3.4.0",
-    "hardhat": "2.27.2",
+    "hardhat": "2.26",
     "hardhat-contract-sizer": "^2.6.1",
     "hardhat-deploy": "^1.0.4",
     "hardhat-gas-reporter": "^1.0.8",

From 99d2ed379013c1f354e836a873c8154d36886407 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Wed, 28 Jan 2026 10:19:15 -0500
Subject: [PATCH 36/37] chore: update hardhat and related dependencies to
 version 0.11.3 for compatibility

---
 yarn.lock | 90 +++++++++++++++++++++++++++----------------------------
 1 file changed, 45 insertions(+), 45 deletions(-)

diff --git a/yarn.lock b/yarn.lock
index c45f19d0..95ea455c 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2826,7 +2826,7 @@ __metadata:
     fs-extra: 9.0.0
     graphql: ^15.5.0
     graphql-request: ^3.4.0
-    hardhat: 2.27.2
+    hardhat: 2.26
     hardhat-contract-sizer: ^2.6.1
     hardhat-deploy: ^1.0.4
     hardhat-gas-reporter: ^1.0.8
@@ -3164,67 +3164,67 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-darwin-arm64@npm:0.12.0-next.16":
-  version: 0.12.0-next.16
-  resolution: "@nomicfoundation/edr-darwin-arm64@npm:0.12.0-next.16"
-  checksum: a72237ed7aad4cb2aa45e1236be023c584a4447869e11393bdf232bad32cc34c8182e8159bc2b77ac9e0befd450e727cffb946d72a32b6b66c937b25f1924953
+"@nomicfoundation/edr-darwin-arm64@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-darwin-arm64@npm:0.11.3"
+  checksum: e14f01c373f2fb5e7ac9e293f1f2c66d745ad4c73024afd44be72d004236b05f56205b899fb96d1abae01c5523f42402806fec8e200aa7c7d918a171f08f114a
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-darwin-x64@npm:0.12.0-next.16":
-  version: 0.12.0-next.16
-  resolution: "@nomicfoundation/edr-darwin-x64@npm:0.12.0-next.16"
-  checksum: db10ff877a3f994a6ccfe7f1b10268364f41983a226cd2f9274698e3a71dbffefe031ab9a4a19ce8a46e6ff4781e15cc808c1d3d27b4e4bf0b9b36556e8d3a9d
+"@nomicfoundation/edr-darwin-x64@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-darwin-x64@npm:0.11.3"
+  checksum: d31317ed11e2f96af5753d22259249dafeeec7b8eb7fb45721b724fed26eda1c9fedb37561ad2504d6df5276e5b8647d589d19dbb8564aaa9f3b501ef67ef9e5
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-linux-arm64-gnu@npm:0.12.0-next.16":
-  version: 0.12.0-next.16
-  resolution: "@nomicfoundation/edr-linux-arm64-gnu@npm:0.12.0-next.16"
-  checksum: 0ffd2bb6ee6f20605bacfa361d44d5e9d7331940258b56fa6d6ba917c3ae7fcb7c64b968d23f546a26adacfaed9755fb4d722aac80b76b5d36b3d54cda1a116f
+"@nomicfoundation/edr-linux-arm64-gnu@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-linux-arm64-gnu@npm:0.11.3"
+  checksum: ec6898f9a4558e1f23086b327de87f1f3d4fbb686280aa3e977e4577027aa61be826950d15f8729d996a67c79b30cfd25a3f9f2894ca022433c35b72fe3fe6d9
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-linux-arm64-musl@npm:0.12.0-next.16":
-  version: 0.12.0-next.16
-  resolution: "@nomicfoundation/edr-linux-arm64-musl@npm:0.12.0-next.16"
-  checksum: 2caaf25e27c60c1c21cd860f1937a0358dd40f01e51950276dc14a5026cbcf2d8fee02572f5b799147baed89306963ddcaff1745a04d2515040dd65dfaa394cd
+"@nomicfoundation/edr-linux-arm64-musl@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-linux-arm64-musl@npm:0.11.3"
+  checksum: 750ef8948030d7efbc87a17e0e0707f06b9976dcda2d4a1fb41c46b13b377a6ff8a6091662afa3bf20e4e9167a0006b5aa1f5bb3355f5b3cce08b527d6d85708
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-linux-x64-gnu@npm:0.12.0-next.16":
-  version: 0.12.0-next.16
-  resolution: "@nomicfoundation/edr-linux-x64-gnu@npm:0.12.0-next.16"
-  checksum: 8c7fc00626d60e61d5960a7dc21e1955b7f5c5f14df73517f702892cb96d1536a12b121894671d6380de026cc9517ad579f50c93435d020a8595bd9fc9401045
+"@nomicfoundation/edr-linux-x64-gnu@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-linux-x64-gnu@npm:0.11.3"
+  checksum: bcdeac2b242b6b799c902589f9629573815e6773b7ce285012021a02aa51585543c470e1c2504d4cad99f28644c78f5801c34dc31eff58309cf15f1609d60c08
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-linux-x64-musl@npm:0.12.0-next.16":
-  version: 0.12.0-next.16
-  resolution: "@nomicfoundation/edr-linux-x64-musl@npm:0.12.0-next.16"
-  checksum: 13b503ae7625c1ec30d70462322bc36133b8a66ce5b27cf7a4ac7a1fe8ae4d77c652ff0aeaaeb6e4d1f942f99e1a7840a7b72f90ba95b3f3e8374c9d891d1164
+"@nomicfoundation/edr-linux-x64-musl@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-linux-x64-musl@npm:0.11.3"
+  checksum: a8412a808cd80b5c74ad99fbb189daf1ab007e621b67ed3294647f64e11798784ae34b6f1f8e9d0084ba7067601b1a6e9c56f5cabb3b28b9bafec88c48a93d2e
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr-win32-x64-msvc@npm:0.12.0-next.16":
-  version: 0.12.0-next.16
-  resolution: "@nomicfoundation/edr-win32-x64-msvc@npm:0.12.0-next.16"
-  checksum: 53ef3ce82c7187f42f8d93099325259b5037487170cc559115d2ecf138583512b8f5f900e4445885c4e0ffa6f06dcdceaf635b67ac6d6008600f1010edd035a8
+"@nomicfoundation/edr-win32-x64-msvc@npm:0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr-win32-x64-msvc@npm:0.11.3"
+  checksum: dcf2e4e01ceca4bf00c008b672c0f59880e771849a20164edafd54db7805f73c145f4ef0fee49dc6612f7d2c912124072b1c98a03ad1a9b9692eefeab2bbadd2
   languageName: node
   linkType: hard
 
-"@nomicfoundation/edr@npm:0.12.0-next.16":
-  version: 0.12.0-next.16
-  resolution: "@nomicfoundation/edr@npm:0.12.0-next.16"
+"@nomicfoundation/edr@npm:^0.11.3":
+  version: 0.11.3
+  resolution: "@nomicfoundation/edr@npm:0.11.3"
   dependencies:
-    "@nomicfoundation/edr-darwin-arm64": 0.12.0-next.16
-    "@nomicfoundation/edr-darwin-x64": 0.12.0-next.16
-    "@nomicfoundation/edr-linux-arm64-gnu": 0.12.0-next.16
-    "@nomicfoundation/edr-linux-arm64-musl": 0.12.0-next.16
-    "@nomicfoundation/edr-linux-x64-gnu": 0.12.0-next.16
-    "@nomicfoundation/edr-linux-x64-musl": 0.12.0-next.16
-    "@nomicfoundation/edr-win32-x64-msvc": 0.12.0-next.16
-  checksum: a40fabbb58d609289bdb1aacd2ac94f46855ce20acf4016374df1ac7611c979ee1ac9285d16b55a13226be6934b47169ceb5de8c07aab9689c37645f9b865c36
+    "@nomicfoundation/edr-darwin-arm64": 0.11.3
+    "@nomicfoundation/edr-darwin-x64": 0.11.3
+    "@nomicfoundation/edr-linux-arm64-gnu": 0.11.3
+    "@nomicfoundation/edr-linux-arm64-musl": 0.11.3
+    "@nomicfoundation/edr-linux-x64-gnu": 0.11.3
+    "@nomicfoundation/edr-linux-x64-musl": 0.11.3
+    "@nomicfoundation/edr-win32-x64-msvc": 0.11.3
+  checksum: f3e92e1da7f30ae8a377f9f315b28d42296fd0551bc63c4b0f594f3a93e1ec767dc396c50643f086d73cb9cdd0b9466a197dd4e6470a142dbde2aa95d5e11ef9
   languageName: node
   linkType: hard
 
@@ -12983,13 +12983,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"hardhat@npm:2.27.2":
-  version: 2.27.2
-  resolution: "hardhat@npm:2.27.2"
+"hardhat@npm:2.26":
+  version: 2.26.5
+  resolution: "hardhat@npm:2.26.5"
   dependencies:
     "@ethereumjs/util": ^9.1.0
     "@ethersproject/abi": ^5.1.2
-    "@nomicfoundation/edr": 0.12.0-next.16
+    "@nomicfoundation/edr": ^0.11.3
     "@nomicfoundation/solidity-analyzer": ^0.1.0
     "@sentry/node": ^5.18.1
     adm-zip: ^0.4.16
@@ -13036,7 +13036,7 @@ __metadata:
       optional: true
   bin:
     hardhat: internal/cli/bootstrap.js
-  checksum: 004d6441bf8353d6b01b0a52c0a7897388e07be7d25605298040a7439c9bc25126033062e6dfc7fad05f5e077dd900f4bb7999ec3d9634f7425bc6f21ce5c27e
+  checksum: 06577ead0dd45516788ce0ebe9cd64aa121a93eec6cb10f7ecc6fa56c3af7533856298dc6563cd025f3300caff5692c732b675e966cfd4048744996bd9e0b6a4
   languageName: node
   linkType: hard
 

From d5ab123d6d6edf9f60b5c1d2f05e815fb24b2fa2 Mon Sep 17 00:00:00 2001
From: blueogin <grilucosy@gmail.com>
Date: Mon, 2 Feb 2026 12:11:05 -0500
Subject: [PATCH 37/37] fix: correct swap logic in BuyGDClone contract and
 update test assertions for accurate price comparison

---
 contracts/utils/BuyGDClone.sol |  2 +-
 test/utils/BuyGDClone.test.ts  | 11 +++++------
 2 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/contracts/utils/BuyGDClone.sol b/contracts/utils/BuyGDClone.sol
index 4812be2e..6b021b12 100644
--- a/contracts/utils/BuyGDClone.sol
+++ b/contracts/utils/BuyGDClone.sol
@@ -169,7 +169,7 @@ contract BuyGDCloneV2 is Initializable {
 			bought = _swapCusdFromMento(maxExpected, refundGas);
 		} else {
 			// Use Uniswap (default or if Mento not available/not better)
-			bought = _swapCUSDfromUniswap(maxExpected - 1, refundGas);
+			bought = _swapCUSDfromUniswap(maxExpected, refundGas);
 		}
 	}
 
diff --git a/test/utils/BuyGDClone.test.ts b/test/utils/BuyGDClone.test.ts
index d4123c8d..efe9099b 100644
--- a/test/utils/BuyGDClone.test.ts
+++ b/test/utils/BuyGDClone.test.ts
@@ -375,15 +375,14 @@ describe("BuyGDClone - Celo Fork E2E", function () {
 
       // Get quote from actual pool
       const [actualAmountOut] = await quoter.callStatic.quoteExactInput(path, testAmount);
-      const actualPrice = actualAmountOut;
 
       console.log("Actual Pool Price:");
       console.log("  Input:", ethers.utils.formatEther(testAmount), "cUSD");
-      console.log("  Actual Output:", ethers.utils.formatEther(actualPrice), "G$");
+      console.log("  Actual Output:", ethers.utils.formatEther(actualAmountOut), "G$");
 
       // Compare TWAP vs actual
-      const twapVsActual = twapQuote.mul(100).div(actualPrice);
-      const minTwapVsActual = minTwap.mul(100).div(actualPrice);
+      const twapVsActual = twapQuote.mul(100).div(actualAmountOut);
+      const minTwapVsActual = minTwap.mul(100).div(actualAmountOut);
 
       console.log("Comparison:");
       console.log("  TWAP Quote vs Actual:", twapVsActual.toString(), "%");
@@ -391,8 +390,8 @@ describe("BuyGDClone - Celo Fork E2E", function () {
 
       // Min TWAP should be less than or equal to actual
       // But allow some tolerance for price movement
-      expect(minTwap).to.be.lte(actualPrice);
-      expect(minTwap).to.be.gte(actualPrice.mul(98).div(100));
+      expect(minTwap).to.be.lte(actualAmountOut);
+      expect(minTwap).to.be.gte(actualAmountOut.mul(98).div(100));
 
       console.log("✓ TWAP quote comparison completed");
     });