ERC-1155
Overview
Max Total Supply
1,009,968,514,381,621,680,307,172
Holders
37
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
BondingShare
Compiler Version
v0.8.3+commit.8d00100c
Optimization Enabled:
Yes with 800 runs
Other Settings:
default evmVersion
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT pragma solidity ^0.8.3; import "./ERC1155Ubiquity.sol"; contract BondingShare is ERC1155Ubiquity { // solhint-disable-next-line no-empty-blocks constructor(address _manager) ERC1155Ubiquity(_manager, "URI") {} }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.3; import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol"; import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol"; import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Pausable.sol"; import "./UbiquityAlgorithmicDollarManager.sol"; import "./utils/SafeAddArray.sol"; /// @title ERC1155 Ubiquity preset /// @author Ubiquity Algorithmic Dollar /// @notice ERC1155 with : /// - ERC1155 minter, burner and pauser /// - TotatSupply per id /// - Ubiquity Manager access control contract ERC1155Ubiquity is ERC1155, ERC1155Burnable, ERC1155Pausable { using SafeAddArray for uint256[]; UbiquityAlgorithmicDollarManager public manager; // Mapping from account to operator approvals mapping(address => uint256[]) private _holderBalances; uint256 private _totalSupply; // ----------- Modifiers ----------- modifier onlyMinter() { require( manager.hasRole(manager.UBQ_MINTER_ROLE(), msg.sender), "Governance token: not minter" ); _; } modifier onlyBurner() { require( manager.hasRole(manager.UBQ_BURNER_ROLE(), msg.sender), "Governance token: not burner" ); _; } modifier onlyPauser() { require( manager.hasRole(manager.PAUSER_ROLE(), msg.sender), "Governance token: not pauser" ); _; } /** * @dev constructor */ constructor(address _manager, string memory uri) ERC1155(uri) { manager = UbiquityAlgorithmicDollarManager(_manager); } // @dev Creates `amount` new tokens for `to`, of token type `id`. function mint( address to, uint256 id, uint256 amount, bytes memory data ) public virtual onlyMinter { _mint(to, id, amount, data); _totalSupply += amount; _holderBalances[to].add(id); } // @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] variant of {mint}. function mintBatch( address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) public virtual onlyMinter whenNotPaused { _mintBatch(to, ids, amounts, data); for (uint256 i = 0; i < ids.length; ++i) { _totalSupply += amounts[i]; } _holderBalances[to].add(ids); } /** * @dev Pauses all token transfers. * * See {ERC1155Pausable} and {Pausable-_pause}. * */ function pause() public virtual onlyPauser { _pause(); } /** * @dev Unpauses all token transfers. * * See {ERC1155Pausable} and {Pausable-_unpause}. * */ function unpause() public virtual onlyPauser { _unpause(); } /** * @dev See {IERC1155-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes memory data ) public override { super.safeTransferFrom(from, to, id, amount, data); _holderBalances[to].add(id); } /** * @dev See {IERC1155-safeBatchTransferFrom}. */ function safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) public virtual override { super.safeBatchTransferFrom(from, to, ids, amounts, data); _holderBalances[to].add(ids); } /** * @dev Total amount of tokens in with a given id. */ function totalSupply() public view virtual returns (uint256) { return _totalSupply; } /** * @dev array of token Id held by the msg.sender. */ function holderTokens(address holder) public view returns (uint256[] memory) { return _holderBalances[holder]; } function _burn( address account, uint256 id, uint256 amount ) internal virtual override whenNotPaused { super._burn(account, id, amount); _totalSupply -= amount; } function _burnBatch( address account, uint256[] memory ids, uint256[] memory amounts ) internal virtual override whenNotPaused { super._burnBatch(account, ids, amounts); for (uint256 i = 0; i < ids.length; ++i) { _totalSupply -= amounts[i]; } } function _beforeTokenTransfer( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual override(ERC1155, ERC1155Pausable) { super._beforeTokenTransfer(operator, from, to, ids, amounts, data); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IERC1155.sol"; import "./IERC1155Receiver.sol"; import "./extensions/IERC1155MetadataURI.sol"; import "../../utils/Address.sol"; import "../../utils/Context.sol"; import "../../utils/introspection/ERC165.sol"; /** * @dev Implementation of the basic standard multi-token. * See https://eips.ethereum.org/EIPS/eip-1155 * Originally based on code by Enjin: https://github.com/enjin/erc-1155 * * _Available since v3.1._ */ contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI { using Address for address; // Mapping from token ID to account balances mapping (uint256 => mapping(address => uint256)) private _balances; // Mapping from account to operator approvals mapping (address => mapping(address => bool)) private _operatorApprovals; // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json string private _uri; /** * @dev See {_setURI}. */ constructor (string memory uri_) { _setURI(uri_); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC1155).interfaceId || interfaceId == type(IERC1155MetadataURI).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC1155MetadataURI-uri}. * * This implementation returns the same URI for *all* token types. It relies * on the token type ID substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. * * Clients calling this function must replace the `\{id\}` substring with the * actual token type ID. */ function uri(uint256) public view virtual override returns (string memory) { return _uri; } /** * @dev See {IERC1155-balanceOf}. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) public view virtual override returns (uint256) { require(account != address(0), "ERC1155: balance query for the zero address"); return _balances[id][account]; } /** * @dev See {IERC1155-balanceOfBatch}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch( address[] memory accounts, uint256[] memory ids ) public view virtual override returns (uint256[] memory) { require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch"); uint256[] memory batchBalances = new uint256[](accounts.length); for (uint256 i = 0; i < accounts.length; ++i) { batchBalances[i] = balanceOf(accounts[i], ids[i]); } return batchBalances; } /** * @dev See {IERC1155-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(_msgSender() != operator, "ERC1155: setting approval status for self"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC1155-isApprovedForAll}. */ function isApprovedForAll(address account, address operator) public view virtual override returns (bool) { return _operatorApprovals[account][operator]; } /** * @dev See {IERC1155-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes memory data ) public virtual override { require(to != address(0), "ERC1155: transfer to the zero address"); require( from == _msgSender() || isApprovedForAll(from, _msgSender()), "ERC1155: caller is not owner nor approved" ); address operator = _msgSender(); _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data); uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: insufficient balance for transfer"); _balances[id][from] = fromBalance - amount; _balances[id][to] += amount; emit TransferSingle(operator, from, to, id, amount); _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data); } /** * @dev See {IERC1155-safeBatchTransferFrom}. */ function safeBatchTransferFrom( address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) public virtual override { require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); require(to != address(0), "ERC1155: transfer to the zero address"); require( from == _msgSender() || isApprovedForAll(from, _msgSender()), "ERC1155: transfer caller is not owner nor approved" ); address operator = _msgSender(); _beforeTokenTransfer(operator, from, to, ids, amounts, data); for (uint256 i = 0; i < ids.length; ++i) { uint256 id = ids[i]; uint256 amount = amounts[i]; uint256 fromBalance = _balances[id][from]; require(fromBalance >= amount, "ERC1155: insufficient balance for transfer"); _balances[id][from] = fromBalance - amount; _balances[id][to] += amount; } emit TransferBatch(operator, from, to, ids, amounts); _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data); } /** * @dev Sets a new URI for all token types, by relying on the token type ID * substitution mechanism * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP]. * * By this mechanism, any occurrence of the `\{id\}` substring in either the * URI or any of the amounts in the JSON file at said URI will be replaced by * clients with the token type ID. * * For example, the `https://token-cdn-domain/\{id\}.json` URI would be * interpreted by clients as * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json` * for token type ID 0x4cce0. * * See {uri}. * * Because these URIs cannot be meaningfully represented by the {URI} event, * this function emits no events. */ function _setURI(string memory newuri) internal virtual { _uri = newuri; } /** * @dev Creates `amount` tokens of token type `id`, and assigns them to `account`. * * Emits a {TransferSingle} event. * * Requirements: * * - `account` cannot be the zero address. * - If `account` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function _mint(address account, uint256 id, uint256 amount, bytes memory data) internal virtual { require(account != address(0), "ERC1155: mint to the zero address"); address operator = _msgSender(); _beforeTokenTransfer(operator, address(0), account, _asSingletonArray(id), _asSingletonArray(amount), data); _balances[id][account] += amount; emit TransferSingle(operator, address(0), account, id, amount); _doSafeTransferAcceptanceCheck(operator, address(0), account, id, amount, data); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function _mintBatch(address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data) internal virtual { require(to != address(0), "ERC1155: mint to the zero address"); require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); address operator = _msgSender(); _beforeTokenTransfer(operator, address(0), to, ids, amounts, data); for (uint i = 0; i < ids.length; i++) { _balances[ids[i]][to] += amounts[i]; } emit TransferBatch(operator, address(0), to, ids, amounts); _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data); } /** * @dev Destroys `amount` tokens of token type `id` from `account` * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens of token type `id`. */ function _burn(address account, uint256 id, uint256 amount) internal virtual { require(account != address(0), "ERC1155: burn from the zero address"); address operator = _msgSender(); _beforeTokenTransfer(operator, account, address(0), _asSingletonArray(id), _asSingletonArray(amount), ""); uint256 accountBalance = _balances[id][account]; require(accountBalance >= amount, "ERC1155: burn amount exceeds balance"); _balances[id][account] = accountBalance - amount; emit TransferSingle(operator, account, address(0), id, amount); } /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}. * * Requirements: * * - `ids` and `amounts` must have the same length. */ function _burnBatch(address account, uint256[] memory ids, uint256[] memory amounts) internal virtual { require(account != address(0), "ERC1155: burn from the zero address"); require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch"); address operator = _msgSender(); _beforeTokenTransfer(operator, account, address(0), ids, amounts, ""); for (uint i = 0; i < ids.length; i++) { uint256 id = ids[i]; uint256 amount = amounts[i]; uint256 accountBalance = _balances[id][account]; require(accountBalance >= amount, "ERC1155: burn amount exceeds balance"); _balances[id][account] = accountBalance - amount; } emit TransferBatch(operator, account, address(0), ids, amounts); } /** * @dev Hook that is called before any token transfer. This includes minting * and burning, as well as batched variants. * * The same hook is called on both single and batched variants. For single * transfers, the length of the `id` and `amount` arrays will be 1. * * Calling conditions (for each `id` and `amount` pair): * * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens * of token type `id` will be transferred to `to`. * - When `from` is zero, `amount` tokens of token type `id` will be minted * for `to`. * - when `to` is zero, `amount` of ``from``'s tokens of token type `id` * will be burned. * - `from` and `to` are never both zero. * - `ids` and `amounts` have the same, non-zero length. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual { } function _doSafeTransferAcceptanceCheck( address operator, address from, address to, uint256 id, uint256 amount, bytes memory data ) private { if (to.isContract()) { try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) { if (response != IERC1155Receiver(to).onERC1155Received.selector) { revert("ERC1155: ERC1155Receiver rejected tokens"); } } catch Error(string memory reason) { revert(reason); } catch { revert("ERC1155: transfer to non ERC1155Receiver implementer"); } } } function _doSafeBatchTransferAcceptanceCheck( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) private { if (to.isContract()) { try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (bytes4 response) { if (response != IERC1155Receiver(to).onERC1155BatchReceived.selector) { revert("ERC1155: ERC1155Receiver rejected tokens"); } } catch Error(string memory reason) { revert(reason); } catch { revert("ERC1155: transfer to non ERC1155Receiver implementer"); } } } function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) { uint256[] memory array = new uint256[](1); array[0] = element; return array; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../ERC1155.sol"; /** * @dev Extension of {ERC1155} that allows token holders to destroy both their * own tokens and those that they have been approved to use. * * _Available since v3.1._ */ abstract contract ERC1155Burnable is ERC1155 { function burn(address account, uint256 id, uint256 value) public virtual { require( account == _msgSender() || isApprovedForAll(account, _msgSender()), "ERC1155: caller is not owner nor approved" ); _burn(account, id, value); } function burnBatch(address account, uint256[] memory ids, uint256[] memory values) public virtual { require( account == _msgSender() || isApprovedForAll(account, _msgSender()), "ERC1155: caller is not owner nor approved" ); _burnBatch(account, ids, values); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../ERC1155.sol"; import "../../../security/Pausable.sol"; /** * @dev ERC1155 token with pausable token transfers, minting and burning. * * Useful for scenarios such as preventing trades until the end of an evaluation * period, or having an emergency switch for freezing all token transfers in the * event of a large bug. * * _Available since v3.1._ */ abstract contract ERC1155Pausable is ERC1155, Pausable { /** * @dev See {ERC1155-_beforeTokenTransfer}. * * Requirements: * * - the contract must not be paused. */ function _beforeTokenTransfer( address operator, address from, address to, uint256[] memory ids, uint256[] memory amounts, bytes memory data ) internal virtual override { super._beforeTokenTransfer(operator, from, to, ids, amounts, data); require(!paused(), "ERC1155Pausable: token transfer while paused"); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.3; import "@openzeppelin/contracts/access/AccessControl.sol"; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol"; import "./interfaces/IUbiquityAlgorithmicDollar.sol"; import "./interfaces/ICurveFactory.sol"; import "./interfaces/IMetaPool.sol"; import "./TWAPOracle.sol"; /// @title A central config for the uAD system. Also acts as a central /// access control manager. /// @notice For storing constants. For storing variables and allowing them to /// be changed by the admin (governance) /// @dev This should be used as a central access control manager which other /// contracts use to check permissions contract UbiquityAlgorithmicDollarManager is AccessControl { using SafeERC20 for IERC20; bytes32 public constant UBQ_MINTER_ROLE = keccak256("UBQ_MINTER_ROLE"); bytes32 public constant UBQ_BURNER_ROLE = keccak256("UBQ_BURNER_ROLE"); bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE"); bytes32 public constant COUPON_MANAGER_ROLE = keccak256("COUPON_MANAGER"); bytes32 public constant BONDING_MANAGER_ROLE = keccak256("BONDING_MANAGER"); bytes32 public constant INCENTIVE_MANAGER_ROLE = keccak256("INCENTIVE_MANAGER"); bytes32 public constant UBQ_TOKEN_MANAGER_ROLE = keccak256("UBQ_TOKEN_MANAGER_ROLE"); address public twapOracleAddress; address public debtCouponAddress; address public dollarTokenAddress; // uAD address public couponCalculatorAddress; address public dollarMintingCalculatorAddress; address public bondingShareAddress; address public bondingContractAddress; address public stableSwapMetaPoolAddress; address public curve3PoolTokenAddress; // 3CRV address public treasuryAddress; address public governanceTokenAddress; // uGOV address public sushiSwapPoolAddress; // sushi pool uAD-uGOV address public masterChefAddress; address public formulasAddress; address public autoRedeemTokenAddress; // uAR address public uarCalculatorAddress; // uAR calculator //key = address of couponmanager, value = excessdollardistributor mapping(address => address) private _excessDollarDistributors; modifier onlyAdmin() { require( hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "uADMGR: Caller is not admin" ); _; } constructor(address _admin) { _setupRole(DEFAULT_ADMIN_ROLE, _admin); _setupRole(UBQ_MINTER_ROLE, _admin); _setupRole(PAUSER_ROLE, _admin); _setupRole(COUPON_MANAGER_ROLE, _admin); _setupRole(BONDING_MANAGER_ROLE, _admin); _setupRole(INCENTIVE_MANAGER_ROLE, _admin); _setupRole(UBQ_TOKEN_MANAGER_ROLE, address(this)); } // TODO Add a generic setter for extra addresses that needs to be linked function setTwapOracleAddress(address _twapOracleAddress) external onlyAdmin { twapOracleAddress = _twapOracleAddress; // to be removed TWAPOracle oracle = TWAPOracle(twapOracleAddress); oracle.update(); } function setuARTokenAddress(address _uarTokenAddress) external onlyAdmin { autoRedeemTokenAddress = _uarTokenAddress; } function setDebtCouponAddress(address _debtCouponAddress) external onlyAdmin { debtCouponAddress = _debtCouponAddress; } function setIncentiveToUAD(address _account, address _incentiveAddress) external onlyAdmin { IUbiquityAlgorithmicDollar(dollarTokenAddress).setIncentiveContract( _account, _incentiveAddress ); } function setDollarTokenAddress(address _dollarTokenAddress) external onlyAdmin { dollarTokenAddress = _dollarTokenAddress; } function setGovernanceTokenAddress(address _governanceTokenAddress) external onlyAdmin { governanceTokenAddress = _governanceTokenAddress; } function setSushiSwapPoolAddress(address _sushiSwapPoolAddress) external onlyAdmin { sushiSwapPoolAddress = _sushiSwapPoolAddress; } function setUARCalculatorAddress(address _uarCalculatorAddress) external onlyAdmin { uarCalculatorAddress = _uarCalculatorAddress; } function setCouponCalculatorAddress(address _couponCalculatorAddress) external onlyAdmin { couponCalculatorAddress = _couponCalculatorAddress; } function setDollarMintingCalculatorAddress( address _dollarMintingCalculatorAddress ) external onlyAdmin { dollarMintingCalculatorAddress = _dollarMintingCalculatorAddress; } function setExcessDollarsDistributor( address debtCouponManagerAddress, address excessCouponDistributor ) external onlyAdmin { _excessDollarDistributors[ debtCouponManagerAddress ] = excessCouponDistributor; } function setMasterChefAddress(address _masterChefAddress) external onlyAdmin { masterChefAddress = _masterChefAddress; } function setFormulasAddress(address _formulasAddress) external onlyAdmin { formulasAddress = _formulasAddress; } function setBondingShareAddress(address _bondingShareAddress) external onlyAdmin { bondingShareAddress = _bondingShareAddress; } function setStableSwapMetaPoolAddress(address _stableSwapMetaPoolAddress) external onlyAdmin { stableSwapMetaPoolAddress = _stableSwapMetaPoolAddress; } /** @notice set the bonding bontract smart contract address @dev bonding contract participants deposit curve LP token for a certain duration to earn uGOV and more curve LP token @param _bondingContractAddress bonding contract address */ function setBondingContractAddress(address _bondingContractAddress) external onlyAdmin { bondingContractAddress = _bondingContractAddress; } /** @notice set the treasury address @dev the treasury fund is used to maintain the protocol @param _treasuryAddress treasury fund address */ function setTreasuryAddress(address _treasuryAddress) external onlyAdmin { treasuryAddress = _treasuryAddress; } /** @notice deploy a new Curve metapools for uAD Token uAD/3Pool @dev From the curve documentation for uncollateralized algorithmic stablecoins amplification should be 5-10 @param _curveFactory MetaPool factory address @param _crvBasePool Address of the base pool to use within the new metapool. @param _crv3PoolTokenAddress curve 3Pool token Address @param _amplificationCoefficient amplification coefficient. The smaller it is the closer to a constant product we are. @param _fee Trade fee, given as an integer with 1e10 precision. */ function deployStableSwapPool( address _curveFactory, address _crvBasePool, address _crv3PoolTokenAddress, uint256 _amplificationCoefficient, uint256 _fee ) external onlyAdmin { // Create new StableSwap meta pool (uAD <-> 3Crv) address metaPool = ICurveFactory(_curveFactory).deploy_metapool( _crvBasePool, ERC20(dollarTokenAddress).name(), ERC20(dollarTokenAddress).symbol(), dollarTokenAddress, _amplificationCoefficient, _fee ); stableSwapMetaPoolAddress = metaPool; // Approve the newly-deployed meta pool to transfer this contract's funds uint256 crv3PoolTokenAmount = IERC20(_crv3PoolTokenAddress).balanceOf(address(this)); uint256 uADTokenAmount = IERC20(dollarTokenAddress).balanceOf(address(this)); // safe approve revert if approve from non-zero to non-zero allowance IERC20(_crv3PoolTokenAddress).safeApprove(metaPool, 0); IERC20(_crv3PoolTokenAddress).safeApprove( metaPool, crv3PoolTokenAmount ); IERC20(dollarTokenAddress).safeApprove(metaPool, 0); IERC20(dollarTokenAddress).safeApprove(metaPool, uADTokenAmount); // coin at index 0 is uAD and index 1 is 3CRV require( IMetaPool(metaPool).coins(0) == dollarTokenAddress && IMetaPool(metaPool).coins(1) == _crv3PoolTokenAddress, "uADMGR: COIN_ORDER_MISMATCH" ); // Add the initial liquidity to the StableSwap meta pool uint256[2] memory amounts = [ IERC20(dollarTokenAddress).balanceOf(address(this)), IERC20(_crv3PoolTokenAddress).balanceOf(address(this)) ]; // set curve 3Pool address curve3PoolTokenAddress = _crv3PoolTokenAddress; IMetaPool(metaPool).add_liquidity(amounts, 0, msg.sender); } function getExcessDollarsDistributor(address _debtCouponManagerAddress) external view returns (address) { return _excessDollarDistributors[_debtCouponManagerAddress]; } }
// SPDX-License-Identifier: MIT // SPDX-License-Identifier: EUPL V1.2 pragma solidity ^0.8.3; /** * @dev Wrappers over Solidity's array push operations with added check * */ library SafeAddArray { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * */ function add(bytes32[] storage array, bytes32 value) internal { for (uint256 i; i < array.length; i++) { if (array[i] == value) { return; } } array.push(value); } function add(string[] storage array, string memory value) internal { bytes32 hashValue = keccak256(bytes(value)); for (uint256 i; i < array.length; i++) { if (keccak256(bytes(array[i])) == hashValue) { return; } } array.push(value); } function add(uint256[] storage array, uint256 value) internal { for (uint256 i; i < array.length; i++) { if (array[i] == value) { return; } } array.push(value); } function add(uint256[] storage array, uint256[] memory values) internal { for (uint256 i; i < values.length; i++) { bool exist = false; for (uint256 j; j < array.length; j++) { if (array[j] == values[i]) { exist = true; break; } } if (!exist) { array.push(values[i]); } } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. * * _Available since v3.1._ */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the amount of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external; }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev _Available since v3.1._ */ interface IERC1155Receiver is IERC165 { /** @dev Handles the receipt of a single ERC1155 token type. This function is called at the end of a `safeTransferFrom` after the balance has been updated. To accept the transfer, this must return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61, or its own function selector). @param operator The address which initiated the transfer (i.e. msg.sender) @param from The address which previously owned the token @param id The ID of the token being transferred @param value The amount of tokens being transferred @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns(bytes4); /** @dev Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a `safeBatchTransferFrom` after the balances have been updated. To accept the transfer(s), this must return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81, or its own function selector). @param operator The address which initiated the batch transfer (i.e. msg.sender) @param from The address which previously owned the token @param ids An array containing ids of each token being transferred (order and length must match values array) @param values An array containing amounts of each token being transferred (order and length must match ids array) @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns(bytes4); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../IERC1155.sol"; /** * @dev Interface of the optional ERC1155MetadataExtension interface, as defined * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP]. * * _Available since v3.1._ */ interface IERC1155MetadataURI is IERC1155 { /** * @dev Returns the URI for token type `id`. * * If the `\{id\}` substring is present in the URI, it must be replaced by * clients with the actual token type ID. */ function uri(uint256 id) external view returns (string memory); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ 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"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ 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"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(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 { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor () { _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../utils/Context.sol"; import "../utils/Strings.sol"; import "../utils/introspection/ERC165.sol"; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { function hasRole(bytes32 role, address account) external view returns (bool); function getRoleAdmin(bytes32 role) external view returns (bytes32); function grantRole(bytes32 role, address account) external; function revokeRole(bytes32 role, address account) external; function renounceRole(bytes32 role, address account) external; } /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ``` * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ``` * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping (address => bool) members; bytes32 adminRole; } mapping (bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role, _msgSender()); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{20}) is missing role (0x[0-9a-f]{32})$/ */ function _checkRole(bytes32 role, address account) internal view { if(!hasRole(role, account)) { revert(string(abi.encodePacked( "AccessControl: account ", Strings.toHexString(uint160(account), 20), " is missing role ", Strings.toHexString(uint256(role), 32) ))); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { emit RoleAdminChanged(role, getRoleAdmin(role), adminRole); _roles[role].adminRole = adminRole; } function _grantRole(bytes32 role, address account) private { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } function _revokeRole(bytes32 role, address account) private { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "./IERC20.sol"; import "./extensions/IERC20Metadata.sol"; import "../../utils/Context.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20, IERC20Metadata { mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; /** * @dev Sets the values for {name} and {symbol}. * * The defaut value of {decimals} is 18. To select a different value for * {decimals} you should overload it. * * All two of these values are immutable: they can only be set once during * construction. */ constructor (string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev Returns the name of the token. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless this function is * overridden; * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual override returns (uint8) { return 18; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); uint256 currentAllowance = _allowances[sender][_msgSender()]; require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance"); _approve(sender, _msgSender(), currentAllowance - amount); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { uint256 currentAllowance = _allowances[_msgSender()][spender]; require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero"); _approve(_msgSender(), spender, currentAllowance - subtractedValue); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); uint256 senderBalance = _balances[sender]; require(senderBalance >= amount, "ERC20: transfer amount exceeds balance"); _balances[sender] = senderBalance - amount; _balances[recipient] += amount; emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply += amount; _balances[account] += amount; emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); uint256 accountBalance = _balances[account]; require(accountBalance >= amount, "ERC20: burn amount exceeds balance"); _balances[account] = accountBalance - amount; _totalSupply -= amount; emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../IERC20.sol"; import "../../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
// SPDX-License-Identifier: Apache-2.0 pragma solidity ^0.8.3; import "./IERC20Ubiquity.sol"; /// @title UAD stablecoin interface /// @author Ubiquity Algorithmic Dollar interface IUbiquityAlgorithmicDollar is IERC20Ubiquity { event IncentiveContractUpdate( address indexed _incentivized, address indexed _incentiveContract ); function setIncentiveContract(address account, address incentive) external; function incentiveContract(address account) external view returns (address); }
// SPDX-License-Identifier: MIT // !! THIS FILE WAS AUTOGENERATED BY abi-to-sol. SEE BELOW FOR SOURCE. !! pragma solidity ^0.8.3; interface ICurveFactory { event BasePoolAdded(address base_pool, address implementat); event MetaPoolDeployed( address coin, address base_pool, uint256 A, uint256 fee, address deployer ); function find_pool_for_coins(address _from, address _to) external view returns (address); function find_pool_for_coins( address _from, address _to, uint256 i ) external view returns (address); function get_n_coins(address _pool) external view returns (uint256, uint256); function get_coins(address _pool) external view returns (address[2] memory); function get_underlying_coins(address _pool) external view returns (address[8] memory); function get_decimals(address _pool) external view returns (uint256[2] memory); function get_underlying_decimals(address _pool) external view returns (uint256[8] memory); function get_rates(address _pool) external view returns (uint256[2] memory); function get_balances(address _pool) external view returns (uint256[2] memory); function get_underlying_balances(address _pool) external view returns (uint256[8] memory); function get_A(address _pool) external view returns (uint256); function get_fees(address _pool) external view returns (uint256, uint256); function get_admin_balances(address _pool) external view returns (uint256[2] memory); function get_coin_indices( address _pool, address _from, address _to ) external view returns ( int128, int128, bool ); function add_base_pool( address _base_pool, address _metapool_implementation, address _fee_receiver ) external; function deploy_metapool( address _base_pool, string memory _name, string memory _symbol, address _coin, uint256 _A, uint256 _fee ) external returns (address); function commit_transfer_ownership(address addr) external; function accept_transfer_ownership() external; function set_fee_receiver(address _base_pool, address _fee_receiver) external; function convert_fees() external returns (bool); function admin() external view returns (address); function future_admin() external view returns (address); function pool_list(uint256 arg0) external view returns (address); function pool_count() external view returns (uint256); function base_pool_list(uint256 arg0) external view returns (address); function base_pool_count() external view returns (uint256); function fee_receiver(address arg0) external view returns (address); }
// SPDX-License-Identifier: UNLICENSED // !! THIS FILE WAS AUTOGENERATED BY abi-to-sol. SEE BELOW FOR SOURCE. !! pragma solidity ^0.8.3; interface IMetaPool { event Transfer( address indexed sender, address indexed receiver, uint256 value ); event Approval( address indexed owner, address indexed spender, uint256 value ); event TokenExchange( address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought ); event TokenExchangeUnderlying( address indexed buyer, int128 sold_id, uint256 tokens_sold, int128 bought_id, uint256 tokens_bought ); event AddLiquidity( address indexed provider, uint256[2] token_amounts, uint256[2] fees, uint256 invariant, uint256 token_supply ); event RemoveLiquidity( address indexed provider, uint256[2] token_amounts, uint256[2] fees, uint256 token_supply ); event RemoveLiquidityOne( address indexed provider, uint256 token_amount, uint256 coin_amount, uint256 token_supply ); event RemoveLiquidityImbalance( address indexed provider, uint256[2] token_amounts, uint256[2] fees, uint256 invariant, uint256 token_supply ); event CommitNewAdmin(uint256 indexed deadline, address indexed admin); event NewAdmin(address indexed admin); event CommitNewFee( uint256 indexed deadline, uint256 fee, uint256 admin_fee ); event NewFee(uint256 fee, uint256 admin_fee); event RampA( uint256 old_A, uint256 new_A, uint256 initial_time, uint256 future_time ); event StopRampA(uint256 A, uint256 t); function initialize( string memory _name, string memory _symbol, address _coin, uint256 _decimals, uint256 _A, uint256 _fee, address _admin ) external; function decimals() external view returns (uint256); function transfer(address _to, uint256 _value) external returns (bool); function transferFrom( address _from, address _to, uint256 _value ) external returns (bool); function approve(address _spender, uint256 _value) external returns (bool); function get_previous_balances() external view returns (uint256[2] memory); function get_balances() external view returns (uint256[2] memory); function get_twap_balances( uint256[2] memory _first_balances, uint256[2] memory _last_balances, uint256 _time_elapsed ) external view returns (uint256[2] memory); function get_price_cumulative_last() external view returns (uint256[2] memory); function admin_fee() external view returns (uint256); function A() external view returns (uint256); function A_precise() external view returns (uint256); function get_virtual_price() external view returns (uint256); function calc_token_amount(uint256[2] memory _amounts, bool _is_deposit) external view returns (uint256); function calc_token_amount( uint256[2] memory _amounts, bool _is_deposit, bool _previous ) external view returns (uint256); function add_liquidity(uint256[2] memory _amounts, uint256 _min_mint_amount) external returns (uint256); function add_liquidity( uint256[2] memory _amounts, uint256 _min_mint_amount, address _receiver ) external returns (uint256); function get_dy( int128 i, int128 j, uint256 dx ) external view returns (uint256); function get_dy( int128 i, int128 j, uint256 dx, uint256[2] memory _balances ) external view returns (uint256); function get_dy_underlying( int128 i, int128 j, uint256 dx ) external view returns (uint256); function get_dy_underlying( int128 i, int128 j, uint256 dx, uint256[2] memory _balances ) external view returns (uint256); function exchange( int128 i, int128 j, uint256 dx, uint256 min_dy ) external returns (uint256); function exchange( int128 i, int128 j, uint256 dx, uint256 min_dy, address _receiver ) external returns (uint256); function exchange_underlying( int128 i, int128 j, uint256 dx, uint256 min_dy ) external returns (uint256); function exchange_underlying( int128 i, int128 j, uint256 dx, uint256 min_dy, address _receiver ) external returns (uint256); function remove_liquidity( uint256 _burn_amount, uint256[2] memory _min_amounts ) external returns (uint256[2] memory); function remove_liquidity( uint256 _burn_amount, uint256[2] memory _min_amounts, address _receiver ) external returns (uint256[2] memory); function remove_liquidity_imbalance( uint256[2] memory _amounts, uint256 _max_burn_amount ) external returns (uint256); function remove_liquidity_imbalance( uint256[2] memory _amounts, uint256 _max_burn_amount, address _receiver ) external returns (uint256); function calc_withdraw_one_coin(uint256 _burn_amount, int128 i) external view returns (uint256); function calc_withdraw_one_coin( uint256 _burn_amount, int128 i, bool _previous ) external view returns (uint256); function remove_liquidity_one_coin( uint256 _burn_amount, int128 i, uint256 _min_received ) external returns (uint256); function remove_liquidity_one_coin( uint256 _burn_amount, int128 i, uint256 _min_received, address _receiver ) external returns (uint256); function ramp_A(uint256 _future_A, uint256 _future_time) external; function stop_ramp_A() external; function admin_balances(uint256 i) external view returns (uint256); function withdraw_admin_fees() external; function admin() external view returns (address); function coins(uint256 arg0) external view returns (address); function balances(uint256 arg0) external view returns (uint256); function fee() external view returns (uint256); function block_timestamp_last() external view returns (uint256); function initial_A() external view returns (uint256); function future_A() external view returns (uint256); function initial_A_time() external view returns (uint256); function future_A_time() external view returns (uint256); function name() external view returns (string memory); function symbol() external view returns (string memory); function balanceOf(address arg0) external view returns (uint256); function allowance(address arg0, address arg1) external view returns (uint256); function totalSupply() external view returns (uint256); }
// SPDX-License-Identifier: Apache-2.0 pragma solidity ^0.8.3; import "./interfaces/IMetaPool.sol"; contract TWAPOracle { address public immutable pool; address public immutable token0; address public immutable token1; uint256 public price0Average; uint256 public price1Average; uint256 public pricesBlockTimestampLast; uint256[2] public priceCumulativeLast; constructor( address _pool, address _uADtoken0, address _curve3CRVtoken1 ) { pool = _pool; // coin at index 0 is uAD and index 1 is 3CRV require( IMetaPool(_pool).coins(0) == _uADtoken0 && IMetaPool(_pool).coins(1) == _curve3CRVtoken1, "TWAPOracle: COIN_ORDER_MISMATCH" ); token0 = _uADtoken0; token1 = _curve3CRVtoken1; uint256 _reserve0 = uint112(IMetaPool(_pool).balances(0)); uint256 _reserve1 = uint112(IMetaPool(_pool).balances(1)); // ensure that there's liquidity in the pair require(_reserve0 != 0 && _reserve1 != 0, "TWAPOracle: NO_RESERVES"); // ensure that pair balance is perfect require(_reserve0 == _reserve1, "TWAPOracle: PAIR_UNBALANCED"); priceCumulativeLast = IMetaPool(_pool).get_price_cumulative_last(); pricesBlockTimestampLast = IMetaPool(_pool).block_timestamp_last(); price0Average = 1 ether; price1Average = 1 ether; } // calculate average price function update() external { (uint256[2] memory priceCumulative, uint256 blockTimestamp) = _currentCumulativePrices(); if (blockTimestamp - pricesBlockTimestampLast > 0) { // get the balances between now and the last price cumulative snapshot uint256[2] memory twapBalances = IMetaPool(pool).get_twap_balances( priceCumulativeLast, priceCumulative, blockTimestamp - pricesBlockTimestampLast ); // price to exchange amounIn uAD to 3CRV based on TWAP price0Average = IMetaPool(pool).get_dy(0, 1, 1 ether, twapBalances); // price to exchange amounIn 3CRV to uAD based on TWAP price1Average = IMetaPool(pool).get_dy(1, 0, 1 ether, twapBalances); // we update the priceCumulative priceCumulativeLast = priceCumulative; pricesBlockTimestampLast = blockTimestamp; } } // note this will always return 0 before update has been called successfully // for the first time. function consult(address token) external view returns (uint256 amountOut) { if (token == token0) { // price to exchange 1 uAD to 3CRV based on TWAP amountOut = price0Average; } else { require(token == token1, "TWAPOracle: INVALID_TOKEN"); // price to exchange 1 3CRV to uAD based on TWAP amountOut = price1Average; } } function _currentCumulativePrices() internal view returns (uint256[2] memory priceCumulative, uint256 blockTimestamp) { priceCumulative = IMetaPool(pool).get_price_cumulative_last(); blockTimestamp = IMetaPool(pool).block_timestamp_last(); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant alphabet = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = alphabet[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } }
// SPDX-License-Identifier: MIT pragma solidity ^0.8.0; import "../IERC20.sol"; /** * @dev Interface for the optional metadata functions from the ERC20 standard. * * _Available since v4.1._ */ interface IERC20Metadata is IERC20 { /** * @dev Returns the name of the token. */ function name() external view returns (string memory); /** * @dev Returns the symbol of the token. */ function symbol() external view returns (string memory); /** * @dev Returns the decimals places of the token. */ function decimals() external view returns (uint8); }
// SPDX-License-Identifier: Apache-2.0 pragma solidity ^0.8.3; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; /// @title ERC20 Ubiquiti preset interface /// @author Ubiquity Algorithmic Dollar interface IERC20Ubiquity is IERC20 { // ----------- Events ----------- event Minting( address indexed _to, address indexed _minter, uint256 _amount ); event Burning(address indexed _burned, uint256 _amount); // ----------- State changing api ----------- function burn(uint256 amount) external; function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; // ----------- Burner only state changing api ----------- function burnFrom(address account, uint256 amount) external; // ----------- Minter only state changing api ----------- function mint(address account, uint256 amount) external; }
{ "optimizer": { "enabled": true, "runs": 800 }, "metadata": { "bytecodeHash": "none", "useLiteralContent": true }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "libraries": {} }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_manager","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"burnBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"}],"name":"holderTokens","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"manager","outputs":[{"internalType":"contract UbiquityAlgorithmicDollarManager","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"mintBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000004da97a8b831c345dbe6d16ff7432df2b7b776d98
-----Decoded View---------------
Arg [0] : _manager (address): 0x4DA97a8b831C345dBe6d16FF7432DF2b7b776d98
-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000004da97a8b831c345dbe6d16ff7432df2b7b776d98
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.