@juicedollar/jusd 1.0.0

package/contracts/gateway/SavingsGateway.sol

@@ -0,0 +1,51 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+import {IFrontendGateway} from "./interface/IFrontendGateway.sol";
+import {Context} from "@openzeppelin/contracts/utils/Context.sol";
+import {IJuiceDollar} from "../interface/IJuiceDollar.sol";
+import {Savings} from "../Savings.sol";
+
+contract SavingsGateway is Savings, Context {
+    IFrontendGateway public immutable GATEWAY;
+
+    constructor(IJuiceDollar jusd_, uint24 initialRatePPM, address gateway_) Savings(jusd_, initialRatePPM) {
+        GATEWAY = IFrontendGateway(gateway_);
+    }
+
+    function refresh(address accountOwner) internal override returns (Account storage) {
+        Account storage account = savings[accountOwner];
+        uint64 ticks = currentTicks();
+        if (ticks > account.ticks) {
+            uint192 earnedInterest = calculateInterest(account, ticks);
+            if (earnedInterest > 0) {
+                // collect interest as you go and trigger accounting event
+                (IJuiceDollar(address(jusd))).distributeProfits(address(this), earnedInterest);
+                account.saved += earnedInterest;
+                GATEWAY.updateSavingRewards(accountOwner, earnedInterest);
+                emit InterestCollected(accountOwner, earnedInterest);
+            }
+            account.ticks = ticks;
+        }
+        return account;
+    }
+
+    function save(uint192 amount, bytes32 frontendCode) public {
+        save(_msgSender(), amount, frontendCode);
+    }
+
+    function save(address owner, uint192 amount, bytes32 frontendCode) public {
+        GATEWAY.updateSavingCode(_msgSender(), frontendCode);
+        save(owner, amount);
+    }
+
+    function adjust(uint192 targetAmount, bytes32 frontendCode) public {
+        GATEWAY.updateSavingCode(_msgSender(), frontendCode);
+        adjust(targetAmount);
+    }
+
+    function withdraw(address target, uint192 amount, bytes32 frontendCode) public returns (uint256) {
+        GATEWAY.updateSavingCode(_msgSender(), frontendCode);
+        return withdraw(target, amount);
+    }
+}

package/contracts/gateway/interface/ICoinLendingGateway.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.10;
+
+/**
+ * @title ICoinLendingGateway
+ * @notice Interface for the Coin Lending Gateway contract
+ */
+interface ICoinLendingGateway {
+    /**
+     * @notice Emitted when a position is created with native coins
+     * @param owner The owner of the newly created position
+     * @param position The address of the newly created position
+     * @param coinAmount The amount of native coin used as collateral
+     * @param mintAmount The amount of JUSD minted
+     * @param liquidationPrice The liquidation price set for the position
+     */
+    event PositionCreatedWithCoin(
+        address indexed owner,
+        address indexed position,
+        uint256 coinAmount,
+        uint256 mintAmount,
+        uint256 liquidationPrice
+    );
+
+    /**
+     * @notice Creates a lending position using native coins in a single transaction
+     * @param parent The parent position to clone from
+     * @param initialMint The amount of JUSD to mint
+     * @param expiration The expiration timestamp for the position
+     * @param frontendCode The frontend referral code
+     * @param liquidationPrice The desired liquidation price (0 to skip adjustment)
+     * @return position The address of the newly created position
+     */
+    function lendWithCoin(
+        address parent,
+        uint256 initialMint,
+        uint40 expiration,
+        bytes32 frontendCode,
+        uint256 liquidationPrice
+    ) external payable returns (address position);
+
+    /**
+     * @notice Creates a lending position for another owner using native coins
+     * @param owner The address that will own the position
+     * @param parent The parent position to clone from
+     * @param initialMint The amount of JUSD to mint
+     * @param expiration The expiration timestamp for the position
+     * @param frontendCode The frontend referral code
+     * @param liquidationPrice The desired liquidation price (0 to skip adjustment)
+     * @return position The address of the newly created position
+     */
+    function lendWithCoinFor(
+        address owner,
+        address parent,
+        uint256 initialMint,
+        uint40 expiration,
+        bytes32 frontendCode,
+        uint256 liquidationPrice
+    ) external payable returns (address position);
+
+    /**
+     * @notice Rescue function to withdraw accidentally sent native coins
+     */
+    function rescueCoin() external;
+
+    /**
+     * @notice Rescue function to withdraw accidentally sent tokens
+     * @param token The address of the token to rescue
+     * @param to The address to send the tokens to
+     * @param amount The amount of tokens to rescue
+     */
+    function rescueToken(address token, address to, uint256 amount) external;
+}

package/contracts/gateway/interface/IFrontendGateway.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface IFrontendGateway {
+    struct FrontendCode {
+        uint256 balance;
+        address owner;
+    }
+
+    event FrontendCodeRegistered(address owner, bytes32 frontendCode);
+    event FrontendCodeTransferred(address from, address to, bytes32 frontendCode);
+    event FrontendCodeRewardsWithdrawn(address to, uint256 amount, bytes32 frontendCode);
+    event NewPositionRegistered(address position, bytes32 frontendCode);
+    event RateChangesProposed(address who, uint24 nextFeeRate, uint24 nextSavingsFeeRate, uint24 nextMintingFeeRate, uint256 nextChange);
+    event RateChangesExecuted(address who, uint24 nextFeeRate, uint24 nextSavingsFeeRate, uint24 nextMintingFeeRate);
+    
+    event InvestRewardAdded(bytes32 frontendCode, address user, uint256 amount, uint256 reward);
+    event RedeemRewardAdded(bytes32 frontendCode, address user, uint256 amount, uint256 reward);
+    event SavingsRewardAdded(bytes32 frontendCode, address saver, uint256 interest, uint256 reward);
+    event PositionRewardAdded(bytes32 frontendCode, address position, uint256 amount, uint256 reward);
+
+    error FrontendCodeAlreadyExists();
+    error NotFrontendCodeOwner();
+    error NotGatewayService();
+    error ProposedChangesToHigh();
+    error NoOpenChanges();
+    error NotDoneWaiting(uint256 minmumExecutionTime);
+    error EquityTooLow();
+
+    function invest(uint256 amount, uint256 expectedShares, bytes32 frontendCode) external returns (uint256);
+    function redeem(address target, uint256 shares, uint256 expectedProceeds, bytes32 frontendCode) external returns (uint256);
+
+    function updateSavingCode(address savingsOwner, bytes32 frontendCode) external;
+    function updateSavingRewards(address saver, uint256 interest) external;
+
+    function registerPosition(address position, bytes32 frontendCode) external;
+    function updatePositionRewards(address position, uint256 amount) external;
+    function getPositionFrontendCode(address position)view external  returns(bytes32);
+
+    // Frontend Code Logic
+    function registerFrontendCode(bytes32 frontendCode) external returns (bool);
+    function transferFrontendCode(bytes32 frontendCode, address to) external returns (bool);
+    function withdrawRewards(bytes32 frontendCode) external returns (uint256);
+    function withdrawRewardsTo(bytes32 frontendCode, address to) external returns (uint256);
+
+    // Governance
+    function proposeChanges(uint24 newFeeRatePPM_, uint24 newSavingsFeeRatePPM_, uint24 newMintingFeeRatePPM_, address[] calldata helpers) external;
+    function executeChanges() external;
+}

package/contracts/gateway/interface/IMintingHubGateway.sol

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import {IMintingHub} from "../../MintingHubV2/interface/IMintingHub.sol";
+import {IFrontendGateway} from "./IFrontendGateway.sol";
+
+interface IMintingHubGateway {
+    function GATEWAY() external view returns (IFrontendGateway);
+    function notifyInterestPaid(uint256 amount) external;
+    function openPosition(address _collateralAddress, uint256 _minCollateral, uint256 _initialCollateral, uint256 _mintingMaximum, uint40 _initPeriodSeconds, uint40 _expirationSeconds, uint40 _challengeSeconds, uint24 _riskPremium, uint256 _liqPrice, uint24 _reservePPM, bytes32 _frontendCode) external returns (address);
+    function clone(address owner, address parent, uint256 _initialCollateral, uint256 _initialMint, uint40 expiration, bytes32 frontendCode) external returns (address);
+}

package/contracts/impl/ERC3009.sol

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+import {EIP712} from "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
+
+abstract contract ERC3009 is ERC20, EIP712 {
+    bytes32 public constant TRANSFER_WITH_AUTHORIZATION_TYPEHASH =
+        keccak256(
+            "TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)"
+        );
+
+    bytes32 public constant RECEIVE_WITH_AUTHORIZATION_TYPEHASH =
+        keccak256(
+            "ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)"
+        );
+
+    bytes32 public constant CANCEL_AUTHORIZATION_TYPEHASH =
+        keccak256("CancelAuthorization(address authorizer,bytes32 nonce)");
+
+    /**
+     * @dev authorizer address => nonce => state (true = used / false = unused)
+     */
+    mapping(address => mapping(bytes32 => bool)) internal _authorizationStates;
+
+    event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce);
+    event AuthorizationCanceled(address indexed authorizer, bytes32 indexed nonce);
+
+    string internal constant _INVALID_SIGNATURE_ERROR = "EIP3009: invalid signature";
+    string internal constant _AUTHORIZATION_USED_ERROR = "EIP3009: authorization is used";
+
+    /**
+     * @notice Returns the state of an authorization
+     * @dev Nonces are randomly generated 32-byte data unique to the authorizer's
+     * address
+     * @param authorizer    Authorizer's address
+     * @param nonce         Nonce of the authorization
+     * @return True if the nonce is used
+     */
+    function authorizationState(address authorizer, bytes32 nonce) external view returns (bool) {
+        return _authorizationStates[authorizer][nonce];
+    }
+
+    /**
+     * @notice Execute a transfer with a signed authorization
+     * @param from          Payer's address (Authorizer)
+     * @param to            Payee's address
+     * @param value         Amount to be transferred
+     * @param validAfter    The time after which this is valid (unix time)
+     * @param validBefore   The time before which this is valid (unix time)
+     * @param nonce         Unique nonce
+     * @param v             v of the signature
+     * @param r             r of the signature
+     * @param s             s of the signature
+     */
+    function transferWithAuthorization(
+        address from,
+        address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external {
+        _transferWithAuthorization(
+            TRANSFER_WITH_AUTHORIZATION_TYPEHASH,
+            from,
+            to,
+            value,
+            validAfter,
+            validBefore,
+            nonce,
+            v,
+            r,
+            s
+        );
+    }
+
+    /**
+     * @notice Receive a transfer with a signed authorization from the payer
+     * @dev This has an additional check to ensure that the payee's address matches
+     * the caller of this function to prevent front-running attacks. (See security
+     * considerations)
+     * @param from          Payer's address (Authorizer)
+     * @param to            Payee's address
+     * @param value         Amount to be transferred
+     * @param validAfter    The time after which this is valid (unix time)
+     * @param validBefore   The time before which this is valid (unix time)
+     * @param nonce         Unique nonce
+     * @param v             v of the signature
+     * @param r             r of the signature
+     * @param s             s of the signature
+     */
+    function receiveWithAuthorization(
+        address from,
+        address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external {
+        require(to == msg.sender, "EIP3009: caller must be the payee");
+
+        _transferWithAuthorization(
+            RECEIVE_WITH_AUTHORIZATION_TYPEHASH,
+            from,
+            to,
+            value,
+            validAfter,
+            validBefore,
+            nonce,
+            v,
+            r,
+            s
+        );
+    }
+
+    /**
+     * @notice Attempt to cancel an authorization
+     * @param authorizer    Authorizer's address
+     * @param nonce         Nonce of the authorization
+     * @param v             v of the signature
+     * @param r             r of the signature
+     * @param s             s of the signature
+     */
+    function cancelAuthorization(address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s) external {
+        require(!_authorizationStates[authorizer][nonce], _AUTHORIZATION_USED_ERROR);
+
+        bytes memory data = abi.encode(CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce);
+
+        bytes32 hash = _hashTypedDataV4(keccak256(data));
+        require(ECDSA.recover(hash, v, r, s) == authorizer, _INVALID_SIGNATURE_ERROR);
+
+        _authorizationStates[authorizer][nonce] = true;
+        emit AuthorizationCanceled(authorizer, nonce);
+    }
+
+    function _transferWithAuthorization(
+        bytes32 typeHash,
+        address from,
+        address to,
+        uint256 value,
+        uint256 validAfter,
+        uint256 validBefore,
+        bytes32 nonce,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) internal {
+        require(block.timestamp > validAfter, "EIP3009: authorization is not yet valid");
+        require(block.timestamp < validBefore, "EIP3009: authorization is expired");
+        require(!_authorizationStates[from][nonce], _AUTHORIZATION_USED_ERROR);
+
+        bytes memory data = abi.encode(typeHash, from, to, value, validAfter, validBefore, nonce);
+
+        bytes32 hash = _hashTypedDataV4(keccak256(data));
+
+        require(ECDSA.recover(hash, v, r, s) == from, _INVALID_SIGNATURE_ERROR);
+
+        _authorizationStates[from][nonce] = true;
+        emit AuthorizationUsed(from, nonce);
+
+        _transfer(from, to, value);
+    }
+}

package/contracts/interface/IJuiceDollar.sol

@@ -0,0 +1,54 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IReserve} from "./IReserve.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IJuiceDollar is IERC20 {
+    function suggestMinter(
+        address _minter,
+        uint256 _applicationPeriod,
+        uint256 _applicationFee,
+        string calldata _message
+    ) external;
+
+    function registerPosition(address position) external;
+
+    function denyMinter(address minter, address[] calldata helpers, string calldata message) external;
+
+    function reserve() external view returns (IReserve);
+
+    function minterReserve() external view returns (uint256);
+
+    function calculateAssignedReserve(uint256 mintedAmount, uint32 _reservePPM) external view returns (uint256);
+
+    function calculateFreedAmount(uint256 amountExcludingReserve, uint32 _reservePPM) external view returns (uint256);
+
+    function equity() external view returns (uint256);
+
+    function isMinter(address minter) external view returns (bool);
+
+    function getPositionParent(address position) external view returns (address);
+
+    function mint(address target, uint256 amount) external;
+
+    function mintWithReserve(address target, uint256 amount, uint32 reservePPM) external;
+
+    function burn(uint256 amount) external;
+
+    function burnFrom(address target, uint256 amount) external;
+
+    function burnWithoutReserve(uint256 amount, uint32 reservePPM) external;
+
+    function burnFromWithReserve(
+        address payer,
+        uint256 targetTotalBurnAmount,
+        uint32 reservePPM
+    ) external returns (uint256);
+
+    function coverLoss(address source, uint256 amount) external;
+
+    function distributeProfits(address recipient, uint256 amount) external;
+
+    function collectProfits(address source, uint256 _amount) external;
+}

package/contracts/interface/ILeadrate.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface ILeadrate {
+   function currentRatePPM() external view returns (uint24);
+   function currentTicks() external view returns (uint64);
+}

package/contracts/interface/IReserve.sol

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IReserve is IERC20 {
+    function invest(uint256 amount, uint256 expected) external returns (uint256);
+    function checkQualified(address sender, address[] calldata helpers) external view;
+}

package/contracts/interface/ISavingsJUSD.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+interface ISavingsJUSD {
+	struct Account {
+		uint192 saved;
+		uint64 ticks;
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	event Saved(address indexed account, uint192 amount);
+	event InterestCollected(address indexed account, uint256 interest);
+	event Withdrawn(address indexed account, uint192 amount);
+
+	// ---------------------------------------------------------------------------------------
+
+	error ModuleDisabled();
+
+	// ---------------------------------------------------------------------------------------
+
+	function savings(address account) external view returns (Account memory);
+
+	// ---------------------------------------------------------------------------------------
+
+	function currentTicks() external view returns (uint64);
+
+	function currentRatePPM() external view returns (uint24);
+
+	function accruedInterest(address accountOwner) external view returns (uint192);
+
+	function accruedInterest(address accountOwner, uint256 timestamp) external view returns (uint192);
+
+	function calculateInterest(Account memory account, uint64 ticks) external view returns (uint192);
+
+	// ---------------------------------------------------------------------------------------
+
+	function save(uint192 amount) external;
+
+	function save(address owner, uint192 amount) external;
+
+	function withdraw(address target, uint192 amount) external returns (uint256);
+
+	function adjust(uint192 targetAmount) external;
+
+	function refreshMyBalance() external returns (uint192);
+
+	function refreshBalance(address owner) external returns (uint192);
+}

package/contracts/test/FreakToken.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract FreakToken is ERC20 {
+    uint8 private _decimals;
+
+    constructor(string memory name_, string memory symbol_, uint8 decimals_) ERC20(name_, symbol_) {
+        _decimals = decimals_;
+        _mint(msg.sender, 1_000_000 * 1e18);
+    }
+
+    function decimals() public view override returns (uint8) {
+        return _decimals;
+    }
+
+    function mint(address _account, uint256 _amount) external {
+        _mint(_account, _amount);
+    }
+
+    function transfer(address, uint256) public virtual override returns (bool) {
+        return true;
+    }
+}