@juicedollar/jusd 1.0.0

package/contracts/test/TestToken.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+import {ERC3009} from "../impl/ERC3009.sol";
+
+contract TestToken is ERC20,  EIP712, ERC3009, ERC20Burnable {
+    uint8 private _decimals;
+
+    constructor(string memory name_, string memory symbol_, uint8 decimals_)  EIP712(name_, "1") ERC20(name_, symbol_) {
+        _decimals = decimals_;
+        _mint(msg.sender, 10_000_000 * 1e18);
+    }
+
+    function decimals() public view override returns (uint8) {
+        return _decimals;
+    }
+
+    function mint(address _account, uint256 _amount) external {
+        _mint(_account, _amount);
+    }
+
+    // Note: Doesn't revert on failure, instead returns false (same as USDC token).
+    // This behaviour is used in BasicTests.ts (SafeERC20 test).
+    function transferFrom(
+        address from,
+        address to,
+        uint256 amount
+    ) public override returns (bool) {
+        uint256 currentAllowance = allowance(from, msg.sender);
+        if (currentAllowance < amount) {
+            return false;
+        }
+
+        if (balanceOf(from) < amount) {
+            return false;
+        }
+
+        _approve(from, msg.sender, currentAllowance - amount); // Update allowance
+        _transfer(from, to, amount); // Perform the transfer
+        return true;
+    }
+}

package/contracts/test/TestWcBTC.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+/**
+ * @title TestWcBTC
+ * @notice Test WcBTC (Wrapped cBTC) implementation for testing CoinLendingGateway on Citrea
+ */
+contract TestWcBTC is ERC20 {
+    error InsufficientBalance();
+    error CBTCTransferFailed();
+
+    event Deposit(address indexed dst, uint256 wad);
+    event Withdrawal(address indexed src, uint256 wad);
+
+    constructor() ERC20("Wrapped cBTC", "WcBTC") {}
+
+    receive() external payable {
+        deposit();
+    }
+
+    function deposit() public payable {
+        _mint(msg.sender, msg.value);
+        emit Deposit(msg.sender, msg.value);
+    }
+
+    function withdraw(uint256 wad) external {
+        if (balanceOf(msg.sender) < wad) revert InsufficientBalance();
+        _burn(msg.sender, wad);
+        (bool success, ) = msg.sender.call{value: wad}("");
+        if (!success) revert CBTCTransferFailed();
+        emit Withdrawal(msg.sender, wad);
+    }
+}

package/contracts/utils/MathUtil.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/**
+ * @title Functions for share valuation
+ */
+contract MathUtil {
+    uint256 internal constant ONE_DEC18 = 10 ** 18;
+
+    // Let's go for 12 digits of precision (18-6)
+    uint256 internal constant THRESH_DEC18 = 10 ** 6;
+
+    /**
+     * @notice Tenth root with Halley approximation
+     *         Number 1e18 decimal
+     * @param _v     number for which we calculate x**(1/10)
+     * @return returns _v**(1/10)
+     */
+    function _tenthRoot(uint256 _v) internal pure returns (uint256) {
+        // Good first guess for _v slightly above 1.0, which is often the case in the JUSD system
+        uint256 x = _v > ONE_DEC18 && _v < 10 ** 19 ? (_v - ONE_DEC18) / 10 + ONE_DEC18 : ONE_DEC18;
+        uint256 diff;
+        do {
+            uint256 powX10 = _power10(x);
+            uint256 xnew = _mulD18(x, _divD18(11 * _v + 9 * powX10, 9 * _v + 11 * powX10));
+            diff = xnew > x ? xnew - x : x - xnew;
+            x = xnew;
+        } while (diff > THRESH_DEC18);
+        return x;
+    }
+
+    function _mulD18(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        return (_a * _b) / ONE_DEC18;
+    }
+
+    function _divD18(uint256 _a, uint256 _b) internal pure returns (uint256) {
+        return (_a * ONE_DEC18) / _b;
+    }
+
+    function _power10(uint256 _x) internal pure returns (uint256) {
+        uint256 x2 = _mulD18(_x, _x);
+        uint256 x4 = _mulD18(x2, x2);
+        uint256 x5 = _mulD18(x4, _x);
+        return _mulD18(x5, x5);
+    }
+
+    function _min(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a < b ? a : b;
+    }
+    
+    /**
+     * @notice Performs ceiling division for PPM calculations using formula: ceil(amount / (1 - ppm/1000000))
+     * @param amount The base amount to divide
+     * @param ppm Parts per million value (e.g., 200000 for 20%)
+     * @return The result of ceiling division
+     */
+    function _ceilDivPPM(uint256 amount, uint24 ppm) internal pure returns (uint256) {
+        return amount == 0 ? 0 : (amount * 1_000_000 - 1) / (1_000_000 - ppm) + 1;
+    }
+}