$GARET · ROBINHOOD CHAIN · CHAIN ID 4663 · PonsV2LauncherToken
CONTRACT SOURCE CODE
Fixed-supply ERC-20 created through the Pons v2 launch factory on Robinhood Chain. The whole supply was minted once to the token's bonding curve. OpenZeppelin ERC20 + ERC20Burnable: holders may burn their own tokens; there is no owner, no tax, no blacklist, no pause and no further minting. The deployer field is attribution data only and grants no privileges.
- CONTRACT ADDRESS
- 0x7df21dd9273903800015DE79B514C66621704677
- COMPILER
- solc 0.8.35+commit.47b9dedd
- SETTINGS
- optimizer on · 200 runs · EVM cancun · via-IR
- RUNTIME BYTECODE
- 3248 bytes
- KECCAK256 OF RUNTIME BYTECODE
- 0x456ed0b1568cd1226ea6d760232727faeadb6458dcdc3e7d545bd82e696e00ac
Created through a launch factory (0x7eD598BcEf8bd9Edd8C97A195C6d13f40801EC7e). The token source is the factory's verified launcher token; the hash below is the runtime bytecode recorded when the source was verified on Sourcify (exact_match).
SOURCE FILES
7 files. The first is the token itself; the rest are the unmodified OpenZeppelin Contracts it imports.
contracts/src/v2/PonsV2LauncherToken.sol107 lines
1// SPDX-License-Identifier: MIT2pragma solidity ^0.8.26;34import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";5import {ERC20Burnable} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";67/**8 * @title PonsV2LauncherToken9 * @notice Fixed-supply ERC-20 deployed by PonsV2LaunchFactory for a v2 launch.10 * The entire supply mints directly to the token's bonding curve instead of a11 * Uniswap position. Anyone, the deployer included, may buy any amount from12 * the curve at any time; the curve's own price impact and its reserved pool13 * allocation are the only limits on a large buy. `deployer` is carried here14 * as immutable reference data for off-chain attribution only, and confers no15 * privileges over the token.16 * `ERC20Burnable` lets any holder voluntarily burn their own balance; the17 * protocol's buyback mechanism does not use it, bought-back tokens are18 * locked into `PonsV2BuybackVault` for a five-year vest instead of being19 * burned.20 */21contract PonsV2LauncherToken is ERC20, ERC20Burnable {22 struct Socials {23 string twitter;24 string telegram;25 string discord;26 string website;27 string farcaster;28 }2930 error ZeroAddress();3132 address public immutable deployer;33 address public immutable launchFactory;34 address public immutable curve;3536 string public logo;37 string public description;3839 Socials private _socials;4041 /**42 * @notice Creates a v2 launch token and mints its entire supply to the bonding curve.43 */44 constructor(45 string memory name_,46 string memory symbol_,47 string memory logo_,48 string memory description_,49 Socials memory socials_,50 address deployer_,51 address curve_,52 address launchFactory_,53 uint256 supply_54 ) ERC20(name_, symbol_) {55 if (deployer_ == address(0) || curve_ == address(0) || launchFactory_ == address(0)) {56 revert ZeroAddress();57 }5859 deployer = deployer_;60 // Passed explicitly rather than read from msg.sender: PonsV2LaunchFactory61 // deploys this token indirectly through PonsV2LaunchDeployer to keep its62 // own bytecode under EIP-170's size limit, so msg.sender at construction63 // time would otherwise resolve to that deployer helper, not the factory.64 launchFactory = launchFactory_;65 curve = curve_;66 logo = logo_;67 description = description_;68 _socials = socials_;6970 _mint(curve_, supply_);71 }7273 /**74 * @notice Returns the launch token's five social metadata fields.75 */76 function socials()77 external78 view79 returns (80 string memory twitter,81 string memory telegram,82 string memory discord,83 string memory website,84 string memory farcaster85 )86 {87 Socials memory values = _socials;88 return (values.twitter, values.telegram, values.discord, values.website, values.farcaster);89 }9091 /**92 * @notice Returns creator and metadata in the launcher-compatible tuple.93 */94 function getTokenInfo()95 external96 view97 returns (98 address tokenDeployer,99 string memory tokenLogo,100 string memory tokenDescription,101 Socials memory tokenSocials102 )103 {104 return (deployer, logo, description, _socials);105 }106}107contracts/lib/openzeppelin-contracts/contracts/interfaces/draft-IERC6093.sol163 lines
1// SPDX-License-Identifier: MIT2// OpenZeppelin Contracts (last updated v5.5.0) (interfaces/draft-IERC6093.sol)34pragma solidity >=0.8.4;56/**7 * @dev Standard ERC-20 Errors8 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.9 */10interface IERC20Errors {11 /**12 * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.13 * @param sender Address whose tokens are being transferred.14 * @param balance Current balance for the interacting account.15 * @param needed Minimum amount required to perform a transfer.16 */17 error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);1819 /**20 * @dev Indicates a failure with the token `sender`. Used in transfers.21 * @param sender Address whose tokens are being transferred.22 */23 error ERC20InvalidSender(address sender);2425 /**26 * @dev Indicates a failure with the token `receiver`. Used in transfers.27 * @param receiver Address to which tokens are being transferred.28 */29 error ERC20InvalidReceiver(address receiver);3031 /**32 * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.33 * @param spender Address that may be allowed to operate on tokens without being their owner.34 * @param allowance Amount of tokens a `spender` is allowed to operate with.35 * @param needed Minimum amount required to perform a transfer.36 */37 error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);3839 /**40 * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.41 * @param approver Address initiating an approval operation.42 */43 error ERC20InvalidApprover(address approver);4445 /**46 * @dev Indicates a failure with the `spender` to be approved. Used in approvals.47 * @param spender Address that may be allowed to operate on tokens without being their owner.48 */49 error ERC20InvalidSpender(address spender);50}5152/**53 * @dev Standard ERC-721 Errors54 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.55 */56interface IERC721Errors {57 /**58 * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-721.59 * Used in balance queries.60 * @param owner Address of the current owner of a token.61 */62 error ERC721InvalidOwner(address owner);6364 /**65 * @dev Indicates a `tokenId` whose `owner` is the zero address.66 * @param tokenId Identifier number of a token.67 */68 error ERC721NonexistentToken(uint256 tokenId);6970 /**71 * @dev Indicates an error related to the ownership over a particular token. Used in transfers.72 * @param sender Address whose tokens are being transferred.73 * @param tokenId Identifier number of a token.74 * @param owner Address of the current owner of a token.75 */76 error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);7778 /**79 * @dev Indicates a failure with the token `sender`. Used in transfers.80 * @param sender Address whose tokens are being transferred.81 */82 error ERC721InvalidSender(address sender);8384 /**85 * @dev Indicates a failure with the token `receiver`. Used in transfers.86 * @param receiver Address to which tokens are being transferred.87 */88 error ERC721InvalidReceiver(address receiver);8990 /**91 * @dev Indicates a failure with the `operator`’s approval. Used in transfers.92 * @param operator Address that may be allowed to operate on tokens without being their owner.93 * @param tokenId Identifier number of a token.94 */95 error ERC721InsufficientApproval(address operator, uint256 tokenId);9697 /**98 * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.99 * @param approver Address initiating an approval operation.100 */101 error ERC721InvalidApprover(address approver);102103 /**104 * @dev Indicates a failure with the `operator` to be approved. Used in approvals.105 * @param operator Address that may be allowed to operate on tokens without being their owner.106 */107 error ERC721InvalidOperator(address operator);108}109110/**111 * @dev Standard ERC-1155 Errors112 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.113 */114interface IERC1155Errors {115 /**116 * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.117 * @param sender Address whose tokens are being transferred.118 * @param balance Current balance for the interacting account.119 * @param needed Minimum amount required to perform a transfer.120 * @param tokenId Identifier number of a token.121 */122 error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);123124 /**125 * @dev Indicates a failure with the token `sender`. Used in transfers.126 * @param sender Address whose tokens are being transferred.127 */128 error ERC1155InvalidSender(address sender);129130 /**131 * @dev Indicates a failure with the token `receiver`. Used in transfers.132 * @param receiver Address to which tokens are being transferred.133 */134 error ERC1155InvalidReceiver(address receiver);135136 /**137 * @dev Indicates a failure with the `operator`’s approval. Used in transfers.138 * @param operator Address that may be allowed to operate on tokens without being their owner.139 * @param owner Address of the current owner of a token.140 */141 error ERC1155MissingApprovalForAll(address operator, address owner);142143 /**144 * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.145 * @param approver Address initiating an approval operation.146 */147 error ERC1155InvalidApprover(address approver);148149 /**150 * @dev Indicates a failure with the `operator` to be approved. Used in approvals.151 * @param operator Address that may be allowed to operate on tokens without being their owner.152 */153 error ERC1155InvalidOperator(address operator);154155 /**156 * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.157 * Used in batch transfers.158 * @param idsLength Length of the array of token identifiers159 * @param valuesLength Length of the array of token amounts160 */161 error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);162}163contracts/lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol306 lines
1// SPDX-License-Identifier: MIT2// OpenZeppelin Contracts (last updated v5.5.0) (token/ERC20/ERC20.sol)34pragma solidity ^0.8.20;56import {IERC20} from "./IERC20.sol";7import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";8import {Context} from "../../utils/Context.sol";9import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";1011/**12 * @dev Implementation of the {IERC20} interface.13 *14 * This implementation is agnostic to the way tokens are created. This means15 * that a supply mechanism has to be added in a derived contract using {_mint}.16 *17 * TIP: For a detailed writeup see our guide18 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How19 * to implement supply mechanisms].20 *21 * The default value of {decimals} is 18. To change this, you should override22 * this function so it returns a different value.23 *24 * We have followed general OpenZeppelin Contracts guidelines: functions revert25 * instead returning `false` on failure. This behavior is nonetheless26 * conventional and does not conflict with the expectations of ERC-2027 * applications.28 */29abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {30 mapping(address account => uint256) private _balances;3132 mapping(address account => mapping(address spender => uint256)) private _allowances;3334 uint256 private _totalSupply;3536 string private _name;37 string private _symbol;3839 /**40 * @dev Sets the values for {name} and {symbol}.41 *42 * Both values are immutable: they can only be set once during construction.43 */44 constructor(string memory name_, string memory symbol_) {45 _name = name_;46 _symbol = symbol_;47 }4849 /**50 * @dev Returns the name of the token.51 */52 function name() public view virtual returns (string memory) {53 return _name;54 }5556 /**57 * @dev Returns the symbol of the token, usually a shorter version of the58 * name.59 */60 function symbol() public view virtual returns (string memory) {61 return _symbol;62 }6364 /**65 * @dev Returns the number of decimals used to get its user representation.66 * For example, if `decimals` equals `2`, a balance of `505` tokens should67 * be displayed to a user as `5.05` (`505 / 10 ** 2`).68 *69 * Tokens usually opt for a value of 18, imitating the relationship between70 * Ether and Wei. This is the default value returned by this function, unless71 * it's overridden.72 *73 * NOTE: This information is only used for _display_ purposes: it in74 * no way affects any of the arithmetic of the contract, including75 * {IERC20-balanceOf} and {IERC20-transfer}.76 */77 function decimals() public view virtual returns (uint8) {78 return 18;79 }8081 /// @inheritdoc IERC2082 function totalSupply() public view virtual returns (uint256) {83 return _totalSupply;84 }8586 /// @inheritdoc IERC2087 function balanceOf(address account) public view virtual returns (uint256) {88 return _balances[account];89 }9091 /**92 * @dev See {IERC20-transfer}.93 *94 * Requirements:95 *96 * - `to` cannot be the zero address.97 * - the caller must have a balance of at least `value`.98 */99 function transfer(address to, uint256 value) public virtual returns (bool) {100 address owner = _msgSender();101 _transfer(owner, to, value);102 return true;103 }104105 /// @inheritdoc IERC20106 function allowance(address owner, address spender) public view virtual returns (uint256) {107 return _allowances[owner][spender];108 }109110 /**111 * @dev See {IERC20-approve}.112 *113 * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on114 * `transferFrom`. This is semantically equivalent to an infinite approval.115 *116 * Requirements:117 *118 * - `spender` cannot be the zero address.119 */120 function approve(address spender, uint256 value) public virtual returns (bool) {121 address owner = _msgSender();122 _approve(owner, spender, value);123 return true;124 }125126 /**127 * @dev See {IERC20-transferFrom}.128 *129 * Skips emitting an {Approval} event indicating an allowance update. This is not130 * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].131 *132 * NOTE: Does not update the allowance if the current allowance133 * is the maximum `uint256`.134 *135 * Requirements:136 *137 * - `from` and `to` cannot be the zero address.138 * - `from` must have a balance of at least `value`.139 * - the caller must have allowance for ``from``'s tokens of at least140 * `value`.141 */142 function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {143 address spender = _msgSender();144 _spendAllowance(from, spender, value);145 _transfer(from, to, value);146 return true;147 }148149 /**150 * @dev Moves a `value` amount of tokens from `from` to `to`.151 *152 * This internal function is equivalent to {transfer}, and can be used to153 * e.g. implement automatic token fees, slashing mechanisms, etc.154 *155 * Emits a {Transfer} event.156 *157 * NOTE: This function is not virtual, {_update} should be overridden instead.158 */159 function _transfer(address from, address to, uint256 value) internal {160 if (from == address(0)) {161 revert ERC20InvalidSender(address(0));162 }163 if (to == address(0)) {164 revert ERC20InvalidReceiver(address(0));165 }166 _update(from, to, value);167 }168169 /**170 * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`171 * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding172 * this function.173 *174 * Emits a {Transfer} event.175 */176 function _update(address from, address to, uint256 value) internal virtual {177 if (from == address(0)) {178 // Overflow check required: The rest of the code assumes that totalSupply never overflows179 _totalSupply += value;180 } else {181 uint256 fromBalance = _balances[from];182 if (fromBalance < value) {183 revert ERC20InsufficientBalance(from, fromBalance, value);184 }185 unchecked {186 // Overflow not possible: value <= fromBalance <= totalSupply.187 _balances[from] = fromBalance - value;188 }189 }190191 if (to == address(0)) {192 unchecked {193 // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.194 _totalSupply -= value;195 }196 } else {197 unchecked {198 // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.199 _balances[to] += value;200 }201 }202203 emit Transfer(from, to, value);204 }205206 /**207 * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).208 * Relies on the `_update` mechanism209 *210 * Emits a {Transfer} event with `from` set to the zero address.211 *212 * NOTE: This function is not virtual, {_update} should be overridden instead.213 */214 function _mint(address account, uint256 value) internal {215 if (account == address(0)) {216 revert ERC20InvalidReceiver(address(0));217 }218 _update(address(0), account, value);219 }220221 /**222 * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.223 * Relies on the `_update` mechanism.224 *225 * Emits a {Transfer} event with `to` set to the zero address.226 *227 * NOTE: This function is not virtual, {_update} should be overridden instead228 */229 function _burn(address account, uint256 value) internal {230 if (account == address(0)) {231 revert ERC20InvalidSender(address(0));232 }233 _update(account, address(0), value);234 }235236 /**237 * @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens.238 *239 * This internal function is equivalent to `approve`, and can be used to240 * e.g. set automatic allowances for certain subsystems, etc.241 *242 * Emits an {Approval} event.243 *244 * Requirements:245 *246 * - `owner` cannot be the zero address.247 * - `spender` cannot be the zero address.248 *249 * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.250 */251 function _approve(address owner, address spender, uint256 value) internal {252 _approve(owner, spender, value, true);253 }254255 /**256 * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.257 *258 * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by259 * `_spendAllowance` during the `transferFrom` operation sets the flag to false. This saves gas by not emitting any260 * `Approval` event during `transferFrom` operations.261 *262 * Anyone who wishes to continue emitting `Approval` events on the `transferFrom` operation can force the flag to263 * true using the following override:264 *265 * ```solidity266 * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {267 * super._approve(owner, spender, value, true);268 * }269 * ```270 *271 * Requirements are the same as {_approve}.272 */273 function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {274 if (owner == address(0)) {275 revert ERC20InvalidApprover(address(0));276 }277 if (spender == address(0)) {278 revert ERC20InvalidSpender(address(0));279 }280 _allowances[owner][spender] = value;281 if (emitEvent) {282 emit Approval(owner, spender, value);283 }284 }285286 /**287 * @dev Updates `owner`'s allowance for `spender` based on spent `value`.288 *289 * Does not update the allowance value in case of infinite allowance.290 * Revert if not enough allowance is available.291 *292 * Does not emit an {Approval} event.293 */294 function _spendAllowance(address owner, address spender, uint256 value) internal virtual {295 uint256 currentAllowance = allowance(owner, spender);296 if (currentAllowance < type(uint256).max) {297 if (currentAllowance < value) {298 revert ERC20InsufficientAllowance(spender, currentAllowance, value);299 }300 unchecked {301 _approve(owner, spender, currentAllowance - value, false);302 }303 }304 }305}306contracts/lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol80 lines
1// SPDX-License-Identifier: MIT2// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/IERC20.sol)34pragma solidity >=0.4.16;56/**7 * @dev Interface of the ERC-20 standard as defined in the ERC.8 */9interface IERC20 {10 /**11 * @dev Emitted when `value` tokens are moved from one account (`from`) to12 * another (`to`).13 *14 * Note that `value` may be zero.15 */16 event Transfer(address indexed from, address indexed to, uint256 value);1718 /**19 * @dev Emitted when the allowance of a `spender` for an `owner` is set by20 * a call to {approve}. `value` is the new allowance.21 */22 event Approval(address indexed owner, address indexed spender, uint256 value);2324 /**25 * @dev Returns the value of tokens in existence.26 */27 function totalSupply() external view returns (uint256);2829 /**30 * @dev Returns the value of tokens owned by `account`.31 */32 function balanceOf(address account) external view returns (uint256);3334 /**35 * @dev Moves a `value` amount of tokens from the caller's account to `to`.36 *37 * Returns a boolean value indicating whether the operation succeeded.38 *39 * Emits a {Transfer} event.40 */41 function transfer(address to, uint256 value) external returns (bool);4243 /**44 * @dev Returns the remaining number of tokens that `spender` will be45 * allowed to spend on behalf of `owner` through {transferFrom}. This is46 * zero by default.47 *48 * This value changes when {approve} or {transferFrom} are called.49 */50 function allowance(address owner, address spender) external view returns (uint256);5152 /**53 * @dev Sets a `value` amount of tokens as the allowance of `spender` over the54 * caller's tokens.55 *56 * Returns a boolean value indicating whether the operation succeeded.57 *58 * IMPORTANT: Beware that changing an allowance with this method brings the risk59 * that someone may use both the old and the new allowance by unfortunate60 * transaction ordering. One possible solution to mitigate this race61 * condition is to first reduce the spender's allowance to 0 and set the62 * desired value afterwards:63 * https://github.com/ethereum/EIPs/issues/20#issuecomment-26352472964 *65 * Emits an {Approval} event.66 */67 function approve(address spender, uint256 value) external returns (bool);6869 /**70 * @dev Moves a `value` amount of tokens from `from` to `to` using the71 * allowance mechanism. `value` is then deducted from the caller's72 * allowance.73 *74 * Returns a boolean value indicating whether the operation succeeded.75 *76 * Emits a {Transfer} event.77 */78 function transferFrom(address from, address to, uint256 value) external returns (bool);79}80contracts/lib/openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Burnable.sol40 lines
1// SPDX-License-Identifier: MIT2// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol)34pragma solidity ^0.8.20;56import {ERC20} from "../ERC20.sol";7import {Context} from "../../../utils/Context.sol";89/**10 * @dev Extension of {ERC20} that allows token holders to destroy both their own11 * tokens and those that they have an allowance for, in a way that can be12 * recognized off-chain (via event analysis).13 */14abstract contract ERC20Burnable is Context, ERC20 {15 /**16 * @dev Destroys a `value` amount of tokens from the caller.17 *18 * See {ERC20-_burn}.19 */20 function burn(uint256 value) public virtual {21 _burn(_msgSender(), value);22 }2324 /**25 * @dev Destroys a `value` amount of tokens from `account`, deducting from26 * the caller's allowance.27 *28 * See {ERC20-_burn} and {ERC20-allowance}.29 *30 * Requirements:31 *32 * - the caller must have allowance for ``accounts``'s tokens of at least33 * `value`.34 */35 function burnFrom(address account, uint256 value) public virtual {36 _spendAllowance(account, _msgSender(), value);37 _burn(account, value);38 }39}40contracts/lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol27 lines
1// SPDX-License-Identifier: MIT2// OpenZeppelin Contracts (last updated v5.4.0) (token/ERC20/extensions/IERC20Metadata.sol)34pragma solidity >=0.6.2;56import {IERC20} from "../IERC20.sol";78/**9 * @dev Interface for the optional metadata functions from the ERC-20 standard.10 */11interface IERC20Metadata is IERC20 {12 /**13 * @dev Returns the name of the token.14 */15 function name() external view returns (string memory);1617 /**18 * @dev Returns the symbol of the token.19 */20 function symbol() external view returns (string memory);2122 /**23 * @dev Returns the decimals places of the token.24 */25 function decimals() external view returns (uint8);26}27contracts/lib/openzeppelin-contracts/contracts/utils/Context.sol29 lines
1// SPDX-License-Identifier: MIT2// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)34pragma solidity ^0.8.20;56/**7 * @dev Provides information about the current execution context, including the8 * sender of the transaction and its data. While these are generally available9 * via msg.sender and msg.data, they should not be accessed in such a direct10 * manner, since when dealing with meta-transactions the account sending and11 * paying for execution may not be the actual sender (as far as an application12 * is concerned).13 *14 * This contract is only required for intermediate, library-like contracts.15 */16abstract contract Context {17 function _msgSender() internal view virtual returns (address) {18 return msg.sender;19 }2021 function _msgData() internal view virtual returns (bytes calldata) {22 return msg.data;23 }2425 function _contextSuffixLength() internal view virtual returns (uint256) {26 return 0;27 }28}29