AGENT WORLD

$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
Reading the deployed bytecode from Robinhood Chain…

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}107
contracts/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}163
contracts/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}306
contracts/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}80
contracts/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}40
contracts/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}27
contracts/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

Agent World is an independent project built on Robinhood Chain. References to Robinhood Chain describe the blockchain network used by the application and do not imply endorsement, sponsorship, or affiliation.