Contract Name:
ChildChainGaugeFactory
Contract Source Code:
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
import "./interfaces/ILiquidityGaugeFactory.sol";
import "./Clones.sol";
abstract contract BaseGaugeFactory is ILiquidityGaugeFactory {
address private _gaugeImplementation;
mapping(address => bool) private _isGaugeFromFactory;
event GaugeCreated(address indexed gauge);
constructor(address gaugeImplementation) {
_gaugeImplementation = gaugeImplementation;
}
/**
* @notice Returns the address of the implementation used for gauge deployments.
*/
function getGaugeImplementation() public view returns (address) {
return _gaugeImplementation;
}
/**
* @notice Returns true if `gauge` was created by this factory.
*/
function isGaugeFromFactory(address gauge) external view override returns (bool) {
return _isGaugeFromFactory[gauge];
}
/**
* @dev Deploys a new gauge as a proxy of the implementation in storage.
* The deployed gauge must be initialized by the caller method.
* @return The address of the deployed gauge
*/
function _create() internal returns (address) {
address gauge = Clones.clone(_gaugeImplementation);
_isGaugeFromFactory[gauge] = true;
emit GaugeCreated(gauge);
return gauge;
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
pragma experimental ABIEncoderV2;
import "./interfaces/IChildChainGauge.sol";
import "./Version.sol";
import "./BaseGaugeFactory.sol";
contract ChildChainGaugeFactory is Version, BaseGaugeFactory {
string private _productVersion;
constructor(
IChildChainGauge gaugeImplementation,
string memory factoryVersion,
string memory productVersion
) Version(factoryVersion) BaseGaugeFactory(address(gaugeImplementation)) {
require(keccak256(abi.encodePacked(gaugeImplementation.version())) == keccak256(abi.encodePacked(productVersion)), "VERSION_MISMATCH");
_productVersion = productVersion;
}
/**
* @notice Returns a JSON representation of the deployed gauge version containing name, version number and task ID.
*
* @dev This value will only be updated at factory creation time.
*/
function getProductVersion() public view returns (string memory) {
return _productVersion;
}
/**
* @notice Deploys a new gauge for a Balancer pool.
* @dev As anyone can register arbitrary Balancer pools with the Vault,
* it's impossible to prove onchain that `pool` is a "valid" deployment.
*
* Care must be taken to ensure that gauges deployed from this factory are suitable to distribute rewards.
*
* It is possible to deploy multiple gauges for a single pool.
* @param pool The address of the pool for which to deploy a gauge
* @return The address of the deployed gauge
*/
function create(address pool) external returns (address) {
address gauge = _create();
IChildChainGauge(gauge).initialize(pool, getProductVersion());
return gauge;
}
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/Clones.sol)
pragma solidity ^0.7.0;
/**
* @dev https://eips.ethereum.org/EIPS/eip-1167[EIP 1167] is a standard for
* deploying minimal proxy contracts, also known as "clones".
*
* > To simply and cheaply clone contract functionality in an immutable way, this standard specifies
* > a minimal bytecode implementation that delegates all calls to a known, fixed address.
*
* The library includes functions to deploy a proxy using either `create` (traditional deployment) or `create2`
* (salted deterministic deployment). It also includes functions to predict the addresses of clones deployed using the
* deterministic method.
*
* _Available since v3.4._
*/
library Clones {
// solhint-disable no-inline-assembly
/**
* @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
*
* This function uses the create opcode, which should never revert.
*/
function clone(address implementation) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create(0, ptr, 0x37)
}
require(instance != address(0), "ERC1167: create failed");
}
/**
* @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`.
*
* This function uses the create2 opcode and a `salt` to deterministically deploy
* the clone. Using the same `implementation` and `salt` multiple time will revert, since
* the clones cannot be deployed twice at the same address.
*/
function cloneDeterministic(address implementation, bytes32 salt) internal returns (address instance) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
instance := create2(0, ptr, 0x37, salt)
}
require(instance != address(0), "ERC1167: create2 failed");
}
/**
* @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
*/
function predictDeterministicAddress(
address implementation,
bytes32 salt,
address deployer
) internal pure returns (address predicted) {
assembly {
let ptr := mload(0x40)
mstore(ptr, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(ptr, 0x14), shl(0x60, implementation))
mstore(add(ptr, 0x28), 0x5af43d82803e903d91602b57fd5bf3ff00000000000000000000000000000000)
mstore(add(ptr, 0x38), shl(0x60, deployer))
mstore(add(ptr, 0x4c), salt)
mstore(add(ptr, 0x6c), keccak256(ptr, 0x37))
predicted := keccak256(add(ptr, 0x37), 0x55)
}
}
/**
* @dev Computes the address of a clone deployed using {Clones-cloneDeterministic}.
*/
function predictDeterministicAddress(address implementation, bytes32 salt)
internal
view
returns (address predicted)
{
return predictDeterministicAddress(implementation, salt, address(this));
}
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.7.0 <0.9.0;
import "./IVersion.sol";
import "./ILiquidityGaugeFactory.sol";
// For compatibility, we're keeping the same function names as in the original Curve code, including the mixed-case
// naming convention.
// solhint-disable func-name-mixedcase
// solhint-disable func-param-name-mixedcase
interface IChildChainGauge is IVersion {
/**
* @notice Proxy constructor.
* @param lpToken Pool allowed to stake in this gauge.
* @param version Gauge version string identifier.
*/
function initialize(address lpToken, string memory version) external;
/**
* @notice Returns BAL liquidity emissions calculated during checkpoints for the given user.
* @param user User address.
* @return uint256 BAL amount to issue for the address.
*/
function integrate_fraction(address user) external view returns (uint256);
/**
* @notice Records a checkpoint for a given user.
* @param user User address.
* @return bool Always true.
*/
function user_checkpoint(address user) external returns (bool);
/**
* @notice Returns gauge factory address.
*/
function factory() external view returns (ILiquidityGaugeFactory);
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.7.0 <0.9.0;
// For compatibility, we're keeping the same function names as in the original Curve code, including the mixed-case
// naming convention.
// solhint-disable func-name-mixedcase
// solhint-disable func-param-name-mixedcase
interface ILiquidityGauge {
// solhint-disable-next-line var-name-mixedcase
event RelativeWeightCapChanged(uint256 new_relative_weight_cap);
/**
* @notice Returns BAL liquidity emissions calculated during checkpoints for the given user.
* @param user User address.
* @return uint256 BAL amount to issue for the address.
*/
function integrate_fraction(address user) external view returns (uint256);
/**
* @notice Record a checkpoint for a given user.
* @param user User address.
* @return bool Always true.
*/
function user_checkpoint(address user) external returns (bool);
/**
* @notice Returns true if gauge is killed; false otherwise.
*/
function is_killed() external view returns (bool);
/**
* @notice Kills the gauge so it cannot mint BAL.
*/
function killGauge() external;
/**
* @notice Unkills the gauge so it can mint BAL again.
*/
function unkillGauge() external;
/**
* @notice Sets a new relative weight cap for the gauge.
* The value shall be normalized to 1e18, and not greater than MAX_RELATIVE_WEIGHT_CAP.
* @param relativeWeightCap New relative weight cap.
*/
function setRelativeWeightCap(uint256 relativeWeightCap) external;
/**
* @notice Gets the relative weight cap for the gauge.
*/
function getRelativeWeightCap() external view returns (uint256);
/**
* @notice Returns the gauge's relative weight for a given time, capped to its relative weight cap attribute.
* @param time Timestamp in the past or present.
*/
function getCappedRelativeWeight(uint256 time) external view returns (uint256);
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.7.0 <0.9.0;
pragma experimental ABIEncoderV2;
import "./ILiquidityGauge.sol";
interface ILiquidityGaugeFactory {
/**
* @notice Returns true if `gauge` was created by this factory.
*/
function isGaugeFromFactory(address gauge) external view returns (bool);
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.7.0 <0.9.0;
/**
* @notice Simple interface to retrieve the version of a deployed contract.
*/
interface IVersion {
/**
* @dev Returns a JSON representation of the contract version containing name, version number and task ID.
*/
function version() external view returns (string memory);
}
// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity ^0.7.0;
import "./interfaces/IVersion.sol";
/**
* @notice Retrieves a contract's version set at creation time from storage.
*/
contract Version is IVersion {
string private _version;
constructor(string memory version) {
_setVersion(version);
}
function version() external view override returns (string memory) {
return _version;
}
/**
* @dev Internal setter that allows this contract to be used in proxies.
*/
function _setVersion(string memory newVersion) internal {
_version = newVersion;
}
}