编译器
0.6.12+commit.27d51765
文件 1 的 19：AddressUpgradeable.sol
pragma solidity >=0.6.2 <0.8.0;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{ value: value }(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return _verifyCallResult(success, returndata, errorMessage);
}
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
文件 2 的 19：Constants.sol
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/introspection/IERC1820RegistryUpgradeable.sol";
library Constants {
IERC1820RegistryUpgradeable public constant REGISTRY = IERC1820RegistryUpgradeable(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
bytes32 public constant TOKENS_SENDER_INTERFACE_HASH =
0x29ddb589b1fb5fc7cf394961c1adf5f8c6454761adf795e67fe149f658abe895;
bytes32 public constant TOKENS_RECIPIENT_INTERFACE_HASH =
0xb281fc8c12954d22544db45de3159a39272895b169a852b314f9cc762e44c53b;
bytes32 public constant ACCEPT_MAGIC =
0xa2ef4600d742022d532d4747cb3547474667d6f13804902513b2ec01c848f4b4;
bytes4 public constant ERC165_INTERFACE_ID_ERC165 = 0x01ffc9a7;
bytes4 public constant ERC165_INTERFACE_ID_ERC721 = 0x80ac58cd;
}文件 3 的 19：ContextUpgradeable.sol
pragma solidity >=0.6.0 <0.8.0;
import "../proxy/Initializable.sol";
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal initializer {
__Context_init_unchained();
}
function __Context_init_unchained() internal initializer {
}
function _msgSender() internal view virtual returns (address payable) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes memory) {
this;
return msg.data;
}
uint256[50] private __gap;
}
文件 4 的 19：ExtendedSafeCast.sol
pragma solidity >=0.6.0 <0.7.0;
library ExtendedSafeCast {
function toUint112(uint256 value) internal pure returns (uint112) {
require(value < 2**112, "SafeCast: value doesn't fit in an uint112");
return uint112(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value < 2**96, "SafeCast: value doesn't fit in an uint96");
return uint96(value);
}
}文件 5 的 19：FixedPoint.sol
pragma solidity >=0.6.0 <0.8.0;
import "./external/openzeppelin/OpenZeppelinSafeMath_V3_3_0.sol";
library FixedPoint {
using OpenZeppelinSafeMath_V3_3_0 for uint256;
uint256 internal constant SCALE = 1e18;
function calculateMantissa(uint256 numerator, uint256 denominator) internal pure returns (uint256) {
uint256 mantissa = numerator.mul(SCALE);
mantissa = mantissa.div(denominator);
return mantissa;
}
function multiplyUintByMantissa(uint256 b, uint256 mantissa) internal pure returns (uint256) {
uint256 result = mantissa.mul(b);
result = result.div(SCALE);
return result;
}
function divideUintByMantissa(uint256 dividend, uint256 mantissa) internal pure returns (uint256) {
uint256 result = SCALE.mul(dividend);
result = result.div(mantissa);
return result;
}
}
文件 6 的 19：IERC165Upgradeable.sol
pragma solidity >=0.6.0 <0.8.0;
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
文件 7 的 19：IERC1820RegistryUpgradeable.sol
pragma solidity >=0.6.0 <0.8.0;
interface IERC1820RegistryUpgradeable {
function setManager(address account, address newManager) external;
function getManager(address account) external view returns (address);
function setInterfaceImplementer(address account, bytes32 _interfaceHash, address implementer) external;
function getInterfaceImplementer(address account, bytes32 _interfaceHash) external view returns (address);
function interfaceHash(string calldata interfaceName) external pure returns (bytes32);
function updateERC165Cache(address account, bytes4 interfaceId) external;
function implementsERC165Interface(address account, bytes4 interfaceId) external view returns (bool);
function implementsERC165InterfaceNoCache(address account, bytes4 interfaceId) external view returns (bool);
event InterfaceImplementerSet(address indexed account, bytes32 indexed interfaceHash, address indexed implementer);
event ManagerChanged(address indexed account, address indexed newManager);
}
文件 8 的 19：IERC20Upgradeable.sol
pragma solidity >=0.6.0 <0.8.0;
interface IERC20Upgradeable {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
文件 9 的 19：Initializable.sol
pragma solidity >=0.4.24 <0.8.0;
import "../utils/AddressUpgradeable.sol";
abstract contract Initializable {
bool private _initialized;
bool private _initializing;
modifier initializer() {
require(_initializing || _isConstructor() || !_initialized, "Initializable: contract is already initialized");
bool isTopLevelCall = !_initializing;
if (isTopLevelCall) {
_initializing = true;
_initialized = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
}
}
function _isConstructor() private view returns (bool) {
return !AddressUpgradeable.isContract(address(this));
}
}
文件 10 的 19：OpenZeppelinSafeMath_V3_3_0.sol
pragma solidity >=0.6.0 <0.8.0;
library OpenZeppelinSafeMath_V3_3_0 {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return sub(a, b, "SafeMath: subtraction overflow");
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
uint256 c = a - b;
return c;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return div(a, b, "SafeMath: division by zero");
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
uint256 c = a / b;
return c;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return mod(a, b, "SafeMath: modulo by zero");
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b != 0, errorMessage);
return a % b;
}
}
文件 11 的 19：OwnableUpgradeable.sol
pragma solidity >=0.6.0 <0.8.0;
import "../utils/ContextUpgradeable.sol";
import "../proxy/Initializable.sol";
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal initializer {
__Context_init_unchained();
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal initializer {
address msgSender = _msgSender();
_owner = msgSender;
emit OwnershipTransferred(address(0), msgSender);
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
uint256[49] private __gap;
}
文件 12 的 19：ProxyFactory.sol
pragma solidity >=0.6.0 <0.7.0;
contract ProxyFactory {
event ProxyCreated(address proxy);
function deployMinimal(address _logic, bytes memory _data) public returns (address proxy) {
bytes20 targetBytes = bytes20(_logic);
assembly {
let clone := mload(0x40)
mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone, 0x14), targetBytes)
mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
proxy := create(0, clone, 0x37)
}
emit ProxyCreated(address(proxy));
if(_data.length > 0) {
(bool success,) = proxy.call(_data);
require(success, "ProxyFactory/constructor-call-failed");
}
}
}
文件 13 的 19：SafeCastUpgradeable.sol
pragma solidity >=0.6.0 <0.8.0;
library SafeCastUpgradeable {
function toUint128(uint256 value) internal pure returns (uint128) {
require(value < 2**128, "SafeCast: value doesn\'t fit in 128 bits");
return uint128(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value < 2**64, "SafeCast: value doesn\'t fit in 64 bits");
return uint64(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value < 2**32, "SafeCast: value doesn\'t fit in 32 bits");
return uint32(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value < 2**16, "SafeCast: value doesn\'t fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value < 2**8, "SafeCast: value doesn\'t fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt128(int256 value) internal pure returns (int128) {
require(value >= -2**127 && value < 2**127, "SafeCast: value doesn\'t fit in 128 bits");
return int128(value);
}
function toInt64(int256 value) internal pure returns (int64) {
require(value >= -2**63 && value < 2**63, "SafeCast: value doesn\'t fit in 64 bits");
return int64(value);
}
function toInt32(int256 value) internal pure returns (int32) {
require(value >= -2**31 && value < 2**31, "SafeCast: value doesn\'t fit in 32 bits");
return int32(value);
}
function toInt16(int256 value) internal pure returns (int16) {
require(value >= -2**15 && value < 2**15, "SafeCast: value doesn\'t fit in 16 bits");
return int16(value);
}
function toInt8(int256 value) internal pure returns (int8) {
require(value >= -2**7 && value < 2**7, "SafeCast: value doesn\'t fit in 8 bits");
return int8(value);
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value < 2**255, "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
文件 14 的 19：SafeMathUpgradeable.sol
pragma solidity >=0.6.0 <0.8.0;
library SafeMathUpgradeable {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b > a) return (false, 0);
return (true, a - b);
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a / b);
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
if (b == 0) return (false, 0);
return (true, a % b);
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath: addition overflow");
return c;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath: subtraction overflow");
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) return 0;
uint256 c = a * b;
require(c / a == b, "SafeMath: multiplication overflow");
return c;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: division by zero");
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0, "SafeMath: modulo by zero");
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b <= a, errorMessage);
return a - b;
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a / b;
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
require(b > 0, errorMessage);
return a % b;
}
}
文件 15 的 19：TokenFaucet.sol
pragma solidity >=0.6.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/SafeCastUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/Initializable.sol";
import "@pooltogether/fixed-point/contracts/FixedPoint.sol";
import "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
import "../utils/ExtendedSafeCast.sol";
import "../token/TokenListener.sol";
contract TokenFaucet is OwnableUpgradeable, TokenListener {
using SafeMathUpgradeable for uint256;
using SafeCastUpgradeable for uint256;
using ExtendedSafeCast for uint256;
event Initialized(
IERC20Upgradeable indexed asset,
IERC20Upgradeable indexed measure,
uint256 dripRatePerSecond
);
event Dripped(
uint256 newTokens
);
event Deposited(
address indexed user,
uint256 amount
);
event Withdrawn(
address indexed to,
uint256 amount
);
event Claimed(
address indexed user,
uint256 newTokens
);
event DripRateChanged(
uint256 dripRatePerSecond
);
struct UserState {
uint128 lastExchangeRateMantissa;
uint128 balance;
}
IERC20Upgradeable public asset;
IERC20Upgradeable public measure;
uint256 public dripRatePerSecond;
uint112 public exchangeRateMantissa;
uint112 public totalUnclaimed;
uint32 public lastDripTimestamp;
mapping(address => UserState) public userStates;
function initialize (
IERC20Upgradeable _asset,
IERC20Upgradeable _measure,
uint256 _dripRatePerSecond
) public initializer {
__Ownable_init();
lastDripTimestamp = _currentTime();
asset = _asset;
measure = _measure;
setDripRatePerSecond(_dripRatePerSecond);
emit Initialized(
asset,
measure,
dripRatePerSecond
);
}
function deposit(uint256 amount) external {
drip();
asset.transferFrom(msg.sender, address(this), amount);
emit Deposited(msg.sender, amount);
}
function withdrawTo(address to, uint256 amount) external onlyOwner {
drip();
uint256 assetTotalSupply = asset.balanceOf(address(this));
uint256 availableTotalSupply = assetTotalSupply.sub(totalUnclaimed);
require(amount <= availableTotalSupply, "TokenFaucet/insufficient-funds");
asset.transfer(to, amount);
emit Withdrawn(to, amount);
}
function claim(address user) external returns (uint256) {
drip();
_captureNewTokensForUser(user);
uint256 balance = userStates[user].balance;
userStates[user].balance = 0;
totalUnclaimed = uint256(totalUnclaimed).sub(balance).toUint112();
asset.transfer(user, balance);
emit Claimed(user, balance);
return balance;
}
function drip() public returns (uint256) {
uint256 currentTimestamp = _currentTime();
if (lastDripTimestamp == uint32(currentTimestamp)) {
return 0;
}
uint256 assetTotalSupply = asset.balanceOf(address(this));
uint256 availableTotalSupply = assetTotalSupply.sub(totalUnclaimed);
uint256 newSeconds = currentTimestamp.sub(lastDripTimestamp);
uint256 nextExchangeRateMantissa = exchangeRateMantissa;
uint256 newTokens;
uint256 measureTotalSupply = measure.totalSupply();
if (measureTotalSupply > 0 && availableTotalSupply > 0) {
newTokens = newSeconds.mul(dripRatePerSecond);
if (newTokens > availableTotalSupply) {
newTokens = availableTotalSupply;
}
uint256 indexDeltaMantissa = FixedPoint.calculateMantissa(newTokens, measureTotalSupply);
nextExchangeRateMantissa = nextExchangeRateMantissa.add(indexDeltaMantissa);
emit Dripped(
newTokens
);
}
exchangeRateMantissa = nextExchangeRateMantissa.toUint112();
totalUnclaimed = uint256(totalUnclaimed).add(newTokens).toUint112();
lastDripTimestamp = currentTimestamp.toUint32();
return newTokens;
}
function setDripRatePerSecond(uint256 _dripRatePerSecond) public onlyOwner {
require(_dripRatePerSecond > 0, "TokenFaucet/dripRate-gt-zero");
drip();
dripRatePerSecond = _dripRatePerSecond;
emit DripRateChanged(dripRatePerSecond);
}
function _captureNewTokensForUser(
address user
) private returns (uint128) {
UserState storage userState = userStates[user];
if (exchangeRateMantissa == userState.lastExchangeRateMantissa) {
return 0;
}
uint256 deltaExchangeRateMantissa = uint256(exchangeRateMantissa).sub(userState.lastExchangeRateMantissa);
uint256 userMeasureBalance = measure.balanceOf(user);
uint128 newTokens = FixedPoint.multiplyUintByMantissa(userMeasureBalance, deltaExchangeRateMantissa).toUint128();
userStates[user] = UserState({
lastExchangeRateMantissa: exchangeRateMantissa,
balance: uint256(userState.balance).add(newTokens).toUint128()
});
return newTokens;
}
function beforeTokenMint(
address to,
uint256,
address token,
address
)
external
override
{
if (token == address(measure)) {
drip();
_captureNewTokensForUser(to);
}
}
function beforeTokenTransfer(
address from,
address to,
uint256,
address token
)
external
override
{
if (token == address(measure) && from != address(0)) {
drip();
_captureNewTokensForUser(to);
_captureNewTokensForUser(from);
}
}
function _currentTime() internal virtual view returns (uint32) {
return block.timestamp.toUint32();
}
}
文件 16 的 19：TokenFaucetProxyFactory.sol
pragma solidity >=0.6.0 <0.7.0;
import "./TokenFaucet.sol";
import "../external/openzeppelin/ProxyFactory.sol";
contract TokenFaucetProxyFactory is ProxyFactory {
TokenFaucet public instance;
constructor () public {
instance = new TokenFaucet();
}
function create(
IERC20Upgradeable _asset,
IERC20Upgradeable _measure,
uint256 _dripRatePerSecond
) public returns (TokenFaucet) {
TokenFaucet tokenFaucet = TokenFaucet(deployMinimal(address(instance), ""));
tokenFaucet.initialize(
_asset, _measure, _dripRatePerSecond
);
tokenFaucet.transferOwnership(msg.sender);
return tokenFaucet;
}
function createAndDeposit(
IERC20Upgradeable _asset,
IERC20Upgradeable _measure,
uint256 _dripRatePerSecond,
uint256 _amount
) external returns (TokenFaucet) {
TokenFaucet faucet = create(_asset, _measure, _dripRatePerSecond);
_asset.transferFrom(msg.sender, address(faucet), _amount);
}
function claimAll(address user, TokenFaucet[] calldata tokenFaucets) external {
for (uint256 i = 0; i < tokenFaucets.length; i++) {
tokenFaucets[i].claim(user);
}
}
}
文件 17 的 19：TokenListener.sol
pragma solidity ^0.6.4;
import "./TokenListenerInterface.sol";
import "./TokenListenerLibrary.sol";
import "../Constants.sol";
abstract contract TokenListener is TokenListenerInterface {
function supportsInterface(bytes4 interfaceId) external override view returns (bool) {
return (
interfaceId == Constants.ERC165_INTERFACE_ID_ERC165 ||
interfaceId == TokenListenerLibrary.ERC165_INTERFACE_ID_TOKEN_LISTENER
);
}
}
文件 18 的 19：TokenListenerInterface.sol
pragma solidity >=0.5.0 <0.7.0;
import "@openzeppelin/contracts-upgradeable/introspection/IERC165Upgradeable.sol";
interface TokenListenerInterface is IERC165Upgradeable {
function beforeTokenMint(address to, uint256 amount, address controlledToken, address referrer) external;
function beforeTokenTransfer(address from, address to, uint256 amount, address controlledToken) external;
}
文件 19 的 19：TokenListenerLibrary.sol
pragma solidity ^0.6.12;
library TokenListenerLibrary {
bytes4 public constant ERC165_INTERFACE_ID_TOKEN_LISTENER = 0xff5e34e7;
}{
"compilationTarget": {
"contracts/token-faucet/TokenFaucetProxyFactory.sol": "TokenFaucetProxyFactory"
},
"evmVersion": "istanbul",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs",
"useLiteralContent": true
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": []
}[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"proxy","type":"address"}],"name":"ProxyCreated","type":"event"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"contract TokenFaucet[]","name":"tokenFaucets","type":"address[]"}],"name":"claimAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"_asset","type":"address"},{"internalType":"contract IERC20Upgradeable","name":"_measure","type":"address"},{"internalType":"uint256","name":"_dripRatePerSecond","type":"uint256"}],"name":"create","outputs":[{"internalType":"contract TokenFaucet","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20Upgradeable","name":"_asset","type":"address"},{"internalType":"contract IERC20Upgradeable","name":"_measure","type":"address"},{"internalType":"uint256","name":"_dripRatePerSecond","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"createAndDeposit","outputs":[{"internalType":"contract TokenFaucet","name":"","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_logic","type":"address"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"deployMinimal","outputs":[{"internalType":"address","name":"proxy","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"instance","outputs":[{"internalType":"contract TokenFaucet","name":"","type":"address"}],"stateMutability":"view","type":"function"}]
