$GARET · ROBINHOOD CHAIN · CHAIN ID 4663
CONTRACT SOURCE CODE
The complete Solidity source of the $GARET token, exactly as compiled and deployed. It is an OpenZeppelin ERC-20 with a fixed supply minted once in the constructor: no owner, no taxes, no blacklist, no pause, no hidden mint and no transfer restrictions.
The $GARET contract is not configured yet. The reference source below is what will be deployed.
SOURCE FILES
6 files. The first is the token itself; the rest are the unmodified OpenZeppelin Contracts it imports.
contracts/GaretToken.sol28 lines
1// SPDX-License-Identifier: MIT2pragma solidity ^0.8.24;34import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";56/**7 * @title GaretToken ($GARET)8 * @notice Reference ERC-20 for Agent World development and testnet demos.9 *10 * Deliberately plain:11 * - no taxes, fees or transfer restrictions12 * - no owner, no blacklist, no pause, no hidden mint13 * - fixed supply minted once to the deployer-chosen recipient in the constructor14 *15 * The supply is an explicit constructor argument so nothing is hidden. This contract16 * is NOT deployed automatically by the website build. See contracts/README.md.17 */18contract GaretToken is ERC20 {19 /**20 * @param recipient Address that receives the entire initial supply.21 * @param initialSupply Whole-token supply (18 decimals are applied here), e.g. 1_000_000_000.22 */23 constructor(address recipient, uint256 initialSupply) ERC20("Garet", "GARET") {24 require(recipient != address(0), "GARET: zero recipient");25 _mint(recipient, initialSupply * 10 ** decimals());26 }27}28@openzeppelin/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@openzeppelin/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@openzeppelin/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@openzeppelin/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@openzeppelin/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}29ABI
GaretToken ABI (18 entries)
1[2 {3 "inputs": [4 {5 "internalType": "address",6 "name": "recipient",7 "type": "address"8 },9 {10 "internalType": "uint256",11 "name": "initialSupply",12 "type": "uint256"13 }14 ],15 "stateMutability": "nonpayable",16 "type": "constructor"17 },18 {19 "inputs": [20 {21 "internalType": "address",22 "name": "spender",23 "type": "address"24 },25 {26 "internalType": "uint256",27 "name": "allowance",28 "type": "uint256"29 },30 {31 "internalType": "uint256",32 "name": "needed",33 "type": "uint256"34 }35 ],36 "name": "ERC20InsufficientAllowance",37 "type": "error"38 },39 {40 "inputs": [41 {42 "internalType": "address",43 "name": "sender",44 "type": "address"45 },46 {47 "internalType": "uint256",48 "name": "balance",49 "type": "uint256"50 },51 {52 "internalType": "uint256",53 "name": "needed",54 "type": "uint256"55 }56 ],57 "name": "ERC20InsufficientBalance",58 "type": "error"59 },60 {61 "inputs": [62 {63 "internalType": "address",64 "name": "approver",65 "type": "address"66 }67 ],68 "name": "ERC20InvalidApprover",69 "type": "error"70 },71 {72 "inputs": [73 {74 "internalType": "address",75 "name": "receiver",76 "type": "address"77 }78 ],79 "name": "ERC20InvalidReceiver",80 "type": "error"81 },82 {83 "inputs": [84 {85 "internalType": "address",86 "name": "sender",87 "type": "address"88 }89 ],90 "name": "ERC20InvalidSender",91 "type": "error"92 },93 {94 "inputs": [95 {96 "internalType": "address",97 "name": "spender",98 "type": "address"99 }100 ],101 "name": "ERC20InvalidSpender",102 "type": "error"103 },104 {105 "anonymous": false,106 "inputs": [107 {108 "indexed": true,109 "internalType": "address",110 "name": "owner",111 "type": "address"112 },113 {114 "indexed": true,115 "internalType": "address",116 "name": "spender",117 "type": "address"118 },119 {120 "indexed": false,121 "internalType": "uint256",122 "name": "value",123 "type": "uint256"124 }125 ],126 "name": "Approval",127 "type": "event"128 },129 {130 "anonymous": false,131 "inputs": [132 {133 "indexed": true,134 "internalType": "address",135 "name": "from",136 "type": "address"137 },138 {139 "indexed": true,140 "internalType": "address",141 "name": "to",142 "type": "address"143 },144 {145 "indexed": false,146 "internalType": "uint256",147 "name": "value",148 "type": "uint256"149 }150 ],151 "name": "Transfer",152 "type": "event"153 },154 {155 "inputs": [156 {157 "internalType": "address",158 "name": "owner",159 "type": "address"160 },161 {162 "internalType": "address",163 "name": "spender",164 "type": "address"165 }166 ],167 "name": "allowance",168 "outputs": [169 {170 "internalType": "uint256",171 "name": "",172 "type": "uint256"173 }174 ],175 "stateMutability": "view",176 "type": "function"177 },178 {179 "inputs": [180 {181 "internalType": "address",182 "name": "spender",183 "type": "address"184 },185 {186 "internalType": "uint256",187 "name": "value",188 "type": "uint256"189 }190 ],191 "name": "approve",192 "outputs": [193 {194 "internalType": "bool",195 "name": "",196 "type": "bool"197 }198 ],199 "stateMutability": "nonpayable",200 "type": "function"201 },202 {203 "inputs": [204 {205 "internalType": "address",206 "name": "account",207 "type": "address"208 }209 ],210 "name": "balanceOf",211 "outputs": [212 {213 "internalType": "uint256",214 "name": "",215 "type": "uint256"216 }217 ],218 "stateMutability": "view",219 "type": "function"220 },221 {222 "inputs": [],223 "name": "decimals",224 "outputs": [225 {226 "internalType": "uint8",227 "name": "",228 "type": "uint8"229 }230 ],231 "stateMutability": "view",232 "type": "function"233 },234 {235 "inputs": [],236 "name": "name",237 "outputs": [238 {239 "internalType": "string",240 "name": "",241 "type": "string"242 }243 ],244 "stateMutability": "view",245 "type": "function"246 },247 {248 "inputs": [],249 "name": "symbol",250 "outputs": [251 {252 "internalType": "string",253 "name": "",254 "type": "string"255 }256 ],257 "stateMutability": "view",258 "type": "function"259 },260 {261 "inputs": [],262 "name": "totalSupply",263 "outputs": [264 {265 "internalType": "uint256",266 "name": "",267 "type": "uint256"268 }269 ],270 "stateMutability": "view",271 "type": "function"272 },273 {274 "inputs": [275 {276 "internalType": "address",277 "name": "to",278 "type": "address"279 },280 {281 "internalType": "uint256",282 "name": "value",283 "type": "uint256"284 }285 ],286 "name": "transfer",287 "outputs": [288 {289 "internalType": "bool",290 "name": "",291 "type": "bool"292 }293 ],294 "stateMutability": "nonpayable",295 "type": "function"296 },297 {298 "inputs": [299 {300 "internalType": "address",301 "name": "from",302 "type": "address"303 },304 {305 "internalType": "address",306 "name": "to",307 "type": "address"308 },309 {310 "internalType": "uint256",311 "name": "value",312 "type": "uint256"313 }314 ],315 "name": "transferFrom",316 "outputs": [317 {318 "internalType": "bool",319 "name": "",320 "type": "bool"321 }322 ],323 "stateMutability": "nonpayable",324 "type": "function"325 }326]