|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.0; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
abstract contract Proxy { |
|
|
|
|
|
|
|
|
|
|
|
function _delegate(address implementation) internal virtual { |
|
assembly { |
|
|
|
|
|
|
|
calldatacopy(0, 0, calldatasize()) |
|
|
|
|
|
|
|
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0) |
|
|
|
// Copy the returned data. |
|
returndatacopy(0, 0, returndatasize()) |
|
|
|
switch result |
|
// delegatecall returns 0 on error. |
|
case 0 { |
|
revert(0, returndatasize()) |
|
} |
|
default { |
|
return(0, returndatasize()) |
|
} |
|
} |
|
} |
|
|
|
|
|
|
|
|
|
|
|
function _implementation() internal view virtual returns (address); |
|
|
|
|
|
|
|
|
|
|
|
|
|
function _fallback() internal virtual { |
|
_beforeFallback(); |
|
_delegate(_implementation()); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
fallback() external payable virtual { |
|
_fallback(); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
receive() external payable virtual { |
|
_fallback(); |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function _beforeFallback() internal virtual {} |
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.8.0; |
|
|
|
|
|
|
|
|
|
library Address { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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"); |
|
} |
|
|
|
/** |
|
* @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"); |
|
|
|
(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"); |
|
|
|
(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"); |
|
|
|
(bool success, bytes memory returndata) = target.delegatecall(data); |
|
return verifyCallResult(success, returndata, errorMessage); |
|
} |
|
|
|
/** |
|
* @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the |
|
* revert reason using the provided one. |
|
* |
|
* _Available since v4.3._ |
|
*/ |
|
function verifyCallResult( |
|
bool success, |
|
bytes memory returndata, |
|
string memory errorMessage |
|
) internal 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 |
|
|
|
assembly { |
|
let returndata_size := mload(returndata) |
|
revert(add(32, returndata), returndata_size) |
|
} |
|
} else { |
|
revert(errorMessage); |
|
} |
|
} |
|
} |
|
} |
|
|
|
|
|
// File @openzeppelin/contracts/utils/[email protected] |
|
|
|
// OpenZeppelin Contracts v4.4.1 (utils/StorageSlot.sol) |
|
|
|
pragma solidity ^0.8.0; |
|
|
|
/** |
|
* @dev Library for reading and writing primitive types to specific storage slots. |
|
* |
|
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts. |
|
* This library helps with reading and writing to such slots without the need for inline assembly. |
|
* |
|
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write. |
|
* |
|
* Example usage to set ERC1967 implementation slot: |
|
* ``` |
|
* contract ERC1967 { |
|
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; |
|
* |
|
* function _getImplementation() internal view returns (address) { |
|
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; |
|
* } |
|
* |
|
* function _setImplementation(address newImplementation) internal { |
|
* require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract"); |
|
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation; |
|
* } |
|
* } |
|
* ``` |
|
* |
|
* _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._ |
|
*/ |
|
library StorageSlot { |
|
struct AddressSlot { |
|
address value; |
|
} |
|
|
|
struct BooleanSlot { |
|
bool value; |
|
} |
|
|
|
struct Bytes32Slot { |
|
bytes32 value; |
|
} |
|
|
|
struct Uint256Slot { |
|
uint256 value; |
|
} |
|
|
|
/** |
|
* @dev Returns an `AddressSlot` with member `value` located at `slot`. |
|
*/ |
|
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) { |
|
assembly { |
|
r.slot := slot |
|
} |
|
} |
|
|
|
/** |
|
* @dev Returns an `BooleanSlot` with member `value` located at `slot`. |
|
*/ |
|
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) { |
|
assembly { |
|
r.slot := slot |
|
} |
|
} |
|
|
|
/** |
|
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`. |
|
*/ |
|
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) { |
|
assembly { |
|
r.slot := slot |
|
} |
|
} |
|
|
|
/** |
|
* @dev Returns an `Uint256Slot` with member `value` located at `slot`. |
|
*/ |
|
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) { |
|
assembly { |
|
r.slot := slot |
|
} |
|
} |
|
} |
|
|
|
|
|
// File contracts/SocialDysfunctionEdicionNegra.sol |
|
|
|
pragma solidity ^0.8.4; |
|
|
|
|
|
|
|
contract ERC721ContractWrapper is Proxy { |
|
address internal constant _IMPLEMENTATION_ADDRESS = 0xea690f45047F6be5E513D35b44933999866C5aA6; |
|
bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc; |
|
|
|
constructor( |
|
string memory _name, |
|
string memory _symbol, |
|
uint256 _totalSupply, |
|
uint256 _commission |
|
) { |
|
assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1)); |
|
StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = _IMPLEMENTATION_ADDRESS; |
|
Address.functionDelegateCall( |
|
_IMPLEMENTATION_ADDRESS, |
|
abi.encodeWithSignature("initialize(string,string,uint256,uint256)", _name, _symbol, _totalSupply, _commission) |
|
); |
|
} |
|
|
|
/** |
|
* @dev Returns the current implementation address. |
|
*/ |
|
function implementation() public view returns (address) { |
|
return _implementation(); |
|
} |
|
|
|
function _implementation() internal override view returns (address) { |
|
return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value; |
|
} |
|
} |
|
|
|
|
|
/// |
|
/// This contract was generated by https://nft-generator.art/ |
|
/// |
|
contract SocialDysfunctionEdicionNegra is ERC721ContractWrapper { |
|
constructor( |
|
string memory _name, |
|
string memory _symbol, |
|
uint256 _totalSupply, |
|
uint256 _commission |
|
) ERC721ContractWrapper(_name,_symbol,_totalSupply,_commission) {} |
|
} |
|
|