Datasets:

Zellic
/

smart-contract-fiesta

	// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.

	// SPDX-License-Identifier: AGPL-3.0-only
	pragma solidity 0.8.17;

	/// @notice Simple single owner authorization mixin.
	/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/auth/Owned.sol)
	abstract contract Owned {
	/*//////////////////////////////////////////////////////////////
	EVENTS
	//////////////////////////////////////////////////////////////*/

	event OwnershipTransferred(address indexed user, address indexed newOwner);

	/*//////////////////////////////////////////////////////////////
	OWNERSHIP STORAGE
	//////////////////////////////////////////////////////////////*/

	address public owner;

	modifier onlyOwner() virtual {
	require(msg.sender == owner, "UNAUTHORIZED");

	_;
	}

	/*//////////////////////////////////////////////////////////////
	CONSTRUCTOR
	//////////////////////////////////////////////////////////////*/

	constructor(address _owner) {
	owner = _owner;

	emit OwnershipTransferred(address(0), _owner);
	}

	/*//////////////////////////////////////////////////////////////
	OWNERSHIP LOGIC
	//////////////////////////////////////////////////////////////*/

	function transferOwnership(address newOwner) public virtual onlyOwner {
	owner = newOwner;

	emit OwnershipTransferred(msg.sender, newOwner);
	}
	}

	/*
	▄▄▄█████▓ ██░ ██ ▓█████ ██░ ██ ▓█████ ██▀███ ▓█████▄
	▓ ██▒ ▓▒▓██░ ██▒▓█ ▀ ▓██░ ██▒▓█ ▀ ▓██ ▒ ██▒▒██▀ ██▌
	▒ ▓██░ ▒░▒██▀▀██░▒███ ▒██▀▀██░▒███ ▓██ ░▄█ ▒░██ █▌
	░ ▓██▓ ░ ░▓█ ░██ ▒▓█ ▄ ░▓█ ░██ ▒▓█ ▄ ▒██▀▀█▄ ░▓█▄ ▌
	▒██▒ ░ ░▓█▒░██▓░▒████▒ ░▓█▒░██▓░▒████▒░██▓ ▒██▒░▒████▓
	▒ ░░ ▒ ░░▒░▒░░ ▒░ ░ ▒ ░░▒░▒░░ ▒░ ░░ ▒▓ ░▒▓░ ▒▒▓ ▒
	░ ▒ ░▒░ ░ ░ ░ ░ ▒ ░▒░ ░ ░ ░ ░ ░▒ ░ ▒░ ░ ▒ ▒
	░ ░ ░░ ░ ░ ░ ░░ ░ ░ ░░ ░ ░ ░ ░
	░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░
	░
	.,;>>%%%%%>>;,.
	.>%%%%%%%%%%%%%%%%%%%%>,.
	.>%%%%%%%%%%%%%%%%%%>>,%%%%%%;,.
	.>>>>%%%%%%%%%%%%%>>,%%%%%%%%%%%%,>>%%,.
	.>>%>>>>%%%%%%%%%>>,%%%%%%%%%%%%%%%%%,>>%%%%%,.
	.>>%%%%%>>%%%%>>,%%>>%%%%%%%%%%%%%%%%%%%%,>>%%%%%%%,
	.>>%%%%%%%%%%>>,%%%%%%>>%%%%%%%%%%%%%%%%%%,>>%%%%%%%%%%.
	.>>%%%%%%%%%%>>,>>>>%%%%%%%%%%'..`%%%%%%%%,;>>%%%%%%%%%>%%.
	.>>%%%>>>%%%%%>,%%%%%%%%%%%%%%.%%%,`%%%%%%,;>>%%%%%%%%>>>%%%%.
	>>%%>%>>>%>%%%>,%%%%%>>%%%%%%%%%%%%%`%%%%%%,>%%%%%%%>>>>%%%%%%%.
	>>%>>>%%>>>%%%%>,%>>>%%%%%%%%%%%%%%%%`%%%%%%%%%%%%%%%%%%%%%%%%%%.
	>>%%%%%%%%%%%%%%,>%%%%%%%%%%%%%%%%%%%'%%%,>>%%%%%%%%%%%%%%%%%%%%%.
	>>%%%%%%%%%%%%%%%,>%%%>>>%%%%%%%%%%%%%%%,>>%%%%%%%%>>>>%%%%%%%%%%%.
	>>%%%%%%%%;%;%;%%;,%>>>>%%%%%%%%%%%%%%%,>>>%%%%%%>>;";>>%%%%%%%%%%%%.
	`>%%%%%%%%%;%;;;%;%,>%%%%%%%%%>>%%%%%%%%,>>>%%%%%%%%%%%%%%%%%%%%%%%%%%.
	>>%%%%%%%%%,;;;;;%%>,%%%%%%%%>>>>%%%%%%%%,>>%%%%%%%%%%%%%%%%%%%%%%%%%%%.
	`>>%%%%%%%%%,%;;;;%%%>,%%%%%%%%>>>>%%%%%%%%,>%%%%%%'%%%%%%%%%%%%%%%%%%%>>.
	`>>%%%%%%%%%%>,;;%%%%%>>,%%%%%%%%>>%%%%%%';;;>%%%%%,`%%%%%%%%%%%%%%%>>%%>.
	>>>%%%%%%%%%%>> %%%%%%%%>>,%%%%>>>%%%%%';;;;;;>>,%%%,`% `;>%%%%%%>>%%
	`>>%%%%%%%%%%>> %%%%%%%%%>>>>>>>>;;;;'.;;;;;>>%%' `%%' ;>%%%%%>
	>>%%%%%%%%%>>; %%%%%%%%>>;;;;;;'' ;;;;;>>%%% ;>%%%%
	`>>%%%%%%%>>>, %%%%%%%%%>>;;' ;;;;>>%%%' ;>%%%
	>>%%%%%%>>>':.%%%%%%%%%%>>; .;;;>>%%%% ;>%%%'
	`>>%%%%%>>> ::`%%%%%%%%%%>>;. ;;;>>%%%%' ;>%%%'
	`>>%%%%>>> `:::`%%%%%%%%%%>;. ;;>>%%%%% ;>%%'
	`>>%%%%>>, `::::`%%%%%%%%%%>, .;>>%%%%%' ;>%'
	`>>%%%%>>, `:::::`%%%%%%%%%>>. ;;>%%%%%% ;>%,
	`>>%%%%>>, :::::::`>>>%%%%>>> ;;>%%%%%' ;>%,
	`>>%%%%>>,::::::,>>>>>>>>>>' ;;>%%%%% ;%%,
	>>%%%%>>,:::,%%>>>>>>>>' ;>%%%%%. ;%%
	>>%%%%>>``%%%%%>>>>>' `>%%%%%%.
	>>%%%%>> `@@a%%%%%%' .%%%%%%%%%.
	`a@@a%@' `%a@@' `a@@a%a@@a
	*/

	interface Factory {
	function feeCollector() external view returns (address);

	function platformFeeManager(address) external view returns (address);

	function recipient(address, address) external view returns (address);
	}

	interface GaugeController {
	struct VotedSlope {
	uint256 slope;
	uint256 power;
	uint256 end;
	}

	struct Point {
	uint256 bias;
	uint256 slope;
	}

	function vote_user_slopes(address, address) external view returns (VotedSlope memory);

	function add_gauge(address, int128) external;

	function WEIGHT_VOTE_DELAY() external view returns (uint256);

	function last_user_vote(address, address) external view returns (uint256);

	function points_weight(address, uint256) external view returns (Point memory);

	function checkpoint_gauge(address) external;

	//solhint-disable-next-line
	function gauge_types(address addr) external view returns (int128);

	//solhint-disable-next-line
	function gauge_relative_weight_write(address addr, uint256 timestamp) external returns (uint256);

	//solhint-disable-next-line
	function gauge_relative_weight(address addr) external view returns (uint256);

	//solhint-disable-next-line
	function gauge_relative_weight(address addr, uint256 timestamp) external view returns (uint256);

	//solhint-disable-next-line
	function get_total_weight() external view returns (uint256);

	//solhint-disable-next-line
	function get_gauge_weight(address addr) external view returns (uint256);

	function vote_for_gauge_weights(address, uint256) external;

	function add_type(string memory, uint256) external;

	function admin() external view returns (address);
	}

	/// @notice Gas optimized reentrancy protection for smart contracts.
	/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ReentrancyGuard.sol)
	/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/security/ReentrancyGuard.sol)
	abstract contract ReentrancyGuard {
	uint256 private locked = 1;

	modifier nonReentrant() virtual {
	require(locked == 1, "REENTRANCY");

	locked = 2;

	_;

	locked = 1;
	}
	}

	/// @notice Arithmetic library with operations for fixed-point numbers.
	/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)
	/// @author Inspired by USM (https://github.com/usmfum/USM/blob/master/contracts/WadMath.sol)
	library FixedPointMathLib {
	/*//////////////////////////////////////////////////////////////
	SIMPLIFIED FIXED POINT OPERATIONS
	//////////////////////////////////////////////////////////////*/

	uint256 internal constant MAX_UINT256 = 2**256 - 1;

	uint256 internal constant WAD = 1e18; // The scalar of ETH and most ERC20s.

	function mulWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
	return mulDivDown(x, y, WAD); // Equivalent to (x * y) / WAD rounded down.
	}

	function mulWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
	return mulDivUp(x, y, WAD); // Equivalent to (x * y) / WAD rounded up.
	}

	function divWadDown(uint256 x, uint256 y) internal pure returns (uint256) {
	return mulDivDown(x, WAD, y); // Equivalent to (x * WAD) / y rounded down.
	}

	function divWadUp(uint256 x, uint256 y) internal pure returns (uint256) {
	return mulDivUp(x, WAD, y); // Equivalent to (x * WAD) / y rounded up.
	}

	/*//////////////////////////////////////////////////////////////
	LOW LEVEL FIXED POINT OPERATIONS
	//////////////////////////////////////////////////////////////*/

	function mulDivDown(
	uint256 x,
	uint256 y,
	uint256 denominator
	) internal pure returns (uint256 z) {
	/// @solidity memory-safe-assembly
	assembly {
	// Equivalent to require(denominator != 0 && (y == 0 \|\| x <= type(uint256).max / y))
	if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
	revert(0, 0)
	}

	// Divide x * y by the denominator.
	z := div(mul(x, y), denominator)
	}
	}

	function mulDivUp(
	uint256 x,
	uint256 y,
	uint256 denominator
	) internal pure returns (uint256 z) {
	/// @solidity memory-safe-assembly
	assembly {
	// Equivalent to require(denominator != 0 && (y == 0 \|\| x <= type(uint256).max / y))
	if iszero(mul(denominator, iszero(mul(y, gt(x, div(MAX_UINT256, y)))))) {
	revert(0, 0)
	}

	// If x * y modulo the denominator is strictly greater than 0,
	// 1 is added to round up the division of x * y by the denominator.
	z := add(gt(mod(mul(x, y), denominator), 0), div(mul(x, y), denominator))
	}
	}

	function rpow(
	uint256 x,
	uint256 n,
	uint256 scalar
	) internal pure returns (uint256 z) {
	/// @solidity memory-safe-assembly
	assembly {
	switch x
	case 0 {
	switch n
	case 0 {
	// 0 ** 0 = 1
	z := scalar
	}
	default {
	// 0 ** n = 0
	z := 0
	}
	}
	default {
	switch mod(n, 2)
	case 0 {
	// If n is even, store scalar in z for now.
	z := scalar
	}
	default {
	// If n is odd, store x in z for now.
	z := x
	}

	// Shifting right by 1 is like dividing by 2.
	let half := shr(1, scalar)

	for {
	// Shift n right by 1 before looping to halve it.
	n := shr(1, n)
	} n {
	// Shift n right by 1 each iteration to halve it.
	n := shr(1, n)
	} {
	// Revert immediately if x ** 2 would overflow.
	// Equivalent to iszero(eq(div(xx, x), x)) here.
	if shr(128, x) {
	revert(0, 0)
	}

	// Store x squared.
	let xx := mul(x, x)

	// Round to the nearest number.
	let xxRound := add(xx, half)

	// Revert if xx + half overflowed.
	if lt(xxRound, xx) {
	revert(0, 0)
	}

	// Set x to scaled xxRound.
	x := div(xxRound, scalar)

	// If n is even:
	if mod(n, 2) {
	// Compute z * x.
	let zx := mul(z, x)

	// If z * x overflowed:
	if iszero(eq(div(zx, x), z)) {
	// Revert if x is non-zero.
	if iszero(iszero(x)) {
	revert(0, 0)
	}
	}

	// Round to the nearest number.
	let zxRound := add(zx, half)

	// Revert if zx + half overflowed.
	if lt(zxRound, zx) {
	revert(0, 0)
	}

	// Return properly scaled zxRound.
	z := div(zxRound, scalar)
	}
	}
	}
	}
	}

	/*//////////////////////////////////////////////////////////////
	GENERAL NUMBER UTILITIES
	//////////////////////////////////////////////////////////////*/

	function sqrt(uint256 x) internal pure returns (uint256 z) {
	/// @solidity memory-safe-assembly
	assembly {
	let y := x // We start y at x, which will help us make our initial estimate.

	z := 181 // The "correct" value is 1, but this saves a multiplication later.

	// This segment is to get a reasonable initial estimate for the Babylonian method. With a bad
	// start, the correct # of bits increases ~linearly each iteration instead of ~quadratically.

	// We check y >= 2^(k + 8) but shift right by k bits
	// each branch to ensure that if x >= 256, then y >= 256.
	if iszero(lt(y, 0x10000000000000000000000000000000000)) {
	y := shr(128, y)
	z := shl(64, z)
	}
	if iszero(lt(y, 0x1000000000000000000)) {
	y := shr(64, y)
	z := shl(32, z)
	}
	if iszero(lt(y, 0x10000000000)) {
	y := shr(32, y)
	z := shl(16, z)
	}
	if iszero(lt(y, 0x1000000)) {
	y := shr(16, y)
	z := shl(8, z)
	}

	// Goal was to get zzy within a small factor of x. More iterations could
	// get y in a tighter range. Currently, we will have y in [256, 256*2^16).
	// We ensured y >= 256 so that the relative difference between y and y+1 is small.
	// That's not possible if x < 256 but we can just verify those cases exhaustively.

	// Now, zzy <= x < zz(y+1), and y <= 2^(16+8), and either y >= 256, or x < 256.
	// Correctness can be checked exhaustively for x < 256, so we assume y >= 256.
	// Then z*sqrt(y) is within sqrt(257)/sqrt(256) of sqrt(x), or about 20bps.

	// For s in the range [1/256, 256], the estimate f(s) = (181/1024) * (s+1) is in the range
	// (1/2.84 * sqrt(s), 2.84 * sqrt(s)), with largest error when s = 1 and when s = 256 or 1/256.

	// Since y is in [256, 256*2^16), let a = y/65536, so that a is in [1/256, 256). Then we can estimate
	// sqrt(y) using sqrt(65536) * 181/1024 * (a + 1) = 181/4 * (y + 65536)/65536 = 181 * (y + 65536)/2^18.

	// There is no overflow risk here since y < 2^136 after the first branch above.
	z := shr(18, mul(z, add(y, 65536))) // A mul() is saved from starting z at 181.

	// Given the worst case multiplicative error of 2.84 above, 7 iterations should be enough.
	z := shr(1, add(z, div(x, z)))
	z := shr(1, add(z, div(x, z)))
	z := shr(1, add(z, div(x, z)))
	z := shr(1, add(z, div(x, z)))
	z := shr(1, add(z, div(x, z)))
	z := shr(1, add(z, div(x, z)))
	z := shr(1, add(z, div(x, z)))

	// If x+1 is a perfect square, the Babylonian method cycles between
	// floor(sqrt(x)) and ceil(sqrt(x)). This statement ensures we return floor.
	// See: https://en.wikipedia.org/wiki/Integer_square_root#Using_only_integer_division
	// Since the ceil is rare, we save gas on the assignment and repeat division in the rare case.
	// If you don't care whether the floor or ceil square root is returned, you can remove this statement.
	z := sub(z, lt(div(x, z), z))
	}
	}

	function unsafeMod(uint256 x, uint256 y) internal pure returns (uint256 z) {
	/// @solidity memory-safe-assembly
	assembly {
	// Mod x by y. Note this will return
	// 0 instead of reverting if y is zero.
	z := mod(x, y)
	}
	}

	function unsafeDiv(uint256 x, uint256 y) internal pure returns (uint256 r) {
	/// @solidity memory-safe-assembly
	assembly {
	// Divide x by y. Note this will return
	// 0 instead of reverting if y is zero.
	r := div(x, y)
	}
	}

	function unsafeDivUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
	/// @solidity memory-safe-assembly
	assembly {
	// Add 1 to x * y if x % y > 0. Note this will
	// return 0 instead of reverting if y is zero.
	z := add(gt(mod(x, y), 0), div(x, y))
	}
	}
	}

	/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
	/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
	/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
	/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
	abstract contract ERC20 {
	/*//////////////////////////////////////////////////////////////
	EVENTS
	//////////////////////////////////////////////////////////////*/

	event Transfer(address indexed from, address indexed to, uint256 amount);

	event Approval(address indexed owner, address indexed spender, uint256 amount);

	/*//////////////////////////////////////////////////////////////
	METADATA STORAGE
	//////////////////////////////////////////////////////////////*/

	string public name;

	string public symbol;

	uint8 public immutable decimals;

	/*//////////////////////////////////////////////////////////////
	ERC20 STORAGE
	//////////////////////////////////////////////////////////////*/

	uint256 public totalSupply;

	mapping(address => uint256) public balanceOf;

	mapping(address => mapping(address => uint256)) public allowance;

	/*//////////////////////////////////////////////////////////////
	EIP-2612 STORAGE
	//////////////////////////////////////////////////////////////*/

	uint256 internal immutable INITIAL_CHAIN_ID;

	bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

	mapping(address => uint256) public nonces;

	/*//////////////////////////////////////////////////////////////
	CONSTRUCTOR
	//////////////////////////////////////////////////////////////*/

	constructor(
	string memory _name,
	string memory _symbol,
	uint8 _decimals
	) {
	name = _name;
	symbol = _symbol;
	decimals = _decimals;

	INITIAL_CHAIN_ID = block.chainid;
	INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
	}

	/*//////////////////////////////////////////////////////////////
	ERC20 LOGIC
	//////////////////////////////////////////////////////////////*/

	function approve(address spender, uint256 amount) public virtual returns (bool) {
	allowance[msg.sender][spender] = amount;

	emit Approval(msg.sender, spender, amount);

	return true;
	}

	function transfer(address to, uint256 amount) public virtual returns (bool) {
	balanceOf[msg.sender] -= amount;

	// Cannot overflow because the sum of all user
	// balances can't exceed the max uint256 value.
	unchecked {
	balanceOf[to] += amount;
	}

	emit Transfer(msg.sender, to, amount);

	return true;
	}

	function transferFrom(
	address from,
	address to,
	uint256 amount
	) public virtual returns (bool) {
	uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

	if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

	balanceOf[from] -= amount;

	// Cannot overflow because the sum of all user
	// balances can't exceed the max uint256 value.
	unchecked {
	balanceOf[to] += amount;
	}

	emit Transfer(from, to, amount);

	return true;
	}

	/*//////////////////////////////////////////////////////////////
	EIP-2612 LOGIC
	//////////////////////////////////////////////////////////////*/

	function permit(
	address owner,
	address spender,
	uint256 value,
	uint256 deadline,
	uint8 v,
	bytes32 r,
	bytes32 s
	) public virtual {
	require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

	// Unchecked because the only math done is incrementing
	// the owner's nonce which cannot realistically overflow.
	unchecked {
	address recoveredAddress = ecrecover(
	keccak256(
	abi.encodePacked(
	"\x19\x01",
	DOMAIN_SEPARATOR(),
	keccak256(
	abi.encode(
	keccak256(
	"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
	),
	owner,
	spender,
	value,
	nonces[owner]++,
	deadline
	)
	)
	)
	),
	v,
	r,
	s
	);

	require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");

	allowance[recoveredAddress][spender] = value;
	}

	emit Approval(owner, spender, value);
	}

	function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
	return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
	}

	function computeDomainSeparator() internal view virtual returns (bytes32) {
	return
	keccak256(
	abi.encode(
	keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
	keccak256(bytes(name)),
	keccak256("1"),
	block.chainid,
	address(this)
	)
	);
	}

	/*//////////////////////////////////////////////////////////////
	INTERNAL MINT/BURN LOGIC
	//////////////////////////////////////////////////////////////*/

	function _mint(address to, uint256 amount) internal virtual {
	totalSupply += amount;

	// Cannot overflow because the sum of all user
	// balances can't exceed the max uint256 value.
	unchecked {
	balanceOf[to] += amount;
	}

	emit Transfer(address(0), to, amount);
	}

	function _burn(address from, uint256 amount) internal virtual {
	balanceOf[from] -= amount;

	// Cannot underflow because a user's balance
	// will never be larger than the total supply.
	unchecked {
	totalSupply -= amount;
	}

	emit Transfer(from, address(0), amount);
	}
	}

	/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
	/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
	/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
	/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
	library SafeTransferLib {
	/*//////////////////////////////////////////////////////////////
	ETH OPERATIONS
	//////////////////////////////////////////////////////////////*/

	function safeTransferETH(address to, uint256 amount) internal {
	bool success;

	/// @solidity memory-safe-assembly
	assembly {
	// Transfer the ETH and store if it succeeded or not.
	success := call(gas(), to, amount, 0, 0, 0, 0)
	}

	require(success, "ETH_TRANSFER_FAILED");
	}

	/*//////////////////////////////////////////////////////////////
	ERC20 OPERATIONS
	//////////////////////////////////////////////////////////////*/

	function safeTransferFrom(
	ERC20 token,
	address from,
	address to,
	uint256 amount
	) internal {
	bool success;

	/// @solidity memory-safe-assembly
	assembly {
	// Get a pointer to some free memory.
	let freeMemoryPointer := mload(0x40)

	// Write the abi-encoded calldata into memory, beginning with the function selector.
	mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
	mstore(add(freeMemoryPointer, 4), from) // Append the "from" argument.
	mstore(add(freeMemoryPointer, 36), to) // Append the "to" argument.
	mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument.

	success := and(
	// Set success to whether the call reverted, if not we check it either
	// returned exactly 1 (can't just be non-zero data), or had no return data.
	or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
	// We use 100 because the length of our calldata totals up like so: 4 + 32 * 3.
	// We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
	// Counterintuitively, this call must be positioned second to the or() call in the
	// surrounding and() call or else returndatasize() will be zero during the computation.
	call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)
	)
	}

	require(success, "TRANSFER_FROM_FAILED");
	}

	function safeTransfer(
	ERC20 token,
	address to,
	uint256 amount
	) internal {
	bool success;

	/// @solidity memory-safe-assembly
	assembly {
	// Get a pointer to some free memory.
	let freeMemoryPointer := mload(0x40)

	// Write the abi-encoded calldata into memory, beginning with the function selector.
	mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
	mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument.
	mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument.

	success := and(
	// Set success to whether the call reverted, if not we check it either
	// returned exactly 1 (can't just be non-zero data), or had no return data.
	or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
	// We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
	// We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
	// Counterintuitively, this call must be positioned second to the or() call in the
	// surrounding and() call or else returndatasize() will be zero during the computation.
	call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
	)
	}

	require(success, "TRANSFER_FAILED");
	}

	function safeApprove(
	ERC20 token,
	address to,
	uint256 amount
	) internal {
	bool success;

	/// @solidity memory-safe-assembly
	assembly {
	// Get a pointer to some free memory.
	let freeMemoryPointer := mload(0x40)

	// Write the abi-encoded calldata into memory, beginning with the function selector.
	mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
	mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument.
	mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument.

	success := and(
	// Set success to whether the call reverted, if not we check it either
	// returned exactly 1 (can't just be non-zero data), or had no return data.
	or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
	// We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
	// We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
	// Counterintuitively, this call must be positioned second to the or() call in the
	// surrounding and() call or else returndatasize() will be zero during the computation.
	call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
	)
	}

	require(success, "APPROVE_FAILED");
	}
	}

	contract FeeManager is Owned {
	using SafeTransferLib for ERC20;
	uint256 public totalFee;
	uint256 internal constant _DEFAULT_FEE = 2e16; // 2%
	struct FeeRecipient {
	address recipient;
	uint256 fee;
	}
	FeeRecipient[] public recipients;

	/// @notice Thrown if the fee percentage is invalid.
	error INCORRECT_FEE();

	constructor(address _feeRecipient) Owned(_feeRecipient) {
	totalFee = _DEFAULT_FEE;
	recipients.push(FeeRecipient(_feeRecipient, _DEFAULT_FEE));
	}

	function disperseFees(address _token) external {
	uint256 length = recipients.length;
	uint256 totalBal = ERC20(_token).balanceOf(address(this));
	uint256 amount;
	for (uint256 i; i < length; ) {
	FeeRecipient memory recipient = recipients[i];
	amount = (totalBal * recipient.fee) / totalFee;
	ERC20(_token).safeTransfer(recipient.recipient, amount);
	unchecked {
	i++;
	}
	}
	}

	function addRecipient(address _recipient, uint256 _fee) external onlyOwner {
	if (_fee > 1e18) revert INCORRECT_FEE();
	recipients.push(FeeRecipient(_recipient, _fee));
	totalFee += _fee;
	}

	function removeRecipient(uint256 _index) external onlyOwner {
	totalFee -= recipients[_index].fee;
	recipients[_index] = recipients[recipients.length - 1];
	recipients.pop();
	}

	function updateRecipient(
	uint256 _index,
	address _recipient,
	uint256 _fee
	) external onlyOwner {
	if (_fee > 1e18) revert INCORRECT_FEE();
	totalFee -= recipients[_index].fee;
	recipients[_index].recipient = _recipient;
	recipients[_index].fee = _fee;
	totalFee += _fee;
	}

	function totalFeeRecipients() external view returns (uint256) {
	return recipients.length;
	}
	}

	/// version 1.5.0
	/// @title Platform
	/// @author Stake DAO
	contract Platform is ReentrancyGuard {
	using SafeTransferLib for ERC20;
	using FixedPointMathLib for uint256;

	////////////////////////////////////////////////////////////////
	/// --- EMERGENCY SHUTDOWN
	///////////////////////////////////////////////////////////////

	/// @notice Emergency shutdown flag
	bool public isKilled;

	////////////////////////////////////////////////////////////////
	/// --- STRUCTS
	///////////////////////////////////////////////////////////////

	/// @notice Bribe struct requirements.
	struct Bribe {
	// Address of the target gauge.
	address gauge;
	// Manager.
	address manager;
	// Address of the ERC20 used for rewards.
	address rewardToken;
	// Number of periods.
	uint8 numberOfPeriods;
	// Timestamp where the bribe become unclaimable.
	uint256 endTimestamp;
	// Max Price per vote.
	uint256 maxRewardPerVote;
	// Total Reward Added.
	uint256 totalRewardAmount;
	// Blacklisted addresses.
	address[] blacklist;
	}

	/// @notice Period struct.
	struct Period {
	// Period id.
	// Eg: 0 is the first period, 1 is the second period, etc.
	uint8 id;
	// Timestamp of the period start.
	uint256 timestamp;
	// Reward amount distributed during the period.
	uint256 rewardPerPeriod;
	}

	struct Upgrade {
	// Number of periods after increase.
	uint8 numberOfPeriods;
	// Total reward amount after increase.
	uint256 totalRewardAmount;
	// New max reward per vote after increase.
	uint256 maxRewardPerVote;
	// New end timestamp after increase.
	uint256 endTimestamp;
	// Blacklisted addresses.
	address[] blacklist;
	}

	////////////////////////////////////////////////////////////////
	/// --- CONSTANTS & IMMUTABLES
	///////////////////////////////////////////////////////////////

	/// @notice Week in seconds.
	uint256 private constant _WEEK = 1 weeks;

	/// @notice Base unit for fixed point compute.
	uint256 private constant _BASE_UNIT = 1e18;

	/// @notice Minimum duration a Bribe.
	uint8 public constant MINIMUM_PERIOD = 2;

	/// @notice Factory contract.
	Factory public immutable factory;

	/// @notice Gauge Controller.
	GaugeController public immutable gaugeController;

	////////////////////////////////////////////////////////////////
	/// --- STORAGE VARS
	///////////////////////////////////////////////////////////////

	/// @notice Bribe ID Counter.
	uint256 public nextID;

	/// @notice ID => Bribe.
	mapping(uint256 => Bribe) public bribes;

	/// @notice ID => Bribe In Queue to be upgraded.
	mapping(uint256 => Upgrade) public upgradeBribeQueue;

	/// @notice ID => Period running.
	mapping(uint256 => Period) public activePeriod;

	/// @notice BribeId => isUpgradeable. If true, the bribe can be upgraded.
	mapping(uint256 => bool) public isUpgradeable;

	/// @notice ID => Amount Claimed per Bribe.
	mapping(uint256 => uint256) public amountClaimed;

	/// @notice ID => Amount of reward per vote distributed.
	mapping(uint256 => uint256) public rewardPerVote;

	/// @notice Blacklisted addresses per bribe that aren't counted for rewards arithmetics.
	mapping(uint256 => mapping(address => bool)) public isBlacklisted;

	/// @notice Last time a user claimed
	mapping(address => mapping(uint256 => uint256)) public lastUserClaim;

	////////////////////////////////////////////////////////////////
	/// --- MODIFIERS
	///////////////////////////////////////////////////////////////

	modifier onlyManager(uint256 _id) {
	if (msg.sender != bribes[_id].manager) revert AUTH_MANAGER_ONLY();
	_;
	}

	modifier notKilled() {
	if (isKilled) revert KILLED();
	_;
	}

	////////////////////////////////////////////////////////////////
	/// --- EVENTS
	///////////////////////////////////////////////////////////////

	/// @notice Emitted when a new bribe is created.
	event BribeCreated(
	uint256 indexed id,
	address indexed gauge,
	address manager,
	address indexed rewardToken,
	uint8 numberOfPeriods,
	uint256 maxRewardPerVote,
	uint256 rewardPerPeriod,
	uint256 totalRewardAmount,
	bool isUpgradeable
	);

	/// @notice Emitted when a bribe is closed.
	event BribeClosed(uint256 id, uint256 remainingReward);

	/// @notice Emitted when a bribe period is rolled over.
	event PeriodRolledOver(
	uint256 id,
	uint256 periodId,
	uint256 timestamp,
	uint256 rewardPerPeriod
	);

	/// @notice Emitted on claim.
	event Claimed(
	address indexed user,
	address indexed rewardToken,
	uint256 indexed bribeId,
	uint256 amount,
	uint256 protocolFees,
	uint256 period
	);

	/// @notice Emitted when a bribe is queued to upgrade.
	event BribeDurationIncreaseQueued(
	uint256 id,
	uint8 numberOfPeriods,
	uint256 totalRewardAmount,
	uint256 maxRewardPerVote
	);

	/// @notice Emitted when a bribe is upgraded.
	event BribeDurationIncreased(
	uint256 id,
	uint8 numberOfPeriods,
	uint256 totalRewardAmount,
	uint256 maxRewardPerVote
	);

	/// @notice Emitted when a bribe manager is updated.
	event ManagerUpdated(uint256 id, address indexed manager);

	////////////////////////////////////////////////////////////////
	/// --- ERRORS
	///////////////////////////////////////////////////////////////

	error KILLED();
	error WRONG_INPUT();
	error ZERO_ADDRESS();
	error NO_PERIODS_LEFT();
	error NOT_UPGRADEABLE();
	error AUTH_MANAGER_ONLY();
	error ALREADY_INCREASED();
	error NOT_ALLOWED_OPERATION();
	error INVALID_NUMBER_OF_PERIODS();

	////////////////////////////////////////////////////////////////
	/// --- CONSTRUCTOR
	///////////////////////////////////////////////////////////////

	/// @notice Create Bribe platform.
	/// @param _gaugeController Address of the gauge controller.
	constructor(address _gaugeController, address _factory) {
	factory = Factory(_factory);
	gaugeController = GaugeController(_gaugeController);
	}

	////////////////////////////////////////////////////////////////
	/// --- BRIBE CREATION LOGIC
	///////////////////////////////////////////////////////////////

	/// @notice Create a new bribe.
	/// @param gauge Address of the target gauge.
	/// @param rewardToken Address of the ERC20 used or rewards.
	/// @param numberOfPeriods Number of periods.
	/// @param maxRewardPerVote Target Bias for the Gauge.
	/// @param totalRewardAmount Total Reward Added.
	/// @param blacklist Array of addresses to blacklist.
	/// @return newBribeID of the bribe created.
	function createBribe(
	address gauge,
	address manager,
	address rewardToken,
	uint8 numberOfPeriods,
	uint256 maxRewardPerVote,
	uint256 totalRewardAmount,
	address[] calldata blacklist,
	bool upgradeable
	) external nonReentrant notKilled returns (uint256 newBribeID) {
	if (rewardToken == address(0)) revert ZERO_ADDRESS();
	if (gaugeController.gauge_types(gauge) < 0) return newBribeID;
	if (numberOfPeriods < MINIMUM_PERIOD)
	revert INVALID_NUMBER_OF_PERIODS();
	if (totalRewardAmount == 0 \|\| maxRewardPerVote == 0)
	revert WRONG_INPUT();

	// Transfer the rewards to the contracts.
	ERC20(rewardToken).safeTransferFrom(
	msg.sender,
	address(this),
	totalRewardAmount
	);

	unchecked {
	// Get the ID for that new Bribe and increment the nextID counter.
	newBribeID = nextID;

	++nextID;
	}

	uint256 rewardPerPeriod = totalRewardAmount.mulDivDown(
	1,
	numberOfPeriods
	);
	uint256 currentPeriod = getCurrentPeriod();

	bribes[newBribeID] = Bribe({
	gauge: gauge,
	manager: manager,
	rewardToken: rewardToken,
	numberOfPeriods: numberOfPeriods,
	endTimestamp: currentPeriod + ((numberOfPeriods + 1) * _WEEK),
	maxRewardPerVote: maxRewardPerVote,
	totalRewardAmount: totalRewardAmount,
	blacklist: blacklist
	});

	emit BribeCreated(
	newBribeID,
	gauge,
	manager,
	rewardToken,
	numberOfPeriods,
	maxRewardPerVote,
	rewardPerPeriod,
	totalRewardAmount,
	upgradeable
	);

	// Set Upgradeable status.
	isUpgradeable[newBribeID] = upgradeable;
	// Starting from next period.
	activePeriod[newBribeID] = Period(
	0,
	currentPeriod + _WEEK,
	rewardPerPeriod
	);

	// Add the addresses to the blacklist.
	uint256 length = blacklist.length;
	for (uint256 i = 0; i < length; ) {
	isBlacklisted[newBribeID][blacklist[i]] = true;
	unchecked {
	++i;
	}
	}
	}

	/// @notice Claim rewards for a given bribe.
	/// @param bribeId ID of the bribe.
	/// @return Amount of rewards claimed.
	function claimFor(address user, uint256 bribeId)
	external
	returns (uint256)
	{
	address recipient = factory.recipient(user, address(gaugeController));
	return
	_claim(user, recipient != address(0) ? recipient : user, bribeId);
	}

	function claimAllFor(address user, uint256[] calldata ids) external {
	address recipient = factory.recipient(user, address(gaugeController));
	uint256 length = ids.length;

	for (uint256 i = 0; i < length; ) {
	uint256 id = ids[i];
	_claim(user, recipient != address(0) ? recipient : user, id);
	unchecked {
	++i;
	}
	}
	}

	/// @notice Claim rewards for a given bribe.
	/// @param bribeId ID of the bribe.
	/// @return Amount of rewards claimed.
	function claim(uint256 bribeId) external returns (uint256) {
	address recipient = factory.recipient(
	msg.sender,
	address(gaugeController)
	);
	return
	_claim(
	msg.sender,
	recipient != address(0) ? recipient : msg.sender,
	bribeId
	);
	}

	/// @notice Update Bribe for a given id.
	/// @param bribeId ID of the bribe.
	function updateBribePeriod(uint256 bribeId) external nonReentrant {
	_updateBribePeriod(bribeId);
	}

	/// @notice Update multiple bribes for given ids.
	/// @param ids Array of Bribe IDs.
	function updateBribePeriods(uint256[] calldata ids) external nonReentrant {
	uint256 length = ids.length;
	for (uint256 i = 0; i < length; ) {
	_updateBribePeriod(ids[i]);
	unchecked {
	++i;
	}
	}
	}

	/// @notice Claim all rewards for multiple bribes.
	/// @param ids Array of bribe IDs to claim.
	function claimAll(uint256[] calldata ids) external {
	address recipient = factory.recipient(
	msg.sender,
	address(gaugeController)
	);
	recipient = recipient != address(0) ? recipient : msg.sender;

	uint256 length = ids.length;

	for (uint256 i = 0; i < length; ) {
	uint256 id = ids[i];
	_claim(msg.sender, recipient, id);

	unchecked {
	++i;
	}
	}
	}

	////////////////////////////////////////////////////////////////
	/// --- INTERNAL LOGIC
	///////////////////////////////////////////////////////////////

	/// @notice Claim rewards for a given bribe.
	/// @param user Address of the user.
	/// @param bribeId ID of the bribe.
	/// @return amount of rewards claimed.
	function _claim(
	address user,
	address recipient,
	uint256 bribeId
	) internal nonReentrant notKilled returns (uint256 amount) {
	if (isBlacklisted[bribeId][user]) return 0;
	// Update if needed the current period.
	uint256 currentPeriod = _updateBribePeriod(bribeId);

	Bribe storage bribe = bribes[bribeId];

	// Get the last_vote timestamp.
	uint256 lastVote = gaugeController.last_user_vote(user, bribe.gauge);

	GaugeController.VotedSlope memory userSlope = gaugeController
	.vote_user_slopes(user, bribe.gauge);

	if (
	userSlope.slope == 0 \|\|
	lastUserClaim[user][bribeId] >= currentPeriod \|\|
	currentPeriod >= userSlope.end \|\|
	currentPeriod <= lastVote \|\|
	currentPeriod >= bribe.endTimestamp \|\|
	currentPeriod != getCurrentPeriod() \|\|
	amountClaimed[bribeId] == bribe.totalRewardAmount
	) return 0;

	// Update User last claim period.
	lastUserClaim[user][bribeId] = currentPeriod;

	// Voting Power = userSlope * dt
	// with dt = lock_end - period.
	uint256 _bias = _getAddrBias(
	userSlope.slope,
	userSlope.end,
	currentPeriod
	);
	// Compute the reward amount based on
	// Reward / Total Votes.
	amount = _bias.mulWadDown(rewardPerVote[bribeId]);
	// Compute the reward amount based on
	// the max price to pay.
	uint256 _amountWithMaxPrice = _bias.mulWadDown(bribe.maxRewardPerVote);
	// Distribute the _min between the amount based on votes, and price.
	amount = _min(amount, _amountWithMaxPrice);

	// Update the amount claimed.
	uint256 _amountClaimed = amountClaimed[bribeId];

	if (amount + _amountClaimed > bribe.totalRewardAmount) {
	amount = bribe.totalRewardAmount - _amountClaimed;
	}

	amountClaimed[bribeId] += amount;

	uint256 feeAmount;
	address feeManager = factory.platformFeeManager(
	address(gaugeController)
	);
	uint256 platformFee = FeeManager(feeManager).totalFee();

	if (platformFee != 0) {
	feeAmount = amount.mulWadDown(platformFee);
	amount -= feeAmount;

	// Transfer fees.
	ERC20(bribe.rewardToken).safeTransfer(feeManager, feeAmount);
	}

	// Transfer to user.
	ERC20(bribe.rewardToken).safeTransfer(recipient, amount);

	emit Claimed(
	user,
	bribe.rewardToken,
	bribeId,
	amount,
	feeAmount,
	currentPeriod
	);
	}

	/// @notice Update the current period for a given bribe.
	/// @param bribeId Bribe ID.
	/// @return current/updated period.
	function _updateBribePeriod(uint256 bribeId) internal returns (uint256) {
	Period storage _activePeriod = activePeriod[bribeId];

	uint256 currentPeriod = getCurrentPeriod();

	if (_activePeriod.id == 0 && currentPeriod == _activePeriod.timestamp) {
	// Checkpoint gauge to have up to date gauge weight.
	gaugeController.checkpoint_gauge(bribes[bribeId].gauge);
	// Initialize reward per token.
	// Only for the first period, and if not already initialized.
	_updateRewardPerToken(bribeId, currentPeriod);
	}

	// Increase Period
	if (block.timestamp >= _activePeriod.timestamp + _WEEK) {
	// Checkpoint gauge to have up to date gauge weight.
	gaugeController.checkpoint_gauge(bribes[bribeId].gauge);
	// Roll to next period.
	_rollOverToNextPeriod(bribeId, currentPeriod);

	return currentPeriod;
	}

	return _activePeriod.timestamp;
	}

	/// @notice Roll over to next period.
	/// @param bribeId Bribe ID.
	/// @param currentPeriod Next period timestamp.
	function _rollOverToNextPeriod(uint256 bribeId, uint256 currentPeriod)
	internal
	{
	uint8 index = getActivePeriodPerBribe(bribeId);

	Upgrade storage upgradedBribe = upgradeBribeQueue[bribeId];

	// Check if there is an upgrade in queue.
	if (upgradedBribe.totalRewardAmount != 0) {
	// Save new values.
	bribes[bribeId].numberOfPeriods = upgradedBribe.numberOfPeriods;
	bribes[bribeId].totalRewardAmount = upgradedBribe.totalRewardAmount;
	bribes[bribeId].maxRewardPerVote = upgradedBribe.maxRewardPerVote;
	bribes[bribeId].endTimestamp = upgradedBribe.endTimestamp;

	if (upgradedBribe.blacklist.length > 0) {
	bribes[bribeId].blacklist = upgradedBribe.blacklist;
	}

	emit BribeDurationIncreased(
	bribeId,
	upgradedBribe.numberOfPeriods,
	upgradedBribe.totalRewardAmount,
	upgradedBribe.maxRewardPerVote
	);

	// Reset the next values.
	delete upgradeBribeQueue[bribeId];
	}

	Bribe storage bribe = bribes[bribeId];

	uint256 periodsLeft = getPeriodsLeft(bribeId);
	uint256 rewardPerPeriod;
	rewardPerPeriod = bribe.totalRewardAmount - amountClaimed[bribeId];

	if (bribe.endTimestamp > currentPeriod + _WEEK && periodsLeft > 1) {
	rewardPerPeriod = rewardPerPeriod.mulDivDown(1, periodsLeft);
	}

	// Get adjusted slope without blacklisted addresses.
	uint256 gaugeBias = _getAdjustedBias(
	bribe.gauge,
	bribe.blacklist,
	currentPeriod
	);

	rewardPerVote[bribeId] = rewardPerPeriod.mulDivDown(
	_BASE_UNIT,
	gaugeBias
	);
	activePeriod[bribeId] = Period(index, currentPeriod, rewardPerPeriod);

	emit PeriodRolledOver(bribeId, index, currentPeriod, rewardPerPeriod);
	}

	/// @notice Update the amount of reward per token for a given bribe.
	/// @dev This function is only called once per Bribe.
	function _updateRewardPerToken(uint256 bribeId, uint256 currentPeriod)
	internal
	{
	if (rewardPerVote[bribeId] == 0) {
	uint256 gaugeBias = _getAdjustedBias(
	bribes[bribeId].gauge,
	bribes[bribeId].blacklist,
	currentPeriod
	);
	if (gaugeBias != 0) {
	rewardPerVote[bribeId] = activePeriod[bribeId]
	.rewardPerPeriod
	.mulDivDown(_BASE_UNIT, gaugeBias);
	}
	}
	}

	////////////////////////////////////////////////////////////////
	/// --- VIEWS
	///////////////////////////////////////////////////////////////

	/// @notice Get an estimate of the reward amount for a given user.
	/// @param user Address of the user.
	/// @param bribeId ID of the bribe.
	/// @return amount of rewards.
	/// Mainly used for UI.
	function claimable(address user, uint256 bribeId)
	external
	view
	returns (uint256 amount)
	{
	if (isBlacklisted[bribeId][user]) return 0;

	Bribe memory bribe = bribes[bribeId];
	// If there is an upgrade in progress but period hasn't been rolled over yet.
	Upgrade storage upgradedBribe = upgradeBribeQueue[bribeId];

	// Update if needed the current period.
	uint256 currentPeriod = getCurrentPeriod();
	// End timestamp of the bribe.
	uint256 endTimestamp = _max(
	bribe.endTimestamp,
	upgradedBribe.endTimestamp
	);
	// Get the last_vote timestamp.
	uint256 lastVote = gaugeController.last_user_vote(user, bribe.gauge);

	GaugeController.VotedSlope memory userSlope = gaugeController
	.vote_user_slopes(user, bribe.gauge);

	if (
	userSlope.slope == 0 \|\|
	lastUserClaim[user][bribeId] >= currentPeriod \|\|
	currentPeriod >= userSlope.end \|\|
	currentPeriod <= lastVote \|\|
	currentPeriod >= endTimestamp \|\|
	currentPeriod < getActivePeriod(bribeId).timestamp \|\|
	amountClaimed[bribeId] >= bribe.totalRewardAmount
	) return 0;

	uint256 _rewardPerVote = rewardPerVote[bribeId];
	// If period updated.
	if (
	_rewardPerVote == 0 \|\|
	(_rewardPerVote > 0 &&
	getActivePeriod(bribeId).timestamp != currentPeriod)
	) {
	uint256 _rewardPerPeriod;

	if (upgradedBribe.numberOfPeriods != 0) {
	// Update max reward per vote.
	bribe.maxRewardPerVote = upgradedBribe.maxRewardPerVote;
	bribe.totalRewardAmount = upgradedBribe.totalRewardAmount;
	}

	uint256 periodsLeft = endTimestamp > currentPeriod
	? (endTimestamp - currentPeriod) / _WEEK
	: 0;
	_rewardPerPeriod = bribe.totalRewardAmount - amountClaimed[bribeId];

	if (endTimestamp > currentPeriod + _WEEK && periodsLeft > 1) {
	_rewardPerPeriod = _rewardPerPeriod.mulDivDown(1, periodsLeft);
	}

	// Get Adjusted Slope without blacklisted addresses weight.
	uint256 gaugeBias = _getAdjustedBias(
	bribe.gauge,
	bribe.blacklist,
	currentPeriod
	);
	_rewardPerVote = _rewardPerPeriod.mulDivDown(_BASE_UNIT, gaugeBias);
	}
	// Get user voting power.
	uint256 _bias = _getAddrBias(
	userSlope.slope,
	userSlope.end,
	currentPeriod
	);
	// Estimation of the amount of rewards.
	amount = _bias.mulWadDown(_rewardPerVote);
	// Compute the reward amount based on
	// the max price to pay.
	uint256 _amountWithMaxPrice = _bias.mulWadDown(bribe.maxRewardPerVote);
	// Distribute the _min between the amount based on votes, and price.
	amount = _min(amount, _amountWithMaxPrice);

	uint256 _amountClaimed = amountClaimed[bribeId];
	// Update the amount claimed.
	if (amount + _amountClaimed > bribe.totalRewardAmount) {
	amount = bribe.totalRewardAmount - _amountClaimed;
	}
	// Substract fees.
	uint256 platformFee = FeeManager(
	factory.platformFeeManager(address(gaugeController))
	).totalFee();
	if (platformFee != 0) {
	amount = amount.mulWadDown(_BASE_UNIT - platformFee);
	}
	}

	////////////////////////////////////////////////////////////////
	/// --- INTERNAL VIEWS
	///////////////////////////////////////////////////////////////

	/// @notice Get adjusted slope from Gauge Controller for a given gauge address.
	/// Remove the weight of blacklisted addresses.
	/// @param gauge Address of the gauge.
	/// @param _addressesBlacklisted Array of blacklisted addresses.
	/// @param period Timestamp to check vote weight.
	function _getAdjustedBias(
	address gauge,
	address[] memory _addressesBlacklisted,
	uint256 period
	) internal view returns (uint256 gaugeBias) {
	// Cache the user slope.
	GaugeController.VotedSlope memory userSlope;
	// Bias
	uint256 _bias;
	// Last Vote
	uint256 _lastVote;
	// Cache the length of the array.
	uint256 length = _addressesBlacklisted.length;
	// Cache blacklist.
	// Get the gauge slope.
	gaugeBias = gaugeController.points_weight(gauge, period).bias;

	for (uint256 i = 0; i < length; ) {
	// Get the user slope.
	userSlope = gaugeController.vote_user_slopes(
	_addressesBlacklisted[i],
	gauge
	);
	_lastVote = gaugeController.last_user_vote(
	_addressesBlacklisted[i],
	gauge
	);
	if (period > _lastVote) {
	_bias = _getAddrBias(userSlope.slope, userSlope.end, period);
	gaugeBias -= _bias;
	}
	// Increment i.
	unchecked {
	++i;
	}
	}
	}

	////////////////////////////////////////////////////////////////
	/// --- MANAGEMENT LOGIC
	///////////////////////////////////////////////////////////////

	/// @notice Increase Bribe duration.
	/// @param _bribeId ID of the bribe.
	/// @param _additionnalPeriods Number of periods to add.
	/// @param _increasedAmount Total reward amount to add.
	/// @param _newMaxPricePerVote Total reward amount to add.
	function increaseBribeDuration(
	uint256 _bribeId,
	uint8 _additionnalPeriods,
	uint256 _increasedAmount,
	uint256 _newMaxPricePerVote,
	address[] calldata _addressesBlacklisted
	) external nonReentrant notKilled onlyManager(_bribeId) {
	if (!isUpgradeable[_bribeId]) revert NOT_UPGRADEABLE();
	if (getPeriodsLeft(_bribeId) < 1) revert NO_PERIODS_LEFT();
	if (_increasedAmount == 0 \|\| _newMaxPricePerVote == 0)
	revert WRONG_INPUT();

	Bribe storage bribe = bribes[_bribeId];
	Upgrade memory upgradedBribe = upgradeBribeQueue[_bribeId];

	ERC20(bribe.rewardToken).safeTransferFrom(
	msg.sender,
	address(this),
	_increasedAmount
	);

	if (upgradedBribe.totalRewardAmount != 0) {
	upgradedBribe = Upgrade({
	numberOfPeriods: upgradedBribe.numberOfPeriods +
	_additionnalPeriods,
	totalRewardAmount: upgradedBribe.totalRewardAmount +
	_increasedAmount,
	maxRewardPerVote: _newMaxPricePerVote,
	endTimestamp: upgradedBribe.endTimestamp +
	(_additionnalPeriods * _WEEK),
	blacklist: _addressesBlacklisted
	});
	} else {
	upgradedBribe = Upgrade({
	numberOfPeriods: bribe.numberOfPeriods + _additionnalPeriods,
	totalRewardAmount: bribe.totalRewardAmount + _increasedAmount,
	maxRewardPerVote: _newMaxPricePerVote,
	endTimestamp: bribe.endTimestamp +
	(_additionnalPeriods * _WEEK),
	blacklist: _addressesBlacklisted
	});
	}

	upgradeBribeQueue[_bribeId] = upgradedBribe;

	emit BribeDurationIncreaseQueued(
	_bribeId,
	upgradedBribe.numberOfPeriods,
	upgradedBribe.totalRewardAmount,
	_newMaxPricePerVote
	);
	}

	/// @notice Close Bribe if there is remaining.
	/// @param bribeId ID of the bribe to close.
	function closeBribe(uint256 bribeId)
	external
	nonReentrant
	onlyManager(bribeId)
	{
	// Check if the currentPeriod is the last one.
	// If not, we can increase the duration.
	Bribe storage bribe = bribes[bribeId];

	if (getCurrentPeriod() >= bribe.endTimestamp \|\| isKilled) {
	uint256 leftOver;
	Upgrade memory upgradedBribe = upgradeBribeQueue[bribeId];
	if (upgradedBribe.totalRewardAmount != 0) {
	leftOver =
	upgradedBribe.totalRewardAmount -
	amountClaimed[bribeId];
	delete upgradeBribeQueue[bribeId];
	} else {
	leftOver =
	bribes[bribeId].totalRewardAmount -
	amountClaimed[bribeId];
	}
	// Transfer the left over to the owner.
	ERC20(bribe.rewardToken).safeTransfer(bribe.manager, leftOver);
	delete bribes[bribeId].manager;

	emit BribeClosed(bribeId, leftOver);
	}
	}

	/// @notice Update Bribe Manager.
	/// @param bribeId ID of the bribe.
	/// @param newManager Address of the new manager.
	function updateManager(uint256 bribeId, address newManager)
	external
	nonReentrant
	onlyManager(bribeId)
	{
	emit ManagerUpdated(bribeId, bribes[bribeId].manager = newManager);
	}

	function kill() external {
	if (msg.sender != address(factory)) revert NOT_ALLOWED_OPERATION();
	isKilled = true;
	}

	////////////////////////////////////////////////////////////////
	/// --- UTILS FUNCTIONS
	///////////////////////////////////////////////////////////////

	/// @notice Returns the number of periods left for a given bribe.
	/// @param bribeId ID of the bribe.
	function getPeriodsLeft(uint256 bribeId)
	public
	view
	returns (uint256 periodsLeft)
	{
	Bribe storage bribe = bribes[bribeId];

	uint256 currentPeriod = getCurrentPeriod();
	periodsLeft = bribe.endTimestamp > currentPeriod
	? (bribe.endTimestamp - currentPeriod) / _WEEK
	: 0;
	}

	/// @notice Return the bribe object for a given ID.
	/// @param bribeId ID of the bribe.
	function getBribe(uint256 bribeId) external view returns (Bribe memory) {
	return bribes[bribeId];
	}

	/// @notice Return the bribe in queue for a given ID.
	/// @dev Can return an empty bribe if there is no upgrade.
	/// @param bribeId ID of the bribe.
	function getUpgradedBribeQueued(uint256 bribeId)
	external
	view
	returns (Upgrade memory)
	{
	return upgradeBribeQueue[bribeId];
	}

	/// @notice Return the blacklisted addresses of a bribe for a given ID.
	/// @param bribeId ID of the bribe.
	function getBlacklistedAddressesForBribe(uint256 bribeId)
	external
	view
	returns (address[] memory)
	{
	return bribes[bribeId].blacklist;
	}

	/// @notice Return the active period running of bribe given an ID.
	/// @param bribeId ID of the bribe.
	function getActivePeriod(uint256 bribeId)
	public
	view
	returns (Period memory)
	{
	return activePeriod[bribeId];
	}

	/// @notice Return the expected current period id.
	/// @param bribeId ID of the bribe.
	function getActivePeriodPerBribe(uint256 bribeId)
	public
	view
	returns (uint8)
	{
	Bribe storage bribe = bribes[bribeId];

	uint256 currentPeriod = getCurrentPeriod();
	uint256 periodsLeft = bribe.endTimestamp > currentPeriod
	? (bribe.endTimestamp - currentPeriod) / _WEEK
	: 0;
	// If periodsLeft is superior, then the bribe didn't start yet.
	return
	uint8(
	periodsLeft > bribe.numberOfPeriods
	? 0
	: bribe.numberOfPeriods - periodsLeft
	);
	}

	/// @notice Return the current period based on Gauge Controller rounding.
	function getCurrentPeriod() public view returns (uint256) {
	return (block.timestamp / _WEEK) * _WEEK;
	}

	/// @notice Return the minimum between two numbers.
	/// @param a First number.
	/// @param b Second number.
	function _min(uint256 a, uint256 b) private pure returns (uint256 min) {
	min = a < b ? a : b;
	}

	/// @notice Return the maximum between two numbers.
	/// @param a First number.
	/// @param b Second number.
	function _max(uint256 a, uint256 b) private pure returns (uint256 max) {
	max = a < b ? b : a;
	}

	/// @notice Return the bias of a given address based on its lock end date and the current period.
	/// @param userSlope User slope.
	/// @param endLockTime Lock end date of the address.
	/// @param currentPeriod Current period.
	function _getAddrBias(
	uint256 userSlope,
	uint256 endLockTime,
	uint256 currentPeriod
	) internal pure returns (uint256) {
	if (currentPeriod + _WEEK >= endLockTime) return 0;
	return userSlope * (endLockTime - currentPeriod);
	}
	}

	/// @notice Library for converting between addresses and bytes32 values.
	/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/Bytes32AddressLib.sol)
	library Bytes32AddressLib {
	function fromLast20Bytes(bytes32 bytesValue) internal pure returns (address) {
	return address(uint160(uint256(bytesValue)));
	}

	function fillLast12Bytes(address addressValue) internal pure returns (bytes32) {
	return bytes32(bytes20(addressValue));
	}
	}

	contract PlatformFactory is Owned, Factory {
	using Bytes32AddressLib for address;
	using Bytes32AddressLib for bytes32;

	/// @notice Fee recipient.
	address public feeCollector;

	/// @notice Fee Manager per gaugeController.
	mapping(address => address) public feeManagerPerGaugeController;

	/// @notice Recipient per address per gaugeController.
	mapping(address => mapping(address => address)) public recipient;

	/// @notice Emitted when a new platform is deployed.
	event PlatformDeployed(
	Platform indexed platform,
	address indexed gaugeController,
	FeeManager indexed feeManager
	);

	/// @notice Emitted when a platform is killed.
	event PlatformKilled(
	Platform indexed platform,
	address indexed gaugeController
	);

	/// @notice Emitted when a recipient is set for an address.
	event RecipientSet(address indexed sender, address indexed recipient);

	////////////////////////////////////////////////////////////////
	/// --- CONSTRUCTOR
	///////////////////////////////////////////////////////////////

	/// @notice Creates a Platform factory.
	/// @param _owner The owner of the factory.
	constructor(address _owner, address _feeCollector) Owned(_owner) {
	feeCollector = _feeCollector;
	}

	function deploy(address _gaugeController)
	external
	returns (Platform platform)
	{
	// Deploy the platform.
	platform = new Platform{
	salt: address(_gaugeController).fillLast12Bytes()
	}(_gaugeController, address(this));
	FeeManager feeManager = new FeeManager{
	salt: address(_gaugeController).fillLast12Bytes()
	}(feeCollector);
	feeManagerPerGaugeController[_gaugeController] = address(feeManager);

	emit PlatformDeployed(platform, _gaugeController, feeManager);
	}

	/// @notice Computes a Platform address from its gauge controller.
	function getPlatformFromGaugeController(address gaugeController)
	external
	view
	returns (Platform)
	{
	return
	Platform(
	payable(
	keccak256(
	abi.encodePacked(
	bytes1(0xFF),
	address(this),
	address(gaugeController).fillLast12Bytes(),
	keccak256(
	abi.encodePacked(
	type(Platform).creationCode,
	abi.encode(gaugeController, address(this))
	)
	)
	)
	).fromLast20Bytes() // Convert the CREATE2 hash into an address.
	)
	);
	}

	function setRecipient(address _recipient, address _gaugeController)
	external
	{
	recipient[msg.sender][_gaugeController] = _recipient;

	emit RecipientSet(msg.sender, _recipient);
	}

	function setRecipientFor(
	address _recipient,
	address _gaugeController,
	address _for
	) external onlyOwner {
	recipient[_for][_gaugeController] = _recipient;

	emit RecipientSet(_for, _recipient);
	}

	function setFeeManager(address _gaugeController, address _feeManager)
	external
	onlyOwner
	{
	feeManagerPerGaugeController[_gaugeController] = _feeManager;
	}

	function platformFeeManager(address _gaugeController)
	external
	view
	returns (address)
	{
	return feeManagerPerGaugeController[_gaugeController];
	}

	function setFeeCollector(address _feeCollector) external onlyOwner {
	feeCollector = _feeCollector;
	}

	function kill(address platform) external onlyOwner {
	Platform(platform).kill();
	emit PlatformKilled(
	Platform(platform),
	address(Platform(platform).gaugeController())
	);
	}
	}