@usdu-core/usdu-core 0.0.1

package/contracts/curve/helpers/ICurveStableSwapNG.sol

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+interface ICurveStableSwapNG {
+	event Transfer(address indexed sender, address indexed receiver, uint256 value);
+	event Approval(address indexed owner, address indexed spender, uint256 value);
+
+	event TokenExchange(address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought);
+
+	event TokenExchangeUnderlying(address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought);
+
+	event AddLiquidity(address indexed provider, uint256[] token_amounts, uint256[] fees, uint256 invariant, uint256 token_supply);
+
+	event RemoveLiquidity(address indexed provider, uint256[] token_amounts, uint256[] fees, uint256 token_supply);
+
+	event RemoveLiquidityOne(address indexed provider, int128 token_id, uint256 token_amount, uint256 coin_amount, uint256 token_supply);
+
+	event RemoveLiquidityImbalance(
+		address indexed provider,
+		uint256[] token_amounts,
+		uint256[] fees,
+		uint256 invariant,
+		uint256 token_supply
+	);
+
+	event RampA(uint256 old_A, uint256 new_A, uint256 initial_time, uint256 future_time);
+
+	event StopRampA(uint256 A, uint256 t);
+
+	event ApplyNewFee(uint256 fee, uint256 offpeg_fee_multiplier);
+
+	event SetNewMATime(uint256 ma_exp_time, uint256 D_ma_time);
+
+	// ----- Core Functions -----
+	function exchange(int128 i, int128 j, uint256 _dx, uint256 _min_dy) external returns (uint256);
+
+	function exchange(int128 i, int128 j, uint256 _dx, uint256 _min_dy, address _receiver) external returns (uint256);
+
+	function exchange_received(int128 i, int128 j, uint256 _dx, uint256 _min_dy) external returns (uint256);
+
+	function exchange_received(int128 i, int128 j, uint256 _dx, uint256 _min_dy, address _receiver) external returns (uint256);
+
+	function add_liquidity(uint256[] calldata _amounts, uint256 _min_mint_amount) external returns (uint256);
+
+	function add_liquidity(uint256[] calldata _amounts, uint256 _min_mint_amount, address _receiver) external returns (uint256);
+
+	function remove_liquidity_one_coin(uint256 _burn_amount, int128 i, uint256 _min_received) external returns (uint256);
+
+	function remove_liquidity_one_coin(uint256 _burn_amount, int128 i, uint256 _min_received, address _receiver) external returns (uint256);
+
+	function remove_liquidity_imbalance(uint256[] calldata _amounts, uint256 _max_burn_amount) external returns (uint256);
+
+	function remove_liquidity_imbalance(
+		uint256[] calldata _amounts,
+		uint256 _max_burn_amount,
+		address _receiver
+	) external returns (uint256);
+
+	function remove_liquidity(uint256 _burn_amount, uint256[] calldata _min_amounts) external returns (uint256[] memory);
+
+	function remove_liquidity(uint256 _burn_amount, uint256[] calldata _min_amounts, address _receiver) external returns (uint256[] memory);
+
+	function remove_liquidity(
+		uint256 _burn_amount,
+		uint256[] calldata _min_amounts,
+		address _receiver,
+		bool _claim_admin_fees
+	) external returns (uint256[] memory);
+
+	// ----- Admin & Fee Management -----
+	function withdraw_admin_fees() external;
+
+	function ramp_A(uint256 _future_A, uint256 _future_time) external;
+
+	function stop_ramp_A() external;
+
+	function set_new_fee(uint256 _new_fee, uint256 _new_offpeg_fee_multiplier) external;
+
+	// ----- ERC20-like -----
+	function transfer(address _to, uint256 _value) external returns (bool);
+
+	function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
+
+	function approve(address _spender, uint256 _value) external returns (bool);
+
+	function permit(
+		address _owner,
+		address _spender,
+		uint256 _value,
+		uint256 _deadline,
+		uint8 _v,
+		bytes32 _r,
+		bytes32 _s
+	) external returns (bool);
+
+	// ----- Views -----
+	function last_price(uint256 i) external view returns (uint256);
+
+	function ema_price(uint256 i) external view returns (uint256);
+
+	function get_p(uint256 i) external view returns (uint256);
+
+	function price_oracle(uint256 i) external view returns (uint256);
+
+	function D_oracle() external view returns (uint256);
+
+	function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+	function get_dx(int128 i, int128 j, uint256 dy) external view returns (uint256);
+
+	function get_dy(int128 i, int128 j, uint256 dx) external view returns (uint256);
+
+	function calc_withdraw_one_coin(uint256 _burn_amount, int128 i) external view returns (uint256);
+
+	function totalSupply() external view returns (uint256);
+
+	function get_virtual_price() external view returns (uint256);
+
+	function calc_token_amount(uint256[] calldata _amounts, bool _is_deposit) external view returns (uint256);
+
+	function A() external view returns (uint256);
+
+	function A_precise() external view returns (uint256);
+
+	function balances(uint256 i) external view returns (uint256);
+
+	function get_balances() external view returns (uint256[] memory);
+
+	function stored_rates() external view returns (uint256[] memory);
+
+	function dynamic_fee(int128 i, int128 j) external view returns (uint256);
+
+	function set_ma_exp_time(uint256 _ma_exp_time, uint256 _D_ma_time) external;
+
+	// --- View functions ---
+	function N_COINS() external view returns (uint256);
+
+	function coins(uint256 arg0) external view returns (address);
+
+	function fee() external view returns (uint256);
+
+	function offpeg_fee_multiplier() external view returns (uint256);
+
+	function admin_fee() external view returns (uint256);
+
+	function initial_A() external view returns (uint256);
+
+	function future_A() external view returns (uint256);
+
+	function initial_A_time() external view returns (uint256);
+
+	function future_A_time() external view returns (uint256);
+
+	function admin_balances(uint256 arg0) external view returns (uint256);
+
+	function ma_exp_time() external view returns (uint256);
+
+	function D_ma_time() external view returns (uint256);
+
+	function ma_last_time() external view returns (uint256);
+
+	function name() external view returns (string memory);
+
+	function symbol() external view returns (string memory);
+
+	function decimals() external view returns (uint8);
+
+	function version() external view returns (string memory);
+
+	function balanceOf(address arg0) external view returns (uint256);
+
+	function allowance(address arg0, address arg1) external view returns (uint256);
+
+	function nonces(address arg0) external view returns (uint256);
+
+	function salt() external view returns (bytes32);
+}

package/contracts/deploy/VaultDeployer.sol

@@ -0,0 +1,110 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {Stablecoin} from '../stablecoin/Stablecoin.sol';
+
+import {IMorpho, MarketParams, Id} from '../morpho/helpers/IMorpho.sol';
+import {ConstantsLib} from '../morpho/helpers/ConstantsLib.sol';
+
+import {IMetaMorphoV1_1} from '../morpho/helpers/IMetaMorphoV1_1.sol';
+import {IMetaMorphoV1_1Factory} from '../morpho/helpers/IMetaMorphoV1_1Factory.sol';
+
+import {MorphoAdapterV1} from '../morpho/MorphoAdapterV1.sol';
+import {RewardRouterV0} from '../reward/RewardRouterV0.sol';
+
+contract VaultDeployer {
+	IMetaMorphoV1_1Factory public immutable vaultFactory;
+	IMorpho public immutable morpho;
+	address public immutable alloc;
+	address public immutable urd;
+
+	Stablecoin public immutable stable;
+
+	IMetaMorphoV1_1 public immutable core;
+	IMetaMorphoV1_1 public immutable staked;
+
+	MorphoAdapterV1 public immutable adapter;
+	RewardRouterV0 public immutable reward;
+
+	constructor(IMorpho _morpho, IMetaMorphoV1_1Factory _factory, address _alloc, address _urd, address _curator) {
+		// deploy stablecoin
+		stable = new Stablecoin('USDU', 'USDU', address(this));
+
+		// morpho contracts
+		vaultFactory = _factory;
+		morpho = _morpho;
+		alloc = _alloc;
+		urd = _urd;
+
+		// set up morpho vaults
+		core = vaultFactory.createMetaMorpho(address(this), 0, address(stable), 'USDU Core', 'sUSDU', 0);
+		core.setCurator(_curator);
+		core.setFeeRecipient(_curator);
+		core.setFee(ConstantsLib.MAX_FEE);
+		core.setSkimRecipient(_curator);
+		core.setIsAllocator(alloc, true);
+
+		staked = vaultFactory.createMetaMorpho(address(this), 0, address(core), 'USDU Staked', 'ssUSDU', 0);
+		staked.setCurator(_curator);
+		staked.setFeeRecipient(_curator);
+		staked.setFee(ConstantsLib.MAX_FEE);
+		staked.setSkimRecipient(_curator);
+		staked.setIsAllocator(alloc, true);
+
+		// prepare markets
+		MarketParams memory coreIdleMarket = MarketParams(address(stable), address(0), address(0), address(0), 0);
+		MarketParams memory stakedIdleMarket = MarketParams(address(core), address(0), address(0), address(0), 0);
+		Id[] memory idCore = new Id[](1);
+		idCore[0] = getMarketId(coreIdleMarket);
+		Id[] memory idStaked = new Id[](1);
+		idStaked[0] = getMarketId(stakedIdleMarket);
+
+		// create markets
+		morpho.createMarket(coreIdleMarket);
+		morpho.createMarket(stakedIdleMarket);
+
+		// attach stable idle market to core vault
+		core.submitCap(coreIdleMarket, 100_000_000 ether);
+		core.acceptCap(coreIdleMarket);
+		core.setSupplyQueue(idCore);
+
+		// attach staked idle market to staked vault
+		staked.submitCap(stakedIdleMarket, 100_000_000 ether);
+		staked.acceptCap(stakedIdleMarket);
+		staked.setSupplyQueue(idStaked);
+
+		// set up reward helper
+		reward = new RewardRouterV0(stable, _urd);
+
+		// set up morpho adapter and reward router
+		address[5] memory receivers = [address(reward), address(0), address(0), address(0), address(0)];
+		uint32[5] memory weights = [uint32(1000), uint32(0), uint32(0), uint32(0), uint32(0)];
+
+		// set up modules
+		adapter = new MorphoAdapterV1(stable, core, staked, receivers, weights);
+		stable.setModule(address(adapter), type(uint256).max, 'MorphoAdapterV1');
+
+		// prepare stable for curator
+		stable.setCurator(_curator); // no timelock, new curator needs to accept role
+		stable.setTimelock(7 days); // will apply now for further steps
+
+		// prepare vaults for curator, needs 2nd step to accept new role
+		core.transferOwnership(_curator);
+		staked.transferOwnership(_curator);
+	}
+
+	function getMarketId(MarketParams memory marketParams) public pure returns (Id) {
+		return
+			Id.wrap(
+				keccak256(
+					abi.encode(
+						marketParams.loanToken,
+						marketParams.collateralToken,
+						marketParams.oracle,
+						marketParams.irm,
+						marketParams.lltv
+					)
+				)
+			);
+	}
+}

package/contracts/morpho/MorphoAdapterV1.sol

@@ -0,0 +1,255 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {Math} from '@openzeppelin/contracts/utils/math/Math.sol';
+
+import {Context} from '@openzeppelin/contracts/utils/Context.sol';
+import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
+
+import {Stablecoin} from '../stablecoin/Stablecoin.sol';
+import {ErrorsLib} from '../stablecoin/libraries/ErrorsLib.sol';
+
+import {IMetaMorphoV1_1} from './helpers/IMetaMorphoV1_1.sol';
+
+/**
+ * @title MorphoAdapterV1
+ * @author @samclassix <samclassix@proton.me>, @wrytlabs <wrytlabs@proton.me>
+ * @notice This is an adapter for interacting with Morpho to mint liquidity straight into the market.
+ */
+contract MorphoAdapterV1 is Context {
+	using Math for uint256;
+	using SafeERC20 for Stablecoin;
+	using SafeERC20 for IMetaMorphoV1_1;
+
+	Stablecoin public immutable stable;
+	IMetaMorphoV1_1 public immutable core;
+	IMetaMorphoV1_1 public immutable staked;
+
+	uint256 public totalMinted;
+	uint256 public totalRevenue;
+
+	address[5] public receivers;
+	uint32[5] public weights;
+	uint256 public totalWeights;
+
+	address[5] public pendingReceivers;
+	uint32[5] public pendingWeights;
+	uint256 public pendingValidAt;
+
+	// ---------------------------------------------------------------------------------------
+
+	event SubmitDistribution(address indexed caller, address[5] receivers, uint32[5] weights, uint256 timelock);
+	event RevokeDistribution(address indexed caller);
+	event SetDistribution(address indexed caller);
+
+	event Deposit(uint256 amount, uint256 sharesCore, uint256 sharesStaked, uint256 totalMinted);
+	event Redeem(uint256 amount, uint256 sharesCore, uint256 sharesStaked, uint256 totalMinted);
+	event Revenue(uint256 amount, uint256 totalRevenue, uint256 totalMinted);
+	event Distribution(address indexed receiver, uint256 amount, uint256 ratio);
+
+	// ---------------------------------------------------------------------------------------
+
+	error ForwardCallFailed(address forwardedTo);
+	error MismatchLength(uint256 receivers, uint256 weights);
+	error NothingToReconcile(uint256 assets, uint256 minted);
+
+	// ---------------------------------------------------------------------------------------
+
+	modifier onlyCurator() {
+		stable.verifyCurator(_msgSender());
+		_;
+	}
+
+	modifier onlyCuratorOrGuardian() {
+		stable.verifyCuratorOrGuardian(_msgSender());
+		_;
+	}
+
+	modifier afterTimelock(uint256 validAt) {
+		if (validAt == 0) revert ErrorsLib.NoPendingValue();
+		if (block.timestamp < validAt) revert ErrorsLib.TimelockNotElapsed();
+		_;
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	constructor(
+		Stablecoin _stable,
+		IMetaMorphoV1_1 _core,
+		IMetaMorphoV1_1 _staked,
+		address[5] memory _receivers,
+		uint32[5] memory _weights
+	) {
+		stable = _stable;
+		core = _core;
+		staked = _staked;
+		_setDistribution(_receivers, _weights);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function totalAssets() public view returns (uint256) {
+		// this will use `_accruedFeeAndAssets`
+		uint256 assetsFromStaked = staked.convertToAssets(staked.balanceOf(address(this)));
+		return core.convertToAssets(assetsFromStaked);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function setDistribution(address[5] calldata _receivers, uint32[5] calldata _weights) external onlyCurator {
+		if (_receivers.length != _weights.length) revert MismatchLength(_receivers.length, _weights.length);
+		if (pendingValidAt != 0) revert ErrorsLib.AlreadyPending();
+
+		if (receivers[0] == address(0)) {
+			_setDistribution(_receivers, _weights);
+		} else {
+			pendingReceivers = _receivers;
+			pendingWeights = _weights;
+			pendingValidAt = block.timestamp + stable.timelock();
+			emit SubmitDistribution(_msgSender(), _receivers, _weights, pendingValidAt);
+		}
+	}
+
+	function revokePendingDistribution() external onlyCuratorOrGuardian {
+		if (pendingValidAt == 0) revert ErrorsLib.NoPendingValue();
+		emit RevokeDistribution(_msgSender());
+		_cleanUpPending();
+	}
+
+	function applyDistribution() external afterTimelock(pendingValidAt) {
+		_setDistribution(pendingReceivers, pendingWeights);
+	}
+
+	function _setDistribution(address[5] memory _receivers, uint32[5] memory _weights) internal {
+		// reset totalWeights
+		totalWeights = 0;
+
+		// update total weight
+		for (uint32 i = 0; i < _receivers.length; i++) {
+			totalWeights += _weights[i];
+		}
+
+		// update distribution
+		receivers = _receivers;
+		weights = _weights;
+
+		// emit event
+		emit SetDistribution(_msgSender());
+
+		_cleanUpPending();
+	}
+
+	function _cleanUpPending() internal {
+		delete pendingReceivers;
+		delete pendingWeights;
+		delete pendingValidAt;
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function deposit(uint256 amount) external onlyCurator {
+		// mint stables
+		stable.mintModule(address(this), amount);
+		totalMinted += amount;
+
+		// approve stable for deposit into core vault
+		stable.forceApprove(address(core), amount);
+		uint256 sharesCore = core.deposit(amount, address(this));
+
+		// approve core shares for deposit into staked vault
+		core.forceApprove(address(staked), sharesCore);
+		uint256 sharesStaked = staked.deposit(sharesCore, address(this));
+
+		emit Deposit(amount, sharesCore, sharesStaked, totalMinted);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function redeem(uint256 sharesStaked) external onlyCurator {
+		// reconcile, triggers `_accruedFeeAndAssets` in vault
+		_reconcile(totalAssets(), true);
+
+		// approve staked shares for redeem from staked vault
+		staked.forceApprove(address(staked), sharesStaked);
+		uint256 sharesCore = staked.redeem(sharesStaked, address(this), address(this));
+
+		// approve core shares for redeem from core vault
+		core.forceApprove(address(core), sharesCore);
+		uint256 amount = core.redeem(sharesCore, address(this), address(this));
+
+		// reduce minted amount
+		if (totalMinted >= amount) {
+			stable.burn(amount);
+			totalMinted -= amount;
+		} else {
+			// fallback, burn existing totalMinted if available
+			if (totalMinted > 0) {
+				stable.burn(totalMinted);
+				totalMinted = 0;
+			}
+
+			// fallback, distribute remaining balance
+			uint256 bal = stable.balanceOf(address(this));
+			if (bal > 0) {
+				_distribute(bal);
+			}
+		}
+
+		emit Redeem(amount, sharesCore, sharesStaked, totalMinted);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function reconcile() external {
+		_reconcile(totalAssets(), false);
+	}
+
+	function _reconcile(uint256 assets, bool allowPassing) internal returns (uint256) {
+		if (assets > totalMinted) {
+			uint256 mintToReconcile = assets - totalMinted;
+			totalRevenue += mintToReconcile;
+
+			stable.mintModule(address(this), mintToReconcile);
+			totalMinted += mintToReconcile;
+			emit Revenue(mintToReconcile, totalRevenue, totalMinted);
+
+			_distribute(mintToReconcile);
+			return mintToReconcile;
+		} else {
+			if (allowPassing) {
+				return 0;
+			} else {
+				revert NothingToReconcile(assets, totalMinted);
+			}
+		}
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function _distribute(uint256 amount) internal {
+		for (uint256 i = 0; i < 5; i++) {
+			address receiver = receivers[i];
+			uint256 weight = weights[i];
+			uint256 split;
+
+			// end distribution
+			if (receiver == address(0)) return;
+
+			// last item reached (index: 5 - 1 = 4) OR next receiver is zeroAddress
+			if (i == 4 || (i < 4 && receivers[i + 1] == address(0))) {
+				// distribute remainings, eliminating rounding or deposit issues
+				split = stable.balanceOf(address(this));
+			} else {
+				// distribute weighted split
+				split = (weight * amount) / totalWeights;
+			}
+
+			// distribute revenue split
+			stable.transfer(receiver, split);
+
+			// last weighted ratio might be inconsistant, due to remaining assets distribution
+			emit Distribution(receiver, split, (weight * 1 ether) / totalWeights);
+		}
+	}
+}

package/contracts/morpho/MorphoAdapterV1_1.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+pragma solidity ^0.8.20;
+
+import {Math} from '@openzeppelin/contracts/utils/math/Math.sol';
+
+import {IERC20} from '@openzeppelin/contracts/token/ERC20/IERC20.sol';
+import {SafeERC20} from '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
+
+import {RewardDistributionV1, Stablecoin} from '../reward/RewardDistributionV1.sol';
+
+import {IMetaMorphoV1_1} from './helpers/IMetaMorphoV1_1.sol';
+
+/**
+ * @title MorphoAdapterV1_1
+ * @author @samclassix <samclassix@proton.me>, @wrytlabs <wrytlabs@proton.me>
+ * @notice This is an adapter for interacting with Morpho to mint liquidity straight into the market.
+ */
+contract MorphoAdapterV1_1 is RewardDistributionV1 {
+	using Math for uint256;
+	using SafeERC20 for Stablecoin;
+	using SafeERC20 for IMetaMorphoV1_1;
+
+	IMetaMorphoV1_1 public immutable core;
+	IMetaMorphoV1_1 public immutable staked;
+
+	uint256 public totalMinted;
+	uint256 public totalRevenue;
+
+	// ---------------------------------------------------------------------------------------
+
+	event Deposit(uint256 amount, uint256 sharesCore, uint256 sharesStaked, uint256 totalMinted);
+	event Redeem(uint256 amount, uint256 sharesCore, uint256 sharesStaked, uint256 totalMinted);
+	event Revenue(uint256 amount, uint256 totalRevenue, uint256 totalMinted);
+
+	// ---------------------------------------------------------------------------------------
+
+	error NothingToReconcile(uint256 assets, uint256 minted);
+
+	// ---------------------------------------------------------------------------------------
+
+	constructor(
+		Stablecoin _stable,
+		IMetaMorphoV1_1 _core,
+		IMetaMorphoV1_1 _staked,
+		address[5] memory _receivers,
+		uint32[5] memory _weights
+	) RewardDistributionV1(_stable, _receivers, _weights) {
+		core = _core;
+		staked = _staked;
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function totalAssets() public view returns (uint256) {
+		// this will use `_accruedFeeAndAssets`
+		uint256 assetsFromStaked = staked.convertToAssets(staked.balanceOf(address(this)));
+		return core.convertToAssets(assetsFromStaked);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function deposit(uint256 amount) external onlyCurator {
+		// mint stables
+		stable.mintModule(address(this), amount);
+		totalMinted += amount;
+
+		// approve stable for deposit into core vault
+		stable.forceApprove(address(core), amount);
+		uint256 sharesCore = core.deposit(amount, address(this));
+
+		// approve core shares for deposit into staked vault
+		core.forceApprove(address(staked), sharesCore);
+		uint256 sharesStaked = staked.deposit(sharesCore, address(this));
+
+		emit Deposit(amount, sharesCore, sharesStaked, totalMinted);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function redeem(uint256 sharesStaked) external onlyCurator {
+		// reconcile, triggers `_accruedFeeAndAssets` in vault
+		_reconcile(totalAssets(), true);
+
+		// redeem staked shares from staked vault
+		uint256 sharesCore = staked.redeem(sharesStaked, address(this), address(this));
+
+		// redeem core shares from core vault
+		uint256 amount = core.redeem(sharesCore, address(this), address(this));
+
+		// reduce minted amount
+		if (totalMinted >= amount) {
+			stable.burn(amount);
+			totalMinted -= amount;
+		} else {
+			// fallback, burn existing totalMinted if available
+			if (totalMinted > 0) {
+				stable.burn(totalMinted);
+				totalMinted = 0;
+			}
+
+			// fallback, distribute remaining balance
+			_distribute();
+		}
+
+		emit Redeem(amount, sharesCore, sharesStaked, totalMinted);
+	}
+
+	// ---------------------------------------------------------------------------------------
+
+	function reconcile() external {
+		_reconcile(totalAssets(), false);
+	}
+
+	function _reconcile(uint256 assets, bool allowPassing) internal returns (uint256) {
+		if (assets > totalMinted) {
+			// calc revenue
+			uint256 mintToReconcile = assets - totalMinted;
+			totalRevenue += mintToReconcile;
+
+			// mint revenue to reconcile
+			stable.mintModule(address(this), mintToReconcile);
+			totalMinted += mintToReconcile;
+			emit Revenue(mintToReconcile, totalRevenue, totalMinted);
+
+			// distribute balance
+			_distribute();
+
+			return mintToReconcile;
+		} else {
+			if (allowPassing) {
+				return 0;
+			} else {
+				revert NothingToReconcile(assets, totalMinted);
+			}
+		}
+	}
+}