@gooddollar/goodprotocol 2.0.32 → 2.0.34-beta.0

package/contracts/token/superfluid/SuperfluidToken.sol

@@ -69,15 +69,14 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 	 *************************************************************************/
 
 	/// @dev ISuperfluidToken.realtimeBalanceOf implementation
-	function realtimeBalanceOf(address account, uint256 timestamp)
+	function realtimeBalanceOf(
+		address account,
+		uint256 timestamp
+	)
 		public
 		view
 		override
-		returns (
-			int256 availableBalance,
-			uint256 deposit,
-			uint256 owedDeposit
-		)
+		returns (int256 availableBalance, uint256 deposit, uint256 owedDeposit)
 	{
 		availableBalance = _sharedSettledBalances[account];
 		ISuperAgreement[] memory activeAgreements = getAccountActiveAgreements(
@@ -105,7 +104,9 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 	}
 
 	/// @dev ISuperfluidToken.realtimeBalanceOfNow implementation
-	function realtimeBalanceOfNow(address account)
+	function realtimeBalanceOfNow(
+		address account
+	)
 		public
 		view
 		override
@@ -116,38 +117,35 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 			uint256 timestamp
 		)
 	{
-		timestamp = _host.getNow();
+		timestamp = address(_host) != address(0) ? _host.getNow() : block.timestamp;
 		(availableBalance, deposit, owedDeposit) = realtimeBalanceOf(
 			account,
-			timestamp
+			address(_host) != address(0) ? _host.getNow() : block.timestamp
 		);
 	}
 
-	function isAccountCritical(address account, uint256 timestamp)
-		public
-		view
-		override
-		returns (bool isCritical)
-	{
+	function isAccountCritical(
+		address account,
+		uint256 timestamp
+	) public view override returns (bool isCritical) {
 		(int256 availableBalance, , ) = realtimeBalanceOf(account, timestamp);
 		return availableBalance < 0;
 	}
 
-	function isAccountCriticalNow(address account)
-		external
-		view
-		override
-		returns (bool isCritical)
-	{
-		return isAccountCritical(account, _host.getNow());
+	function isAccountCriticalNow(
+		address account
+	) external view override returns (bool isCritical) {
+		return
+			isAccountCritical(
+				account,
+				address(_host) != address(0) ? _host.getNow() : block.timestamp
+			);
 	}
 
-	function isAccountSolvent(address account, uint256 timestamp)
-		public
-		view
-		override
-		returns (bool isSolvent)
-	{
+	function isAccountSolvent(
+		address account,
+		uint256 timestamp
+	) public view override returns (bool isSolvent) {
 		(
 			int256 availableBalance,
 			uint256 deposit,
@@ -159,23 +157,24 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 		return realtimeBalance >= 0;
 	}
 
-	function isAccountSolventNow(address account)
-		external
-		view
-		override
-		returns (bool isSolvent)
-	{
-		return isAccountSolvent(account, _host.getNow());
+	function isAccountSolventNow(
+		address account
+	) external view override returns (bool isSolvent) {
+		return
+			isAccountSolvent(
+				account,
+				address(_host) != address(0) ? _host.getNow() : block.timestamp
+			);
 	}
 
 	/// @dev ISuperfluidToken.getAccountActiveAgreements implementation
-	function getAccountActiveAgreements(address account)
-		public
-		view
-		override
-		returns (ISuperAgreement[] memory)
-	{
-		return _host.mapAgreementClasses(~_inactiveAgreementBitmap[account]);
+	function getAccountActiveAgreements(
+		address account
+	) public view override returns (ISuperAgreement[] memory) {
+		return
+			address(_host) != address(0)
+				? _host.mapAgreementClasses(~_inactiveAgreementBitmap[account])
+				: new ISuperAgreement[](0);
 	}
 
 	/**************************************************************************
@@ -190,7 +189,10 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 	}
 
 	function _burn(address account, uint256 amount) internal {
-		(int256 availableBalance, , ) = realtimeBalanceOf(account, _host.getNow());
+		(int256 availableBalance, , ) = realtimeBalanceOf(
+			account,
+			address(_host) != address(0) ? _host.getNow() : block.timestamp
+		);
 		if (availableBalance < amount.toInt256()) {
 			revert SF_TOKEN_BURN_INSUFFICIENT_BALANCE();
 		}
@@ -200,12 +202,11 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 		_totalSupply = _totalSupply - amount;
 	}
 
-	function _move(
-		address from,
-		address to,
-		int256 amount
-	) internal {
-		(int256 availableBalance, , ) = realtimeBalanceOf(from, _host.getNow());
+	function _move(address from, address to, int256 amount) internal {
+		(int256 availableBalance, , ) = realtimeBalanceOf(
+			from,
+			address(_host) != address(0) ? _host.getNow() : block.timestamp
+		);
 		if (availableBalance < amount) {
 			revert SF_TOKEN_MOVE_INSUFFICIENT_BALANCE();
 		}
@@ -227,11 +228,10 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 	 *************************************************************************/
 
 	/// @dev ISuperfluidToken.createAgreement implementation
-	function createAgreement(bytes32 id, bytes32[] calldata data)
-		public
-		virtual
-		override
-	{
+	function createAgreement(
+		bytes32 id,
+		bytes32[] calldata data
+	) public virtual override {
 		address agreementClass = msg.sender;
 		bytes32 slot = keccak256(abi.encode("AgreementData", agreementClass, id));
 		if (FixedSizeData.hasData(slot, data.length)) {
@@ -252,10 +252,10 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 	}
 
 	/// @dev ISuperfluidToken.updateAgreementData implementation
-	function updateAgreementData(bytes32 id, bytes32[] calldata data)
-		external
-		override
-	{
+	function updateAgreementData(
+		bytes32 id,
+		bytes32[] calldata data
+	) external override {
 		address agreementClass = msg.sender;
 		bytes32 slot = keccak256(abi.encode("AgreementData", agreementClass, id));
 		FixedSizeData.storeData(slot, data);
@@ -263,10 +263,10 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 	}
 
 	/// @dev ISuperfluidToken.terminateAgreement implementation
-	function terminateAgreement(bytes32 id, uint256 dataLength)
-		external
-		override
-	{
+	function terminateAgreement(
+		bytes32 id,
+		uint256 dataLength
+	) external override {
 		address agreementClass = msg.sender;
 		bytes32 slot = keccak256(abi.encode("AgreementData", agreementClass, id));
 		if (!FixedSizeData.hasData(slot, dataLength)) {
@@ -303,11 +303,10 @@ abstract contract SuperfluidToken is ISuperfluidToken {
 	}
 
 	/// @dev ISuperfluidToken.settleBalance implementation
-	function settleBalance(address account, int256 delta)
-		external
-		override
-		onlyAgreement
-	{
+	function settleBalance(
+		address account,
+		int256 delta
+	) external override onlyAgreement {
 		_sharedSettledBalances[account] = _sharedSettledBalances[account] + delta;
 	}
 

package/contracts/ubi/UBISchemeV2.sol

@@ -129,17 +129,12 @@ contract UBISchemeV2 is DAOUpgradeableContract {
 	/**
 	 * @dev Constructor
 	 * @param _ns the DAO
-	 * @param _maxInactiveDays Days of grace without claiming request
 	 */
-	function initialize(
-		INameService _ns,
-		uint256 _maxInactiveDays
-	) public initializer {
-		require(_maxInactiveDays > 0, "Max inactive days cannot be zero");
+	function initialize(INameService _ns) public initializer {
 		setDAO(_ns);
 		shouldWithdrawFromDAO = false;
 		cycleLength = 30; //30 days
-		periodStart = (block.timestamp / (1 days)) * 1 days + 12 hours; //set start time to GMT noon
+		periodStart = (block.timestamp / (1 days)) * 1 days - 12 hours; //set start time to GMT noon
 		startOfCycle = periodStart;
 		minActiveUsers = 1000;
 		reserveFactor = 10500;
@@ -240,13 +235,12 @@ contract UBISchemeV2 is DAOUpgradeableContract {
 			uint256 currentBalance = token.balanceOf(address(this));
 			//start early cycle if daily pool size is +%5 previous pool or not enough until end of cycle
 			uint256 nextDailyPool = currentBalance / cycleLength;
-			bool shouldStartEarlyCycle = nextDailyPool >
-				(dailyCyclePool * 105) / 100 ||
-				currentBalance < (dailyCyclePool * (cycleLength - currentDayInCycle()));
+			bool shouldStartCycle = currentDayInCycle() >= currentCycleLength ||
+				(nextDailyPool > (dailyCyclePool * 105) / 100 ||
+					currentBalance <
+					(dailyCyclePool * (cycleLength - currentDayInCycle())));
 
-			if (
-				currentDayInCycle() >= currentCycleLength || shouldStartEarlyCycle
-			) //start of cycle or first time
+			if (shouldStartCycle) //start of cycle or first time
 			{
 				if (shouldWithdrawFromDAO) {
 					_withdrawFromDao();
@@ -347,16 +341,16 @@ contract UBISchemeV2 is DAOUpgradeableContract {
 		uint256 currentBalance = nativeToken().balanceOf(address(this));
 		//start early cycle if we can increase the daily UBI pool
 		uint256 nextDailyPool = currentBalance / cycleLength;
-		bool shouldStartEarlyCycle = nextDailyPool > (dailyCyclePool * 105) / 100 ||
+		bool shouldStartEarlyCycle = currentDayInCycle() + 1 >=
+			currentCycleLength ||
+			nextDailyPool > (dailyCyclePool * 105) / 100 ||
 			currentBalance < (dailyCyclePool * (cycleLength - currentDayInCycle()));
 
 		uint256 _dailyCyclePool = dailyCyclePool;
 		uint256 _dailyUbi;
-		if (
-			(currentDayInCycle() + 1) >= currentCycleLength || shouldStartEarlyCycle
-		) //start of cycle or first time
+		if (shouldStartEarlyCycle) //start of cycle or first time
 		{
-			_dailyCyclePool = currentBalance / cycleLength;
+			_dailyCyclePool = nextDailyPool;
 		}
 
 		_dailyUbi =

package/contracts/utils/BuyFromReserveHelper.sol

@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "../MentoInterfaces.sol";
+import "@openzeppelin/contracts/access/AccessControl.sol";
+import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
+
+contract BuyFromReserveHelper is AccessControl, ReentrancyGuard {
+	using SafeERC20 for IERC20;
+
+	bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");
+	bytes32 public constant EXECUTOR_ROLE = keccak256("EXECUTOR_ROLE");
+
+	address public safe;
+	address public exchangeProvider;
+	bytes32 public exchangeId;
+	IERC20 public tokenIn;
+	IERC20 public tokenOut;
+	IBroker public broker;
+
+	event SafeUpdated(address indexed newSafe);
+	event SettingsUpdated(
+		address indexed exchangeProvider,
+		bytes32 indexed exchangeId
+	);
+	event GDBought(address indexed buyer, uint256 amountIn, uint256 amountOut);
+
+	constructor(
+		address _safe,
+		address _tokenIn,
+		address _tokenOut,
+		address _broker,
+		address _exchangeProvider,
+		bytes32 _exchangeId
+	) {
+		require(_safe != address(0), "Safe address cannot be zero");
+		require(_tokenIn != address(0), "TokenIn address cannot be zero");
+		require(_tokenOut != address(0), "TokenOut address cannot be zero");
+		require(_broker != address(0), "Broker address cannot be zero");
+		require(_exchangeProvider != address(0), "ExchangeProvider cannot be zero");
+		require(_exchangeId != bytes32(0), "ExchangeId cannot be zero");
+
+		safe = _safe;
+		tokenIn = IERC20(_tokenIn);
+		tokenOut = IERC20(_tokenOut);
+		broker = IBroker(_broker);
+		exchangeProvider = _exchangeProvider;
+		exchangeId = _exchangeId;
+
+		_setupRole(DEFAULT_ADMIN_ROLE, _safe);
+		_setupRole(EXECUTOR_ROLE, msg.sender);
+	}
+
+	function updateSafe(address _newSafe) external {
+		require(msg.sender == safe, "Only safe can update");
+		require(_newSafe != address(0), "New safe address cannot be zero");
+
+		// Update admin role
+		_revokeRole(DEFAULT_ADMIN_ROLE, safe);
+		_setupRole(DEFAULT_ADMIN_ROLE, _newSafe);
+
+		safe = _newSafe;
+		emit SafeUpdated(_newSafe);
+	}
+
+	function updateSettings(
+		address _exchangeProvider,
+		bytes32 _exchangeId,
+		address _tokenIn,
+		address _tokenOut,
+		address _broker
+	) external onlyRole(DEFAULT_ADMIN_ROLE) {
+		require(_exchangeProvider != address(0), "ExchangeProvider cannot be zero");
+		require(_exchangeId != bytes32(0), "ExchangeId cannot be zero");
+		require(_tokenIn != address(0), "TokenIn address cannot be zero");
+		require(_tokenOut != address(0), "TokenOut address cannot be zero");
+		require(_broker != address(0), "Broker address cannot be zero");
+
+		exchangeProvider = _exchangeProvider;
+		exchangeId = _exchangeId;
+		tokenIn = IERC20(_tokenIn);
+		tokenOut = IERC20(_tokenOut);
+		broker = IBroker(_broker);
+
+		emit SettingsUpdated(_exchangeProvider, _exchangeId);
+	}
+
+	function buyGdFromBroker(
+		uint256 amountInNominal,
+		uint256 minReturnNominal
+	) external onlyRole(EXECUTOR_ROLE) nonReentrant {
+		require(amountInNominal > 0, "Amount must be greater than zero");
+		require(minReturnNominal > 0, "Minimum return must be greater than zero");
+
+		uint256 amountIn = amountInNominal * 1e18;
+		uint256 minReturn = minReturnNominal * 1e18;
+
+		// assume minimum price for 0.00005 for G$ for safety check
+		require((amountIn * 1e18) / 5e13 >= minReturn, "minReturn seems too low");
+
+		// Transfer tokenIn from the safe to this contract
+		tokenIn.safeTransferFrom(safe, address(this), amountIn);
+
+		// Reset any existing approval
+		tokenIn.safeApprove(address(broker), 0);
+		// Approve the broker to spend tokenIn
+		tokenIn.safeApprove(address(broker), amountIn);
+
+		// Call the broker to buy tokenOut (G$)
+		uint256 amountOut = broker.swapIn(
+			exchangeProvider,
+			exchangeId,
+			address(tokenIn),
+			address(tokenOut),
+			amountIn,
+			minReturn
+		);
+
+		// Verify minimum return
+		require(amountOut >= minReturn, "Insufficient return amount");
+
+		// Transfer bought tokens to safe
+		tokenOut.safeTransfer(safe, amountOut);
+
+		emit GDBought(msg.sender, amountIn, amountOut);
+	}
+}