├── README.md ├── HolaCoin.sol └── HolaCoin.json /README.md: -------------------------------------------------------------------------------- 1 | # HAC 2 | 3 | [Token Contract on Etherscan](https://etherscan.io/token/0x3D254e5b6b21bFaB4bB97489FC28eE4c3F44c6D8) 4 | 5 | Hola Coins is an ERC-20 token based on the Ethereum blockchain, in which you can earn unbeatable rewards for every action. Hola Coins is on a mission to minimize the risk associated with crypto investing. 6 | -------------------------------------------------------------------------------- /HolaCoin.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Sample 2 | 3 | pragma solidity >=0.6.0 <0.8.0; 4 | 5 | abstract contract Context { 6 | function _msgSender() internal view virtual returns (address payable) { 7 | return msg.sender; 8 | } 9 | 10 | function _msgData() internal view virtual returns (bytes memory) { 11 | this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 12 | return msg.data; 13 | } 14 | } 15 | 16 | interface IERC20 { 17 | /** 18 | * @dev Returns the amount of tokens in existence. 19 | */ 20 | function totalSupply() external view returns (uint256); 21 | 22 | /** 23 | * @dev Returns the amount of tokens owned by `account`. 24 | */ 25 | function balanceOf(address account) external view returns (uint256); 26 | 27 | /** 28 | * @dev Moves `amount` tokens from the caller's account to `recipient`. 29 | * 30 | * Returns a boolean value indicating whether the operation succeeded. 31 | * 32 | * Emits a {Transfer} event. 33 | */ 34 | function transfer(address recipient, uint256 amount) external returns (bool); 35 | 36 | /** 37 | * @dev Returns the remaining number of tokens that `spender` will be 38 | * allowed to spend on behalf of `owner` through {transferFrom}. This is 39 | * zero by default. 40 | * 41 | * This value changes when {approve} or {transferFrom} are called. 42 | */ 43 | function allowance(address owner, address spender) external view returns (uint256); 44 | 45 | /** 46 | * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. 47 | * 48 | * Returns a boolean value indicating whether the operation succeeded. 49 | * 50 | * IMPORTANT: Beware that changing an allowance with this method brings the risk 51 | * that someone may use both the old and the new allowance by unfortunate 52 | * transaction ordering. One possible solution to mitigate this race 53 | * condition is to first reduce the spender's allowance to 0 and set the 54 | * desired value afterwards: 55 | * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 56 | * 57 | * Emits an {Approval} event. 58 | */ 59 | function approve(address spender, uint256 amount) external returns (bool); 60 | 61 | /** 62 | * @dev Moves `amount` tokens from `sender` to `recipient` using the 63 | * allowance mechanism. `amount` is then deducted from the caller's 64 | * allowance. 65 | * 66 | * Returns a boolean value indicating whether the operation succeeded. 67 | * 68 | * Emits a {Transfer} event. 69 | */ 70 | function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); 71 | 72 | /** 73 | * @dev Emitted when `value` tokens are moved from one account (`from`) to 74 | * another (`to`). 75 | * 76 | * Note that `value` may be zero. 77 | */ 78 | event Transfer(address indexed from, address indexed to, uint256 value); 79 | 80 | /** 81 | * @dev Emitted when the allowance of a `spender` for an `owner` is set by 82 | * a call to {approve}. `value` is the new allowance. 83 | */ 84 | event Approval(address indexed owner, address indexed spender, uint256 value); 85 | } 86 | 87 | library SafeMath { 88 | 89 | function add(uint256 a, uint256 b) internal pure returns (uint256) { 90 | uint256 c = a + b; 91 | require(c >= a, "SafeMath: addition overflow"); 92 | 93 | return c; 94 | } 95 | 96 | /** 97 | * @dev Returns the subtraction of two unsigned integers, reverting on 98 | * overflow (when the result is negative). 99 | * 100 | * Counterpart to Solidity's `-` operator. 101 | * 102 | * Requirements: 103 | * 104 | * - Subtraction cannot overflow. 105 | */ 106 | function sub(uint256 a, uint256 b) internal pure returns (uint256) { 107 | return sub(a, b, "SafeMath: subtraction overflow"); 108 | } 109 | 110 | /** 111 | * @dev Returns the subtraction of two unsigned integers, reverting with custom message on 112 | * overflow (when the result is negative). 113 | * 114 | * Counterpart to Solidity's `-` operator. 115 | * 116 | * Requirements: 117 | * 118 | * - Subtraction cannot overflow. 119 | */ 120 | function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 121 | require(b <= a, errorMessage); 122 | uint256 c = a - b; 123 | 124 | return c; 125 | } 126 | 127 | /** 128 | * @dev Returns the multiplication of two unsigned integers, reverting on 129 | * overflow. 130 | * 131 | * Counterpart to Solidity's `*` operator. 132 | * 133 | * Requirements: 134 | * 135 | * - Multiplication cannot overflow. 136 | */ 137 | function mul(uint256 a, uint256 b) internal pure returns (uint256) { 138 | // Gas optimization: this is cheaper than requiring 'a' not being zero, but the 139 | // benefit is lost if 'b' is also tested. 140 | // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 141 | if (a == 0) { 142 | return 0; 143 | } 144 | 145 | uint256 c = a * b; 146 | require(c / a == b, "SafeMath: multiplication overflow"); 147 | 148 | return c; 149 | } 150 | 151 | 152 | function div(uint256 a, uint256 b) internal pure returns (uint256) { 153 | return div(a, b, "SafeMath: division by zero"); 154 | } 155 | 156 | /** 157 | * @dev Returns the integer division of two unsigned integers. Reverts with custom message on 158 | * division by zero. The result is rounded towards zero. 159 | * 160 | * Counterpart to Solidity's `/` operator. Note: this function uses a 161 | * `revert` opcode (which leaves remaining gas untouched) while Solidity 162 | * uses an invalid opcode to revert (consuming all remaining gas). 163 | * 164 | * Requirements: 165 | * 166 | * - The divisor cannot be zero. 167 | */ 168 | function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 169 | require(b > 0, errorMessage); 170 | uint256 c = a / b; 171 | // assert(a == b * c + a % b); // There is no case in which this doesn't hold 172 | 173 | return c; 174 | } 175 | 176 | /** 177 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 178 | * Reverts when dividing by zero. 179 | * 180 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 181 | * opcode (which leaves remaining gas untouched) while Solidity uses an 182 | * invalid opcode to revert (consuming all remaining gas). 183 | * 184 | * Requirements: 185 | * 186 | * - The divisor cannot be zero. 187 | */ 188 | function mod(uint256 a, uint256 b) internal pure returns (uint256) { 189 | return mod(a, b, "SafeMath: modulo by zero"); 190 | } 191 | 192 | /** 193 | * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), 194 | * Reverts with custom message when dividing by zero. 195 | * 196 | * Counterpart to Solidity's `%` operator. This function uses a `revert` 197 | * opcode (which leaves remaining gas untouched) while Solidity uses an 198 | * invalid opcode to revert (consuming all remaining gas). 199 | * 200 | * Requirements: 201 | * 202 | * - The divisor cannot be zero. 203 | */ 204 | function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { 205 | require(b != 0, errorMessage); 206 | return a % b; 207 | } 208 | } 209 | 210 | contract ERC20 is Context, IERC20 { 211 | using SafeMath for uint256; 212 | 213 | mapping (address => uint256) private _balances; 214 | 215 | mapping (address => mapping (address => uint256)) private _allowances; 216 | 217 | uint256 private _totalSupply; 218 | 219 | string private _name; 220 | string private _symbol; 221 | uint8 private _decimals; 222 | 223 | /** 224 | * @dev Sets the values for {name} and {symbol}, initializes {decimals} with 225 | * a default value of 18. 226 | * 227 | * To select a different value for {decimals}, use {_setupDecimals}. 228 | * 229 | * All three of these values are immutable: they can only be set once during 230 | * construction. 231 | */ 232 | constructor (string memory name_, string memory symbol_) public { 233 | _name = name_; 234 | _symbol = symbol_; 235 | _decimals = 18; 236 | } 237 | 238 | /** 239 | * @dev Returns the name of the token. 240 | */ 241 | function name() public view returns (string memory) { 242 | return _name; 243 | } 244 | 245 | /** 246 | * @dev Returns the symbol of the token, usually a shorter version of the 247 | * name. 248 | */ 249 | function symbol() public view returns (string memory) { 250 | return _symbol; 251 | } 252 | 253 | /** 254 | * @dev Returns the number of decimals used to get its user representation. 255 | * For example, if `decimals` equals `2`, a balance of `505` tokens should 256 | * be displayed to a user as `5,05` (`505 / 10 ** 2`). 257 | * 258 | * Tokens usually opt for a value of 18, imitating the relationship between 259 | * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is 260 | * called. 261 | * 262 | * NOTE: This information is only used for _display_ purposes: it in 263 | * no way affects any of the arithmetic of the contract, including 264 | * {IERC20-balanceOf} and {IERC20-transfer}. 265 | */ 266 | function decimals() public view returns (uint8) { 267 | return _decimals; 268 | } 269 | 270 | /** 271 | * @dev See {IERC20-totalSupply}. 272 | */ 273 | function totalSupply() public view override returns (uint256) { 274 | return _totalSupply; 275 | } 276 | 277 | /** 278 | * @dev See {IERC20-balanceOf}. 279 | */ 280 | function balanceOf(address account) public view override returns (uint256) { 281 | return _balances[account]; 282 | } 283 | 284 | /** 285 | * @dev See {IERC20-transfer}. 286 | * 287 | * Requirements: 288 | * 289 | * - `recipient` cannot be the zero address. 290 | * - the caller must have a balance of at least `amount`. 291 | */ 292 | function transfer(address recipient, uint256 amount) public virtual override returns (bool) { 293 | _transfer(_msgSender(), recipient, amount); 294 | return true; 295 | } 296 | 297 | /** 298 | * @dev See {IERC20-allowance}. 299 | */ 300 | function allowance(address owner, address spender) public view virtual override returns (uint256) { 301 | return _allowances[owner][spender]; 302 | } 303 | 304 | /** 305 | * @dev See {IERC20-approve}. 306 | * 307 | * Requirements: 308 | * 309 | * - `spender` cannot be the zero address. 310 | */ 311 | function approve(address spender, uint256 amount) public virtual override returns (bool) { 312 | _approve(_msgSender(), spender, amount); 313 | return true; 314 | } 315 | 316 | /** 317 | * @dev See {IERC20-transferFrom}. 318 | * 319 | * Emits an {Approval} event indicating the updated allowance. This is not 320 | * required by the EIP. See the note at the beginning of {ERC20}. 321 | * 322 | * Requirements: 323 | * 324 | * - `sender` and `recipient` cannot be the zero address. 325 | * - `sender` must have a balance of at least `amount`. 326 | * - the caller must have allowance for ``sender``'s tokens of at least 327 | * `amount`. 328 | */ 329 | function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { 330 | _transfer(sender, recipient, amount); 331 | _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); 332 | return true; 333 | } 334 | 335 | /** 336 | * @dev Atomically increases the allowance granted to `spender` by the caller. 337 | * 338 | * This is an alternative to {approve} that can be used as a mitigation for 339 | * problems described in {IERC20-approve}. 340 | * 341 | * Emits an {Approval} event indicating the updated allowance. 342 | * 343 | * Requirements: 344 | * 345 | * - `spender` cannot be the zero address. 346 | */ 347 | function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { 348 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); 349 | return true; 350 | } 351 | 352 | /** 353 | * @dev Atomically decreases the allowance granted to `spender` by the caller. 354 | * 355 | * This is an alternative to {approve} that can be used as a mitigation for 356 | * problems described in {IERC20-approve}. 357 | * 358 | * Emits an {Approval} event indicating the updated allowance. 359 | * 360 | * Requirements: 361 | * 362 | * - `spender` cannot be the zero address. 363 | * - `spender` must have allowance for the caller of at least 364 | * `subtractedValue`. 365 | */ 366 | function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { 367 | _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); 368 | return true; 369 | } 370 | 371 | /** 372 | * @dev Moves tokens `amount` from `sender` to `recipient`. 373 | * 374 | * This is internal function is equivalent to {transfer}, and can be used to 375 | * e.g. implement automatic token fees, slashing mechanisms, etc. 376 | * 377 | * Emits a {Transfer} event. 378 | * 379 | * Requirements: 380 | * 381 | * - `sender` cannot be the zero address. 382 | * - `recipient` cannot be the zero address. 383 | * - `sender` must have a balance of at least `amount`. 384 | */ 385 | function _transfer(address sender, address recipient, uint256 amount) internal virtual { 386 | require(sender != address(0), "ERC20: transfer from the zero address"); 387 | require(recipient != address(0), "ERC20: transfer to the zero address"); 388 | 389 | _beforeTokenTransfer(sender, recipient, amount); 390 | 391 | _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); 392 | _balances[recipient] = _balances[recipient].add(amount); 393 | emit Transfer(sender, recipient, amount); 394 | } 395 | 396 | /** @dev Creates `amount` tokens and assigns them to `account`, increasing 397 | * the total supply. 398 | * 399 | * Emits a {Transfer} event with `from` set to the zero address. 400 | * 401 | * Requirements: 402 | * 403 | * - `to` cannot be the zero address. 404 | */ 405 | function _mint(address account, uint256 amount) internal virtual { 406 | require(account != address(0), "ERC20: mint to the zero address"); 407 | 408 | _beforeTokenTransfer(address(0), account, amount); 409 | 410 | _totalSupply = _totalSupply.add(amount); 411 | _balances[account] = _balances[account].add(amount); 412 | emit Transfer(address(0), account, amount); 413 | } 414 | 415 | /** 416 | * @dev Destroys `amount` tokens from `account`, reducing the 417 | * total supply. 418 | * 419 | * Emits a {Transfer} event with `to` set to the zero address. 420 | * 421 | * Requirements: 422 | * 423 | * - `account` cannot be the zero address. 424 | * - `account` must have at least `amount` tokens. 425 | */ 426 | function _burn(address account, uint256 amount) internal virtual { 427 | require(account != address(0), "ERC20: burn from the zero address"); 428 | 429 | _beforeTokenTransfer(account, address(0), amount); 430 | 431 | _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); 432 | _totalSupply = _totalSupply.sub(amount); 433 | emit Transfer(account, address(0), amount); 434 | } 435 | 436 | /** 437 | * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. 438 | * 439 | * This internal function is equivalent to `approve`, and can be used to 440 | * e.g. set automatic allowances for certain subsystems, etc. 441 | * 442 | * Emits an {Approval} event. 443 | * 444 | * Requirements: 445 | * 446 | * - `owner` cannot be the zero address. 447 | * - `spender` cannot be the zero address. 448 | */ 449 | function _approve(address owner, address spender, uint256 amount) internal virtual { 450 | require(owner != address(0), "ERC20: approve from the zero address"); 451 | require(spender != address(0), "ERC20: approve to the zero address"); 452 | 453 | _allowances[owner][spender] = amount; 454 | emit Approval(owner, spender, amount); 455 | } 456 | 457 | /** 458 | * @dev Sets {decimals} to a value other than the default one of 18. 459 | * 460 | * WARNING: This function should only be called from the constructor. Most 461 | * applications that interact with token contracts will not expect 462 | * {decimals} to ever change, and may work incorrectly if it does. 463 | */ 464 | function _setupDecimals(uint8 decimals_) internal { 465 | _decimals = decimals_; 466 | } 467 | 468 | /** 469 | * @dev Hook that is called before any transfer of tokens. This includes 470 | * minting and burning. 471 | * 472 | * Calling conditions: 473 | * 474 | * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens 475 | * will be to transferred to `to`. 476 | * - when `from` is zero, `amount` tokens will be minted for `to`. 477 | * - when `to` is zero, `amount` of ``from``'s tokens will be burned. 478 | * - `from` and `to` are never both zero. 479 | * 480 | * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. 481 | */ 482 | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } 483 | } 484 | 485 | abstract contract ERC20Capped is ERC20 { 486 | using SafeMath for uint256; 487 | 488 | uint256 private _cap; 489 | 490 | /** 491 | * @dev Sets the value of the `cap`. This value is immutable, it can only be 492 | * set once during construction. 493 | */ 494 | constructor (uint256 cap_) internal { 495 | require(cap_ > 0, "ERC20Capped: cap is 0"); 496 | _cap = cap_; 497 | } 498 | 499 | /** 500 | * @dev Returns the cap on the token's total supply. 501 | */ 502 | function cap() public view returns (uint256) { 503 | return _cap; 504 | } 505 | 506 | /** 507 | * @dev See {ERC20-_beforeTokenTransfer}. 508 | * 509 | * Requirements: 510 | * 511 | * - minted tokens must not cause the total supply to go over the cap. 512 | */ 513 | function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override { 514 | super._beforeTokenTransfer(from, to, amount); 515 | 516 | if (from == address(0)) { // When minting tokens 517 | require(totalSupply().add(amount) <= _cap, "ERC20Capped: cap exceeded"); 518 | } 519 | } 520 | } 521 | 522 | library EnumerableSet { 523 | // To implement this library for multiple types with as little code 524 | // repetition as possible, we write it in terms of a generic Set type with 525 | // bytes32 values. 526 | // The Set implementation uses private functions, and user-facing 527 | // implementations (such as AddressSet) are just wrappers around the 528 | // underlying Set. 529 | // This means that we can only create new EnumerableSets for types that fit 530 | // in bytes32. 531 | 532 | struct Set { 533 | // Storage of set values 534 | bytes32[] _values; 535 | 536 | // Position of the value in the `values` array, plus 1 because index 0 537 | // means a value is not in the set. 538 | mapping (bytes32 => uint256) _indexes; 539 | } 540 | 541 | /** 542 | * @dev Add a value to a set. O(1). 543 | * 544 | * Returns true if the value was added to the set, that is if it was not 545 | * already present. 546 | */ 547 | function _add(Set storage set, bytes32 value) private returns (bool) { 548 | if (!_contains(set, value)) { 549 | set._values.push(value); 550 | // The value is stored at length-1, but we add 1 to all indexes 551 | // and use 0 as a sentinel value 552 | set._indexes[value] = set._values.length; 553 | return true; 554 | } else { 555 | return false; 556 | } 557 | } 558 | 559 | /** 560 | * @dev Removes a value from a set. O(1). 561 | * 562 | * Returns true if the value was removed from the set, that is if it was 563 | * present. 564 | */ 565 | function _remove(Set storage set, bytes32 value) private returns (bool) { 566 | // We read and store the value's index to prevent multiple reads from the same storage slot 567 | uint256 valueIndex = set._indexes[value]; 568 | 569 | if (valueIndex != 0) { // Equivalent to contains(set, value) 570 | // To delete an element from the _values array in O(1), we swap the element to delete with the last one in 571 | // the array, and then remove the last element (sometimes called as 'swap and pop'). 572 | // This modifies the order of the array, as noted in {at}. 573 | 574 | uint256 toDeleteIndex = valueIndex - 1; 575 | uint256 lastIndex = set._values.length - 1; 576 | 577 | // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs 578 | // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. 579 | 580 | bytes32 lastvalue = set._values[lastIndex]; 581 | 582 | // Move the last value to the index where the value to delete is 583 | set._values[toDeleteIndex] = lastvalue; 584 | // Update the index for the moved value 585 | set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based 586 | 587 | // Delete the slot where the moved value was stored 588 | set._values.pop(); 589 | 590 | // Delete the index for the deleted slot 591 | delete set._indexes[value]; 592 | 593 | return true; 594 | } else { 595 | return false; 596 | } 597 | } 598 | 599 | /** 600 | * @dev Returns true if the value is in the set. O(1). 601 | */ 602 | function _contains(Set storage set, bytes32 value) private view returns (bool) { 603 | return set._indexes[value] != 0; 604 | } 605 | 606 | /** 607 | * @dev Returns the number of values on the set. O(1). 608 | */ 609 | function _length(Set storage set) private view returns (uint256) { 610 | return set._values.length; 611 | } 612 | 613 | /** 614 | * @dev Returns the value stored at position `index` in the set. O(1). 615 | * 616 | * Note that there are no guarantees on the ordering of values inside the 617 | * array, and it may change when more values are added or removed. 618 | * 619 | * Requirements: 620 | * 621 | * - `index` must be strictly less than {length}. 622 | */ 623 | function _at(Set storage set, uint256 index) private view returns (bytes32) { 624 | require(set._values.length > index, "EnumerableSet: index out of bounds"); 625 | return set._values[index]; 626 | } 627 | 628 | // Bytes32Set 629 | 630 | struct Bytes32Set { 631 | Set _inner; 632 | } 633 | 634 | /** 635 | * @dev Add a value to a set. O(1). 636 | * 637 | * Returns true if the value was added to the set, that is if it was not 638 | * already present. 639 | */ 640 | function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { 641 | return _add(set._inner, value); 642 | } 643 | 644 | /** 645 | * @dev Removes a value from a set. O(1). 646 | * 647 | * Returns true if the value was removed from the set, that is if it was 648 | * present. 649 | */ 650 | function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { 651 | return _remove(set._inner, value); 652 | } 653 | 654 | /** 655 | * @dev Returns true if the value is in the set. O(1). 656 | */ 657 | function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { 658 | return _contains(set._inner, value); 659 | } 660 | 661 | /** 662 | * @dev Returns the number of values in the set. O(1). 663 | */ 664 | function length(Bytes32Set storage set) internal view returns (uint256) { 665 | return _length(set._inner); 666 | } 667 | 668 | /** 669 | * @dev Returns the value stored at position `index` in the set. O(1). 670 | * 671 | * Note that there are no guarantees on the ordering of values inside the 672 | * array, and it may change when more values are added or removed. 673 | * 674 | * Requirements: 675 | * 676 | * - `index` must be strictly less than {length}. 677 | */ 678 | function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { 679 | return _at(set._inner, index); 680 | } 681 | 682 | // AddressSet 683 | 684 | struct AddressSet { 685 | Set _inner; 686 | } 687 | 688 | /** 689 | * @dev Add a value to a set. O(1). 690 | * 691 | * Returns true if the value was added to the set, that is if it was not 692 | * already present. 693 | */ 694 | function add(AddressSet storage set, address value) internal returns (bool) { 695 | return _add(set._inner, bytes32(uint256(value))); 696 | } 697 | 698 | /** 699 | * @dev Removes a value from a set. O(1). 700 | * 701 | * Returns true if the value was removed from the set, that is if it was 702 | * present. 703 | */ 704 | function remove(AddressSet storage set, address value) internal returns (bool) { 705 | return _remove(set._inner, bytes32(uint256(value))); 706 | } 707 | 708 | /** 709 | * @dev Returns true if the value is in the set. O(1). 710 | */ 711 | function contains(AddressSet storage set, address value) internal view returns (bool) { 712 | return _contains(set._inner, bytes32(uint256(value))); 713 | } 714 | 715 | /** 716 | * @dev Returns the number of values in the set. O(1). 717 | */ 718 | function length(AddressSet storage set) internal view returns (uint256) { 719 | return _length(set._inner); 720 | } 721 | 722 | /** 723 | * @dev Returns the value stored at position `index` in the set. O(1). 724 | * 725 | * Note that there are no guarantees on the ordering of values inside the 726 | * array, and it may change when more values are added or removed. 727 | * 728 | * Requirements: 729 | * 730 | * - `index` must be strictly less than {length}. 731 | */ 732 | function at(AddressSet storage set, uint256 index) internal view returns (address) { 733 | return address(uint256(_at(set._inner, index))); 734 | } 735 | 736 | 737 | // UintSet 738 | 739 | struct UintSet { 740 | Set _inner; 741 | } 742 | 743 | /** 744 | * @dev Add a value to a set. O(1). 745 | * 746 | * Returns true if the value was added to the set, that is if it was not 747 | * already present. 748 | */ 749 | function add(UintSet storage set, uint256 value) internal returns (bool) { 750 | return _add(set._inner, bytes32(value)); 751 | } 752 | 753 | /** 754 | * @dev Removes a value from a set. O(1). 755 | * 756 | * Returns true if the value was removed from the set, that is if it was 757 | * present. 758 | */ 759 | function remove(UintSet storage set, uint256 value) internal returns (bool) { 760 | return _remove(set._inner, bytes32(value)); 761 | } 762 | 763 | /** 764 | * @dev Returns true if the value is in the set. O(1). 765 | */ 766 | function contains(UintSet storage set, uint256 value) internal view returns (bool) { 767 | return _contains(set._inner, bytes32(value)); 768 | } 769 | 770 | /** 771 | * @dev Returns the number of values on the set. O(1). 772 | */ 773 | function length(UintSet storage set) internal view returns (uint256) { 774 | return _length(set._inner); 775 | } 776 | 777 | /** 778 | * @dev Returns the value stored at position `index` in the set. O(1). 779 | * 780 | * Note that there are no guarantees on the ordering of values inside the 781 | * array, and it may change when more values are added or removed. 782 | * 783 | * Requirements: 784 | * 785 | * - `index` must be strictly less than {length}. 786 | */ 787 | function at(UintSet storage set, uint256 index) internal view returns (uint256) { 788 | return uint256(_at(set._inner, index)); 789 | } 790 | } 791 | 792 | library Address { 793 | /** 794 | * @dev Returns true if `account` is a contract. 795 | * 796 | * [IMPORTANT] 797 | * ==== 798 | * It is unsafe to assume that an address for which this function returns 799 | * false is an externally-owned account (EOA) and not a contract. 800 | * 801 | * Among others, `isContract` will return false for the following 802 | * types of addresses: 803 | * 804 | * - an externally-owned account 805 | * - a contract in construction 806 | * - an address where a contract will be created 807 | * - an address where a contract lived, but was destroyed 808 | * ==== 809 | */ 810 | function isContract(address account) internal view returns (bool) { 811 | // This method relies on extcodesize, which returns 0 for contracts in 812 | // construction, since the code is only stored at the end of the 813 | // constructor execution. 814 | 815 | uint256 size; 816 | // solhint-disable-next-line no-inline-assembly 817 | assembly { size := extcodesize(account) } 818 | return size > 0; 819 | } 820 | 821 | /** 822 | * @dev Replacement for Solidity's `transfer`: sends `amount` wei to 823 | * `recipient`, forwarding all available gas and reverting on errors. 824 | * 825 | * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost 826 | * of certain opcodes, possibly making contracts go over the 2300 gas limit 827 | * imposed by `transfer`, making them unable to receive funds via 828 | * `transfer`. {sendValue} removes this limitation. 829 | * 830 | * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. 831 | * 832 | * IMPORTANT: because control is transferred to `recipient`, care must be 833 | * taken to not create reentrancy vulnerabilities. Consider using 834 | * {ReentrancyGuard} or the 835 | * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. 836 | */ 837 | function sendValue(address payable recipient, uint256 amount) internal { 838 | require(address(this).balance >= amount, "Address: insufficient balance"); 839 | 840 | // solhint-disable-next-line avoid-low-level-calls, avoid-call-value 841 | (bool success, ) = recipient.call{ value: amount }(""); 842 | require(success, "Address: unable to send value, recipient may have reverted"); 843 | } 844 | 845 | /** 846 | * @dev Performs a Solidity function call using a low level `call`. A 847 | * plain`call` is an unsafe replacement for a function call: use this 848 | * function instead. 849 | * 850 | * If `target` reverts with a revert reason, it is bubbled up by this 851 | * function (like regular Solidity function calls). 852 | * 853 | * Returns the raw returned data. To convert to the expected return value, 854 | * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. 855 | * 856 | * Requirements: 857 | * 858 | * - `target` must be a contract. 859 | * - calling `target` with `data` must not revert. 860 | * 861 | * _Available since v3.1._ 862 | */ 863 | function functionCall(address target, bytes memory data) internal returns (bytes memory) { 864 | return functionCall(target, data, "Address: low-level call failed"); 865 | } 866 | 867 | /** 868 | * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with 869 | * `errorMessage` as a fallback revert reason when `target` reverts. 870 | * 871 | * _Available since v3.1._ 872 | */ 873 | function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { 874 | return functionCallWithValue(target, data, 0, errorMessage); 875 | } 876 | 877 | /** 878 | * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], 879 | * but also transferring `value` wei to `target`. 880 | * 881 | * Requirements: 882 | * 883 | * - the calling contract must have an ETH balance of at least `value`. 884 | * - the called Solidity function must be `payable`. 885 | * 886 | * _Available since v3.1._ 887 | */ 888 | function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { 889 | return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); 890 | } 891 | 892 | /** 893 | * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but 894 | * with `errorMessage` as a fallback revert reason when `target` reverts. 895 | * 896 | * _Available since v3.1._ 897 | */ 898 | function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { 899 | require(address(this).balance >= value, "Address: insufficient balance for call"); 900 | require(isContract(target), "Address: call to non-contract"); 901 | 902 | // solhint-disable-next-line avoid-low-level-calls 903 | (bool success, bytes memory returndata) = target.call{ value: value }(data); 904 | return _verifyCallResult(success, returndata, errorMessage); 905 | } 906 | 907 | /** 908 | * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], 909 | * but performing a static call. 910 | * 911 | * _Available since v3.3._ 912 | */ 913 | function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { 914 | return functionStaticCall(target, data, "Address: low-level static call failed"); 915 | } 916 | 917 | /** 918 | * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], 919 | * but performing a static call. 920 | * 921 | * _Available since v3.3._ 922 | */ 923 | function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { 924 | require(isContract(target), "Address: static call to non-contract"); 925 | 926 | // solhint-disable-next-line avoid-low-level-calls 927 | (bool success, bytes memory returndata) = target.staticcall(data); 928 | return _verifyCallResult(success, returndata, errorMessage); 929 | } 930 | 931 | function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { 932 | if (success) { 933 | return returndata; 934 | } else { 935 | // Look for revert reason and bubble it up if present 936 | if (returndata.length > 0) { 937 | // The easiest way to bubble the revert reason is using memory via assembly 938 | 939 | // solhint-disable-next-line no-inline-assembly 940 | assembly { 941 | let returndata_size := mload(returndata) 942 | revert(add(32, returndata), returndata_size) 943 | } 944 | } else { 945 | revert(errorMessage); 946 | } 947 | } 948 | } 949 | } 950 | 951 | abstract contract AccessControl is Context { 952 | using EnumerableSet for EnumerableSet.AddressSet; 953 | using Address for address; 954 | 955 | struct RoleData { 956 | EnumerableSet.AddressSet members; 957 | bytes32 adminRole; 958 | } 959 | 960 | mapping (bytes32 => RoleData) private _roles; 961 | 962 | bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; 963 | 964 | /** 965 | * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` 966 | * 967 | * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite 968 | * {RoleAdminChanged} not being emitted signaling this. 969 | * 970 | * _Available since v3.1._ 971 | */ 972 | event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); 973 | 974 | /** 975 | * @dev Emitted when `account` is granted `role`. 976 | * 977 | * `sender` is the account that originated the contract call, an admin role 978 | * bearer except when using {_setupRole}. 979 | */ 980 | event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); 981 | 982 | /** 983 | * @dev Emitted when `account` is revoked `role`. 984 | * 985 | * `sender` is the account that originated the contract call: 986 | * - if using `revokeRole`, it is the admin role bearer 987 | * - if using `renounceRole`, it is the role bearer (i.e. `account`) 988 | */ 989 | event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); 990 | 991 | /** 992 | * @dev Returns `true` if `account` has been granted `role`. 993 | */ 994 | function hasRole(bytes32 role, address account) public view returns (bool) { 995 | return _roles[role].members.contains(account); 996 | } 997 | 998 | /** 999 | * @dev Returns the number of accounts that have `role`. Can be used 1000 | * together with {getRoleMember} to enumerate all bearers of a role. 1001 | */ 1002 | function getRoleMemberCount(bytes32 role) public view returns (uint256) { 1003 | return _roles[role].members.length(); 1004 | } 1005 | 1006 | /** 1007 | * @dev Returns one of the accounts that have `role`. `index` must be a 1008 | * value between 0 and {getRoleMemberCount}, non-inclusive. 1009 | * 1010 | * Role bearers are not sorted in any particular way, and their ordering may 1011 | * change at any point. 1012 | * 1013 | * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure 1014 | * you perform all queries on the same block. See the following 1015 | * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] 1016 | * for more information. 1017 | */ 1018 | function getRoleMember(bytes32 role, uint256 index) public view returns (address) { 1019 | return _roles[role].members.at(index); 1020 | } 1021 | 1022 | /** 1023 | * @dev Returns the admin role that controls `role`. See {grantRole} and 1024 | * {revokeRole}. 1025 | * 1026 | * To change a role's admin, use {_setRoleAdmin}. 1027 | */ 1028 | function getRoleAdmin(bytes32 role) public view returns (bytes32) { 1029 | return _roles[role].adminRole; 1030 | } 1031 | 1032 | /** 1033 | * @dev Grants `role` to `account`. 1034 | * 1035 | * If `account` had not been already granted `role`, emits a {RoleGranted} 1036 | * event. 1037 | * 1038 | * Requirements: 1039 | * 1040 | * - the caller must have ``role``'s admin role. 1041 | */ 1042 | function grantRole(bytes32 role, address account) public virtual { 1043 | require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to grant"); 1044 | 1045 | _grantRole(role, account); 1046 | } 1047 | 1048 | /** 1049 | * @dev Revokes `role` from `account`. 1050 | * 1051 | * If `account` had been granted `role`, emits a {RoleRevoked} event. 1052 | * 1053 | * Requirements: 1054 | * 1055 | * - the caller must have ``role``'s admin role. 1056 | */ 1057 | function revokeRole(bytes32 role, address account) public virtual { 1058 | require(hasRole(_roles[role].adminRole, _msgSender()), "AccessControl: sender must be an admin to revoke"); 1059 | 1060 | _revokeRole(role, account); 1061 | } 1062 | 1063 | /** 1064 | * @dev Revokes `role` from the calling account. 1065 | * 1066 | * Roles are often managed via {grantRole} and {revokeRole}: this function's 1067 | * purpose is to provide a mechanism for accounts to lose their privileges 1068 | * if they are compromised (such as when a trusted device is misplaced). 1069 | * 1070 | * If the calling account had been granted `role`, emits a {RoleRevoked} 1071 | * event. 1072 | * 1073 | * Requirements: 1074 | * 1075 | * - the caller must be `account`. 1076 | */ 1077 | function renounceRole(bytes32 role, address account) public virtual { 1078 | require(account == _msgSender(), "AccessControl: can only renounce roles for self"); 1079 | 1080 | _revokeRole(role, account); 1081 | } 1082 | 1083 | /** 1084 | * @dev Grants `role` to `account`. 1085 | * 1086 | * If `account` had not been already granted `role`, emits a {RoleGranted} 1087 | * event. Note that unlike {grantRole}, this function doesn't perform any 1088 | * checks on the calling account. 1089 | * 1090 | * [WARNING] 1091 | * ==== 1092 | * This function should only be called from the constructor when setting 1093 | * up the initial roles for the system. 1094 | * 1095 | * Using this function in any other way is effectively circumventing the admin 1096 | * system imposed by {AccessControl}. 1097 | * ==== 1098 | */ 1099 | function _setupRole(bytes32 role, address account) internal virtual { 1100 | _grantRole(role, account); 1101 | } 1102 | 1103 | /** 1104 | * @dev Sets `adminRole` as ``role``'s admin role. 1105 | * 1106 | * Emits a {RoleAdminChanged} event. 1107 | */ 1108 | function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { 1109 | emit RoleAdminChanged(role, _roles[role].adminRole, adminRole); 1110 | _roles[role].adminRole = adminRole; 1111 | } 1112 | 1113 | function _grantRole(bytes32 role, address account) private { 1114 | if (_roles[role].members.add(account)) { 1115 | emit RoleGranted(role, account, _msgSender()); 1116 | } 1117 | } 1118 | 1119 | function _revokeRole(bytes32 role, address account) private { 1120 | if (_roles[role].members.remove(account)) { 1121 | emit RoleRevoked(role, account, _msgSender()); 1122 | } 1123 | } 1124 | } 1125 | 1126 | 1127 | contract HolaCoin is ERC20Capped, AccessControl { 1128 | 1129 | bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE"); 1130 | uint256 totalSupplyCap = 3000000000 * (10 ** 18); 1131 | 1132 | constructor() public ERC20("HOLA COINS", "HAC") ERC20Capped(totalSupplyCap) { 1133 | _setupRole(MINTER_ROLE, msg.sender); 1134 | } 1135 | 1136 | function mint(address to, uint256 amount) public { 1137 | require(hasRole(MINTER_ROLE, msg.sender), "Caller is not a minter"); 1138 | _mint(to, amount); 1139 | } 1140 | } 1141 | -------------------------------------------------------------------------------- /HolaCoin.json: -------------------------------------------------------------------------------- 1 | { 2 | "contractName": "HolaCoin", 3 | "abi": [ 4 | { 5 | "inputs": [], 6 | "stateMutability": "nonpayable", 7 | "type": "constructor" 8 | }, 9 | { 10 | "anonymous": false, 11 | "inputs": [ 12 | { 13 | "indexed": true, 14 | "internalType": "address", 15 | "name": "owner", 16 | "type": "address" 17 | }, 18 | { 19 | "indexed": true, 20 | "internalType": "address", 21 | "name": "spender", 22 | "type": "address" 23 | }, 24 | { 25 | "indexed": false, 26 | "internalType": "uint256", 27 | "name": "value", 28 | "type": "uint256" 29 | } 30 | ], 31 | "name": "Approval", 32 | "type": "event" 33 | }, 34 | { 35 | "anonymous": false, 36 | "inputs": [ 37 | { 38 | "indexed": true, 39 | "internalType": "bytes32", 40 | "name": "role", 41 | "type": "bytes32" 42 | }, 43 | { 44 | "indexed": true, 45 | "internalType": "bytes32", 46 | "name": "previousAdminRole", 47 | "type": "bytes32" 48 | }, 49 | { 50 | "indexed": true, 51 | "internalType": "bytes32", 52 | "name": "newAdminRole", 53 | "type": "bytes32" 54 | } 55 | ], 56 | "name": "RoleAdminChanged", 57 | "type": "event" 58 | }, 59 | { 60 | "anonymous": false, 61 | "inputs": [ 62 | { 63 | "indexed": true, 64 | "internalType": "bytes32", 65 | "name": "role", 66 | "type": "bytes32" 67 | }, 68 | { 69 | "indexed": true, 70 | "internalType": "address", 71 | "name": "account", 72 | "type": "address" 73 | }, 74 | { 75 | "indexed": true, 76 | "internalType": "address", 77 | "name": "sender", 78 | "type": "address" 79 | } 80 | ], 81 | "name": "RoleGranted", 82 | "type": "event" 83 | }, 84 | { 85 | "anonymous": false, 86 | "inputs": [ 87 | { 88 | "indexed": true, 89 | "internalType": "bytes32", 90 | "name": "role", 91 | "type": "bytes32" 92 | }, 93 | { 94 | "indexed": true, 95 | "internalType": "address", 96 | "name": "account", 97 | "type": "address" 98 | }, 99 | { 100 | "indexed": true, 101 | "internalType": "address", 102 | "name": "sender", 103 | "type": "address" 104 | } 105 | ], 106 | "name": "RoleRevoked", 107 | "type": "event" 108 | }, 109 | { 110 | "anonymous": false, 111 | "inputs": [ 112 | { 113 | "indexed": true, 114 | "internalType": "address", 115 | "name": "from", 116 | "type": "address" 117 | }, 118 | { 119 | "indexed": true, 120 | "internalType": "address", 121 | "name": "to", 122 | "type": "address" 123 | }, 124 | { 125 | "indexed": false, 126 | "internalType": "uint256", 127 | "name": "value", 128 | "type": "uint256" 129 | } 130 | ], 131 | "name": "Transfer", 132 | "type": "event" 133 | }, 134 | { 135 | "inputs": [], 136 | "name": "DEFAULT_ADMIN_ROLE", 137 | "outputs": [ 138 | { 139 | "internalType": "bytes32", 140 | "name": "", 141 | "type": "bytes32" 142 | } 143 | ], 144 | "stateMutability": "view", 145 | "type": "function", 146 | "constant": true 147 | }, 148 | { 149 | "inputs": [], 150 | "name": "MINTER_ROLE", 151 | "outputs": [ 152 | { 153 | "internalType": "bytes32", 154 | "name": "", 155 | "type": "bytes32" 156 | } 157 | ], 158 | "stateMutability": "view", 159 | "type": "function", 160 | "constant": true 161 | }, 162 | { 163 | "inputs": [ 164 | { 165 | "internalType": "address", 166 | "name": "owner", 167 | "type": "address" 168 | }, 169 | { 170 | "internalType": "address", 171 | "name": "spender", 172 | "type": "address" 173 | } 174 | ], 175 | "name": "allowance", 176 | "outputs": [ 177 | { 178 | "internalType": "uint256", 179 | "name": "", 180 | "type": "uint256" 181 | } 182 | ], 183 | "stateMutability": "view", 184 | "type": "function", 185 | "constant": true 186 | }, 187 | { 188 | "inputs": [ 189 | { 190 | "internalType": "address", 191 | "name": "spender", 192 | "type": "address" 193 | }, 194 | { 195 | "internalType": "uint256", 196 | "name": "amount", 197 | "type": "uint256" 198 | } 199 | ], 200 | "name": "approve", 201 | "outputs": [ 202 | { 203 | "internalType": "bool", 204 | "name": "", 205 | "type": "bool" 206 | } 207 | ], 208 | "stateMutability": "nonpayable", 209 | "type": "function" 210 | }, 211 | { 212 | "inputs": [ 213 | { 214 | "internalType": "address", 215 | "name": "account", 216 | "type": "address" 217 | } 218 | ], 219 | "name": "balanceOf", 220 | "outputs": [ 221 | { 222 | "internalType": "uint256", 223 | "name": "", 224 | "type": "uint256" 225 | } 226 | ], 227 | "stateMutability": "view", 228 | "type": "function", 229 | "constant": true 230 | }, 231 | { 232 | "inputs": [], 233 | "name": "cap", 234 | "outputs": [ 235 | { 236 | "internalType": "uint256", 237 | "name": "", 238 | "type": "uint256" 239 | } 240 | ], 241 | "stateMutability": "view", 242 | "type": "function", 243 | "constant": true 244 | }, 245 | { 246 | "inputs": [], 247 | "name": "decimals", 248 | "outputs": [ 249 | { 250 | "internalType": "uint8", 251 | "name": "", 252 | "type": "uint8" 253 | } 254 | ], 255 | "stateMutability": "view", 256 | "type": "function", 257 | "constant": true 258 | }, 259 | { 260 | "inputs": [ 261 | { 262 | "internalType": "address", 263 | "name": "spender", 264 | "type": "address" 265 | }, 266 | { 267 | "internalType": "uint256", 268 | "name": "subtractedValue", 269 | "type": "uint256" 270 | } 271 | ], 272 | "name": "decreaseAllowance", 273 | "outputs": [ 274 | { 275 | "internalType": "bool", 276 | "name": "", 277 | "type": "bool" 278 | } 279 | ], 280 | "stateMutability": "nonpayable", 281 | "type": "function" 282 | }, 283 | { 284 | "inputs": [ 285 | { 286 | "internalType": "bytes32", 287 | "name": "role", 288 | "type": "bytes32" 289 | } 290 | ], 291 | "name": "getRoleAdmin", 292 | "outputs": [ 293 | { 294 | "internalType": "bytes32", 295 | "name": "", 296 | "type": "bytes32" 297 | } 298 | ], 299 | "stateMutability": "view", 300 | "type": "function", 301 | "constant": true 302 | }, 303 | { 304 | "inputs": [ 305 | { 306 | "internalType": "bytes32", 307 | "name": "role", 308 | "type": "bytes32" 309 | }, 310 | { 311 | "internalType": "uint256", 312 | "name": "index", 313 | "type": "uint256" 314 | } 315 | ], 316 | "name": "getRoleMember", 317 | "outputs": [ 318 | { 319 | "internalType": "address", 320 | "name": "", 321 | "type": "address" 322 | } 323 | ], 324 | "stateMutability": "view", 325 | "type": "function", 326 | "constant": true 327 | }, 328 | { 329 | "inputs": [ 330 | { 331 | "internalType": "bytes32", 332 | "name": "role", 333 | "type": "bytes32" 334 | } 335 | ], 336 | "name": "getRoleMemberCount", 337 | "outputs": [ 338 | { 339 | "internalType": "uint256", 340 | "name": "", 341 | "type": "uint256" 342 | } 343 | ], 344 | "stateMutability": "view", 345 | "type": "function", 346 | "constant": true 347 | }, 348 | { 349 | "inputs": [ 350 | { 351 | "internalType": "bytes32", 352 | "name": "role", 353 | "type": "bytes32" 354 | }, 355 | { 356 | "internalType": "address", 357 | "name": "account", 358 | "type": "address" 359 | } 360 | ], 361 | "name": "grantRole", 362 | "outputs": [], 363 | "stateMutability": "nonpayable", 364 | "type": "function" 365 | }, 366 | { 367 | "inputs": [ 368 | { 369 | "internalType": "bytes32", 370 | "name": "role", 371 | "type": "bytes32" 372 | }, 373 | { 374 | "internalType": "address", 375 | "name": "account", 376 | "type": "address" 377 | } 378 | ], 379 | "name": "hasRole", 380 | "outputs": [ 381 | { 382 | "internalType": "bool", 383 | "name": "", 384 | "type": "bool" 385 | } 386 | ], 387 | "stateMutability": "view", 388 | "type": "function", 389 | "constant": true 390 | }, 391 | { 392 | "inputs": [ 393 | { 394 | "internalType": "address", 395 | "name": "spender", 396 | "type": "address" 397 | }, 398 | { 399 | "internalType": "uint256", 400 | "name": "addedValue", 401 | "type": "uint256" 402 | } 403 | ], 404 | "name": "increaseAllowance", 405 | "outputs": [ 406 | { 407 | "internalType": "bool", 408 | "name": "", 409 | "type": "bool" 410 | } 411 | ], 412 | "stateMutability": "nonpayable", 413 | "type": "function" 414 | }, 415 | { 416 | "inputs": [], 417 | "name": "name", 418 | "outputs": [ 419 | { 420 | "internalType": "string", 421 | "name": "", 422 | "type": "string" 423 | } 424 | ], 425 | "stateMutability": "view", 426 | "type": "function", 427 | "constant": true 428 | }, 429 | { 430 | "inputs": [ 431 | { 432 | "internalType": "bytes32", 433 | "name": "role", 434 | "type": "bytes32" 435 | }, 436 | { 437 | "internalType": "address", 438 | "name": "account", 439 | "type": "address" 440 | } 441 | ], 442 | "name": "renounceRole", 443 | "outputs": [], 444 | "stateMutability": "nonpayable", 445 | "type": "function" 446 | }, 447 | { 448 | "inputs": [ 449 | { 450 | "internalType": "bytes32", 451 | "name": "role", 452 | "type": "bytes32" 453 | }, 454 | { 455 | "internalType": "address", 456 | "name": "account", 457 | "type": "address" 458 | } 459 | ], 460 | "name": "revokeRole", 461 | "outputs": [], 462 | "stateMutability": "nonpayable", 463 | "type": "function" 464 | }, 465 | { 466 | "inputs": [], 467 | "name": "symbol", 468 | "outputs": [ 469 | { 470 | "internalType": "string", 471 | "name": "", 472 | "type": "string" 473 | } 474 | ], 475 | "stateMutability": "view", 476 | "type": "function", 477 | "constant": true 478 | }, 479 | { 480 | "inputs": [], 481 | "name": "totalSupply", 482 | "outputs": [ 483 | { 484 | "internalType": "uint256", 485 | "name": "", 486 | "type": "uint256" 487 | } 488 | ], 489 | "stateMutability": "view", 490 | "type": "function", 491 | "constant": true 492 | }, 493 | { 494 | "inputs": [ 495 | { 496 | "internalType": "address", 497 | "name": "recipient", 498 | "type": "address" 499 | }, 500 | { 501 | "internalType": "uint256", 502 | "name": "amount", 503 | "type": "uint256" 504 | } 505 | ], 506 | "name": "transfer", 507 | "outputs": [ 508 | { 509 | "internalType": "bool", 510 | "name": "", 511 | "type": "bool" 512 | } 513 | ], 514 | "stateMutability": "nonpayable", 515 | "type": "function" 516 | }, 517 | { 518 | "inputs": [ 519 | { 520 | "internalType": "address", 521 | "name": "sender", 522 | "type": "address" 523 | }, 524 | { 525 | "internalType": "address", 526 | "name": "recipient", 527 | "type": "address" 528 | }, 529 | { 530 | "internalType": "uint256", 531 | "name": "amount", 532 | "type": "uint256" 533 | } 534 | ], 535 | "name": "transferFrom", 536 | "outputs": [ 537 | { 538 | "internalType": "bool", 539 | "name": "", 540 | "type": "bool" 541 | } 542 | ], 543 | "stateMutability": "nonpayable", 544 | "type": "function" 545 | }, 546 | { 547 | "inputs": [ 548 | { 549 | "internalType": "address", 550 | "name": "to", 551 | "type": "address" 552 | }, 553 | { 554 | "internalType": "uint256", 555 | "name": "amount", 556 | "type": "uint256" 557 | } 558 | ], 559 | "name": "mint", 560 | "outputs": [], 561 | "stateMutability": "nonpayable", 562 | "type": "function" 563 | } 564 | ], 565 | "metadata": "{\"compiler\":{\"version\":\"0.6.12+commit.27d51765\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MINTER_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"cap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"getRoleMember\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleMemberCount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"cap()\":{\"details\":\"Returns the cap on the token's total supply.\"},\"decimals()\":{\"details\":\"Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5,05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is called. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}.\"},\"decreaseAllowance(address,uint256)\":{\"details\":\"Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`.\"},\"getRoleAdmin(bytes32)\":{\"details\":\"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.\"},\"getRoleMember(bytes32,uint256)\":{\"details\":\"Returns one of the accounts that have `role`. `index` must be a value between 0 and {getRoleMemberCount}, non-inclusive. Role bearers are not sorted in any particular way, and their ordering may change at any point. WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure you perform all queries on the same block. See the following https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] for more information.\"},\"getRoleMemberCount(bytes32)\":{\"details\":\"Returns the number of accounts that have `role`. Can be used together with {getRoleMember} to enumerate all bearers of a role.\"},\"grantRole(bytes32,address)\":{\"details\":\"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role.\"},\"hasRole(bytes32,address)\":{\"details\":\"Returns `true` if `account` has been granted `role`.\"},\"increaseAllowance(address,uint256)\":{\"details\":\"Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address.\"},\"name()\":{\"details\":\"Returns the name of the token.\"},\"renounceRole(bytes32,address)\":{\"details\":\"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`.\"},\"revokeRole(bytes32,address)\":{\"details\":\"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role.\"},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `recipient` cannot be the zero address. - the caller must have a balance of at least `amount`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. Requirements: - `sender` and `recipient` cannot be the zero address. - `sender` must have a balance of at least `amount`. - the caller must have allowance for ``sender``'s tokens of at least `amount`.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"/Users/sibizulu/Code/dev/knit/truffle/contracts/HolaCoin.sol\":\"HolaCoin\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":false,\"runs\":200},\"remappings\":[]},\"sources\":{\"/Users/sibizulu/Code/dev/knit/truffle/contracts/HolaCoin.sol\":{\"keccak256\":\"0x4510ced30af9e29368f1fca1c9f692a940d8d9459fd1604939390e5547c049b4\",\"license\":\"Sample\",\"urls\":[\"bzz-raw://8ba7b672d02426c9a2ad8d487b76a84412871055cc537ce6f1dbaca8fbd25f09\",\"dweb:/ipfs/QmQphTLYratsiwQ48T1VQyxBPXu1joauPbF7xmpdyAAnmW\"]},\"@openzeppelin/contracts/GSN/Context.sol\":{\"keccak256\":\"0x8d3cb350f04ff49cfb10aef08d87f19dcbaecc8027b0bed12f3275cd12f38cf0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://ded47ec7c96750f9bd04bbbc84f659992d4ba901cb7b532a52cd468272cf378f\",\"dweb:/ipfs/QmfBrGtQP7rZEqEg6Wz6jh2N2Kukpj1z5v3CGWmAqrzm96\"]},\"@openzeppelin/contracts/access/AccessControl.sol\":{\"keccak256\":\"0x37ff88aa5ca8f533e31b9e1cb5354816b15bb7d41c904ea1c8f5dd5a78d6da25\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://f3731db435ced7084f2cb3947e708371c10a2e3f654dcfe2a237fc8fbdafbe5f\",\"dweb:/ipfs/QmUyiwkuiP2fYBVaTwwY82sJKxJyPQaBqAtS4uG6iaUSP7\"]},\"@openzeppelin/contracts/math/SafeMath.sol\":{\"keccak256\":\"0x3b21f2c8d626de3b9925ae33e972d8bf5c8b1bffb3f4ee94daeed7d0679036e6\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://7f8d45329fecbf0836ad7543330c3ecd0f8d0ffa42d4016278c3eb2215fdcdfe\",\"dweb:/ipfs/QmXWLT7GcnHtA5NiD6MFi2CV3EWJY4wv5mLNnypqYDrxL3\"]},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"keccak256\":\"0xcbd85c86627a47fd939f1f4ee3ba626575ff2a182e1804b29f5136394449b538\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://53c6a80c519bb9356aad28efa9a1ec31603860eb759d2dc57f545fcae1dd1aca\",\"dweb:/ipfs/QmfRS6TtMNUHhvgLHXK21qKNnpn2S7g2Yd1fKaHKyFiJsR\"]},\"@openzeppelin/contracts/token/ERC20/ERC20Capped.sol\":{\"keccak256\":\"0xcf427190fa6213e44a1c2c10a721b2e7696d67e600fb05412fb3a3e41f4b9317\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c3a8834a26ae399a9f5a5a3059acc154998024a46696c51100c0785d9a54b0d4\",\"dweb:/ipfs/QmYNGDWpqRQGzpPreYRab4fLaxVwyR6DpURxxuVHhK1La4\"]},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x5f02220344881ce43204ae4a6281145a67bc52c2bb1290a791857df3d19d78f5\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://24427744bd3e6cb73c17010119af12a318289c0253a4d9acb8576c9fb3797b08\",\"dweb:/ipfs/QmTLDqpKRBuxGxRAmjgXt9AkXyACW3MtKzi7PYjm5iMfGC\"]},\"@openzeppelin/contracts/utils/Address.sol\":{\"keccak256\":\"0xa6a15ddddcbf29d2922a1e0d4151b5d2d33da24b93cc9ebc12390e0d855532f8\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://7c119bcaecfa853d564ac88d312777f75fa1126a3bca88a3371adb0ad9f35cb0\",\"dweb:/ipfs/QmY9UPuXeSKq86Zh38fE43VGQPhKMN34mkuFSFqPcr6nvZ\"]},\"@openzeppelin/contracts/utils/EnumerableSet.sol\":{\"keccak256\":\"0xae0992eb1ec30fd1ecdf2e04a6036decfc9797bf11dc1ec84b546b74318d5ec2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3b61f99a64e999682ad7bfbb3a1c762a20a0a5b30f9f2011693fa857969af61f\",\"dweb:/ipfs/QmZystFY76wkWCf7V3yKh3buZuKVKbswiE7y6yU62kk3zi\"]}},\"version\":1}", 566 | "bytecode": "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", 567 | "deployedBytecode": "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", 568 | "immutableReferences": {}, 569 | "sourceMap": "239:475:0:-:0;;;388:23;362:49;;418:128;;;;;;;;;;478:14;;1956:145:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2038:5;2030;:13;;;;;;;;;;;;:::i;:::-;;2063:7;2053;:17;;;;;;;;;;;;:::i;:::-;;2092:2;2080:9;;:14;;;;;;;;;;;;;;;;;;1956:145;;467:1:19;460:4;:8;452:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;511:4;504;:11;;;;406:116;504:35:0::2;332:24;528:10;504;;;:35;;:::i;:::-;239:475:::0;;6586:110:15;6664:25;6675:4;6681:7;6664:10;;;:25;;:::i;:::-;6586:110;;:::o;7023:184::-;7096:33;7121:7;7096:6;:12;7103:4;7096:12;;;;;;;;;;;:20;;:24;;;;;;:33;;;;:::i;:::-;7092:109;;;7177:12;:10;;;:12;;:::i;:::-;7150:40;;7168:7;7150:40;;7162:4;7150:40;;;;;;;;;;7092:109;7023:184;;:::o;6429:141:22:-;6499:4;6522:41;6527:3;:10;;6555:5;6547:14;;6539:23;;6522:4;;;:41;;:::i;:::-;6515:48;;6429:141;;;;:::o;598:104:14:-;651:15;685:10;678:17;;598:104;:::o;1640:404:22:-;1703:4;1724:21;1734:3;1739:5;1724:9;;;:21;;:::i;:::-;1719:319;;1761:3;:11;;1778:5;1761:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1941:3;:11;;:18;;;;1919:3;:12;;:19;1932:5;1919:19;;;;;;;;;;;:40;;;;1980:4;1973:11;;;;1719:319;2022:5;2015:12;;1640:404;;;;;:::o;3805:127::-;3878:4;3924:1;3901:3;:12;;:19;3914:5;3901:19;;;;;;;;;;;;:24;;3894:31;;3805:127;;;;:::o;239:475:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;", 570 | "deployedSourceMap": "239:475:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2166:81:17;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4202:166;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;3209:98;;;:::i;:::-;;;;;;;;;;;;;;;;;;;4835:317;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;4280:112:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;4642:223;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3068:81:17;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;601:73:19;;;:::i;:::-;;;;;;;;;;;;;;;;;;;5816:205:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;5547:215:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;552:160:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3365:117:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;3963:136:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;2948:137;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;2360:85:17;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1725:49:15;;;:::i;:::-;;;;;;;;;;;;;;;;;;;6249:266:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;3685:172;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;3253:125:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;294:62:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;;5099:226:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;3915:149:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;2166:81;2203:13;2235:5;2228:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2166:81;:::o;4202:166::-;4285:4;4301:39;4310:12;:10;:12::i;:::-;4324:7;4333:6;4301:8;:39::i;:::-;4357:4;4350:11;;4202:166;;;;:::o;3209:98::-;3262:7;3288:12;;3281:19;;3209:98;:::o;4835:317::-;4941:4;4957:36;4967:6;4975:9;4986:6;4957:9;:36::i;:::-;5003:121;5012:6;5020:12;:10;:12::i;:::-;5034:89;5072:6;5034:89;;;;;;;;;;;;;;;;;:11;:19;5046:6;5034:19;;;;;;;;;;;;;;;:33;5054:12;:10;:12::i;:::-;5034:33;;;;;;;;;;;;;;;;:37;;:89;;;;;:::i;:::-;5003:8;:121::i;:::-;5141:4;5134:11;;4835:317;;;;;:::o;4280:112:15:-;4337:7;4363:6;:12;4370:4;4363:12;;;;;;;;;;;:22;;;4356:29;;4280:112;;;:::o;4642:223::-;4725:45;4733:6;:12;4740:4;4733:12;;;;;;;;;;;:22;;;4757:12;:10;:12::i;:::-;4725:7;:45::i;:::-;4717:105;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4833:25;4844:4;4850:7;4833:10;:25::i;:::-;4642:223;;:::o;3068:81:17:-;3109:5;3133:9;;;;;;;;;;;3126:16;;3068:81;:::o;601:73:19:-;637:7;663:4;;656:11;;601:73;:::o;5816:205:15:-;5913:12;:10;:12::i;:::-;5902:23;;:7;:23;;;5894:83;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5988:26;6000:4;6006:7;5988:11;:26::i;:::-;5816:205;;:::o;5547:215:17:-;5635:4;5651:83;5660:12;:10;:12::i;:::-;5674:7;5683:50;5722:10;5683:11;:25;5695:12;:10;:12::i;:::-;5683:25;;;;;;;;;;;;;;;:34;5709:7;5683:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;5651:8;:83::i;:::-;5751:4;5744:11;;5547:215;;;;:::o;552:160:0:-;619:32;332:24;640:10;619:7;:32::i;:::-;611:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;688:17;694:2;698:6;688:5;:17::i;:::-;552:160;;:::o;3365:117:17:-;3431:7;3457:9;:18;3467:7;3457:18;;;;;;;;;;;;;;;;3450:25;;3365:117;;;:::o;3963:136:15:-;4036:7;4062:30;4086:5;4062:6;:12;4069:4;4062:12;;;;;;;;;;;:20;;:23;;:30;;;;:::i;:::-;4055:37;;3963:136;;;;:::o;2948:137::-;3017:4;3040:38;3070:7;3040:6;:12;3047:4;3040:12;;;;;;;;;;;:20;;:29;;:38;;;;:::i;:::-;3033:45;;2948:137;;;;:::o;2360:85:17:-;2399:13;2431:7;2424:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2360:85;:::o;1725:49:15:-;1770:4;1725:49;;;:::o;6249:266:17:-;6342:4;6358:129;6367:12;:10;:12::i;:::-;6381:7;6390:96;6429:15;6390:96;;;;;;;;;;;;;;;;;:11;:25;6402:12;:10;:12::i;:::-;6390:25;;;;;;;;;;;;;;;:34;6416:7;6390:34;;;;;;;;;;;;;;;;:38;;:96;;;;;:::i;:::-;6358:8;:129::i;:::-;6504:4;6497:11;;6249:266;;;;:::o;3685:172::-;3771:4;3787:42;3797:12;:10;:12::i;:::-;3811:9;3822:6;3787:9;:42::i;:::-;3846:4;3839:11;;3685:172;;;;:::o;3253:125:15:-;3316:7;3342:29;:6;:12;3349:4;3342:12;;;;;;;;;;;:20;;:27;:29::i;:::-;3335:36;;3253:125;;;:::o;294:62:0:-;332:24;294:62;:::o;5099:226:15:-;5183:45;5191:6;:12;5198:4;5191:12;;;;;;;;;;;:22;;;5215:12;:10;:12::i;:::-;5183:7;:45::i;:::-;5175:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5292:26;5304:4;5310:7;5292:11;:26::i;:::-;5099:226;;:::o;3915:149:17:-;4004:7;4030:11;:18;4042:5;4030:18;;;;;;;;;;;;;;;:27;4049:7;4030:27;;;;;;;;;;;;;;;;4023:34;;3915:149;;;;:::o;6429:141:22:-;6499:4;6522:41;6527:3;:10;;6555:5;6547:14;;6539:23;;6522:4;:41::i;:::-;6515:48;;6429:141;;;;:::o;598:104:14:-;651:15;685:10;678:17;;598:104;:::o;9313:340:17:-;9431:1;9414:19;;:5;:19;;;;9406:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9511:1;9492:21;;:7;:21;;;;9484:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9593:6;9563:11;:18;9575:5;9563:18;;;;;;;;;;;;;;;:27;9582:7;9563:27;;;;;;;;;;;;;;;:36;;;;9630:7;9614:32;;9623:5;9614:32;;;9639:6;9614:32;;;;;;;;;;;;;;;;;;9313:340;;;:::o;6989:530::-;7112:1;7094:20;;:6;:20;;;;7086:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7195:1;7174:23;;:9;:23;;;;7166:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7248:47;7269:6;7277:9;7288:6;7248:20;:47::i;:::-;7326:71;7348:6;7326:71;;;;;;;;;;;;;;;;;:9;:17;7336:6;7326:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;7306:9;:17;7316:6;7306:17;;;;;;;;;;;;;;;:91;;;;7430:32;7455:6;7430:9;:20;7440:9;7430:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;7407:9;:20;7417:9;7407:20;;;;;;;;;;;;;;;:55;;;;7494:9;7477:35;;7486:6;7477:35;;;7505:6;7477:35;;;;;;;;;;;;;;;;;;6989:530;;;:::o;1754:187:16:-;1840:7;1872:1;1867;:6;;1875:12;1859:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1898:9;1914:1;1910;:5;1898:17;;1933:1;1926:8;;;1754:187;;;;;:::o;7023:184:15:-;7096:33;7121:7;7096:6;:12;7103:4;7096:12;;;;;;;;;;;:20;;:24;;:33;;;;:::i;:::-;7092:109;;;7177:12;:10;:12::i;:::-;7150:40;;7168:7;7150:40;;7162:4;7150:40;;;;;;;;;;7092:109;7023:184;;:::o;7213:188::-;7287:36;7315:7;7287:6;:12;7294:4;7287:12;;;;;;;;;;;:20;;:27;;:36;;;;:::i;:::-;7283:112;;;7371:12;:10;:12::i;:::-;7344:40;;7362:7;7344:40;;7356:4;7344:40;;;;;;;;;;7283:112;7213:188;;:::o;882:176:16:-;940:7;959:9;975:1;971;:5;959:17;;999:1;994;:6;;986:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1050:1;1043:8;;;882:176;;;;:::o;7790:370:17:-;7892:1;7873:21;;:7;:21;;;;7865:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7941:49;7970:1;7974:7;7983:6;7941:20;:49::i;:::-;8016:24;8033:6;8016:12;;:16;;:24;;;;:::i;:::-;8001:12;:39;;;;8071:30;8094:6;8071:9;:18;8081:7;8071:18;;;;;;;;;;;;;;;;:22;;:30;;;;:::i;:::-;8050:9;:18;8060:7;8050:18;;;;;;;;;;;;;;;:51;;;;8137:7;8116:37;;8133:1;8116:37;;;8146:6;8116:37;;;;;;;;;;;;;;;;;;7790:370;;:::o;7650:147:22:-;7724:7;7766:22;7770:3;:10;;7782:5;7766:3;:22::i;:::-;7758:31;;7743:47;;7650:147;;;;:::o;6966:156::-;7046:4;7069:46;7079:3;:10;;7107:5;7099:14;;7091:23;;7069:9;:46::i;:::-;7062:53;;6966:156;;;;:::o;7203:115::-;7266:7;7292:19;7300:3;:10;;7292:7;:19::i;:::-;7285:26;;7203:115;;;:::o;1640:404::-;1703:4;1724:21;1734:3;1739:5;1724:9;:21::i;:::-;1719:319;;1761:3;:11;;1778:5;1761:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1941:3;:11;;:18;;;;1919:3;:12;;:19;1932:5;1919:19;;;;;;;;;;;:40;;;;1980:4;1973:11;;;;1719:319;2022:5;2015:12;;1640:404;;;;;:::o;852:312:19:-;960:44;987:4;993:2;997:6;960:26;:44::i;:::-;1035:1;1019:18;;:4;:18;;;1015:143;;;1113:4;;1084:25;1102:6;1084:13;:11;:13::i;:::-;:17;;:25;;;;:::i;:::-;:33;;1076:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1015:143;852:312;;;:::o;6738:147:22:-;6811:4;6834:44;6842:3;:10;;6870:5;6862:14;;6854:23;;6834:7;:44::i;:::-;6827:51;;6738:147;;;;:::o;4452:201::-;4519:7;4567:5;4546:3;:11;;:18;;;;:26;4538:73;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4628:3;:11;;4640:5;4628:18;;;;;;;;;;;;;;;;4621:25;;4452:201;;;;:::o;3805:127::-;3878:4;3924:1;3901:3;:12;;:19;3914:5;3901:19;;;;;;;;;;;;:24;;3894:31;;3805:127;;;;:::o;4013:107::-;4069:7;4095:3;:11;;:18;;;;4088:25;;4013:107;;;:::o;10651:92:17:-;;;;:::o;2212:1512:22:-;2278:4;2394:18;2415:3;:12;;:19;2428:5;2415:19;;;;;;;;;;;;2394:40;;2463:1;2449:10;:15;2445:1273;;2806:21;2843:1;2830:10;:14;2806:38;;2858:17;2899:1;2878:3;:11;;:18;;;;:22;2858:42;;3140:17;3160:3;:11;;3172:9;3160:22;;;;;;;;;;;;;;;;3140:42;;3303:9;3274:3;:11;;3286:13;3274:26;;;;;;;;;;;;;;;:38;;;;3420:1;3404:13;:17;3378:3;:12;;:23;3391:9;3378:23;;;;;;;;;;;:43;;;;3527:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;3619:3;:12;;:19;3632:5;3619:19;;;;;;;;;;;3612:26;;;3660:4;3653:11;;;;;;;;2445:1273;3702:5;3695:12;;;2212:1512;;;;;:::o", 571 | "source": "// SPDX-License-Identifier: Sample\n\npragma solidity ^0.6.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20Capped.sol\";\nimport \"@openzeppelin/contracts/access/AccessControl.sol\";\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\n\ncontract HolaCoin is ERC20Capped, AccessControl {\n\n bytes32 public constant MINTER_ROLE = keccak256(\"MINTER_ROLE\");\n uint256 totalSupplyCap = 3000000000 * (10 ** 18);\n\n constructor() public ERC20(\"HOLA COINS\", \"HAC\") ERC20Capped(totalSupplyCap) {\n _setupRole(MINTER_ROLE, msg.sender);\n }\n\n function mint(address to, uint256 amount) public {\n require(hasRole(MINTER_ROLE, msg.sender), \"Caller is not a minter\");\n _mint(to, amount);\n }\n}\n", 572 | "sourcePath": "/Users/sibizulu/Code/dev/knit/truffle/contracts/HolaCoin.sol", 573 | "ast": { 574 | "absolutePath": "/Users/sibizulu/Code/dev/knit/truffle/contracts/HolaCoin.sol", 575 | "exportedSymbols": { 576 | "HolaCoin": [ 577 | 61 578 | ] 579 | }, 580 | "id": 62, 581 | "license": "Sample", 582 | "nodeType": "SourceUnit", 583 | "nodes": [ 584 | { 585 | "id": 1, 586 | "literals": [ 587 | "solidity", 588 | "^", 589 | "0.6", 590 | ".0" 591 | ], 592 | "nodeType": "PragmaDirective", 593 | "src": "36:23:0" 594 | }, 595 | { 596 | "absolutePath": "@openzeppelin/contracts/token/ERC20/ERC20Capped.sol", 597 | "file": "@openzeppelin/contracts/token/ERC20/ERC20Capped.sol", 598 | "id": 2, 599 | "nodeType": "ImportDirective", 600 | "scope": 62, 601 | "sourceUnit": 1906, 602 | "src": "61:61:0", 603 | "symbolAliases": [], 604 | "unitAlias": "" 605 | }, 606 | { 607 | "absolutePath": "@openzeppelin/contracts/access/AccessControl.sol", 608 | "file": "@openzeppelin/contracts/access/AccessControl.sol", 609 | "id": 3, 610 | "nodeType": "ImportDirective", 611 | "scope": 62, 612 | "sourceUnit": 1070, 613 | "src": "123:58:0", 614 | "symbolAliases": [], 615 | "unitAlias": "" 616 | }, 617 | { 618 | "absolutePath": "@openzeppelin/contracts/token/ERC20/ERC20.sol", 619 | "file": "@openzeppelin/contracts/token/ERC20/ERC20.sol", 620 | "id": 4, 621 | "nodeType": "ImportDirective", 622 | "scope": 62, 623 | "sourceUnit": 1769, 624 | "src": "182:55:0", 625 | "symbolAliases": [], 626 | "unitAlias": "" 627 | }, 628 | { 629 | "abstract": false, 630 | "baseContracts": [ 631 | { 632 | "arguments": null, 633 | "baseName": { 634 | "contractScope": null, 635 | "id": 5, 636 | "name": "ERC20Capped", 637 | "nodeType": "UserDefinedTypeName", 638 | "referencedDeclaration": 1905, 639 | "src": "260:11:0", 640 | "typeDescriptions": { 641 | "typeIdentifier": "t_contract$_ERC20Capped_$1905", 642 | "typeString": "contract ERC20Capped" 643 | } 644 | }, 645 | "id": 6, 646 | "nodeType": "InheritanceSpecifier", 647 | "src": "260:11:0" 648 | }, 649 | { 650 | "arguments": null, 651 | "baseName": { 652 | "contractScope": null, 653 | "id": 7, 654 | "name": "AccessControl", 655 | "nodeType": "UserDefinedTypeName", 656 | "referencedDeclaration": 1069, 657 | "src": "273:13:0", 658 | "typeDescriptions": { 659 | "typeIdentifier": "t_contract$_AccessControl_$1069", 660 | "typeString": "contract AccessControl" 661 | } 662 | }, 663 | "id": 8, 664 | "nodeType": "InheritanceSpecifier", 665 | "src": "273:13:0" 666 | } 667 | ], 668 | "contractDependencies": [ 669 | 786, 670 | 1069, 671 | 1768, 672 | 1905, 673 | 1983 674 | ], 675 | "contractKind": "contract", 676 | "documentation": null, 677 | "fullyImplemented": true, 678 | "id": 61, 679 | "linearizedBaseContracts": [ 680 | 61, 681 | 1069, 682 | 1905, 683 | 1768, 684 | 1983, 685 | 786 686 | ], 687 | "name": "HolaCoin", 688 | "nodeType": "ContractDefinition", 689 | "nodes": [ 690 | { 691 | "constant": true, 692 | "functionSelector": "d5391393", 693 | "id": 13, 694 | "mutability": "constant", 695 | "name": "MINTER_ROLE", 696 | "nodeType": "VariableDeclaration", 697 | "overrides": null, 698 | "scope": 61, 699 | "src": "294:62:0", 700 | "stateVariable": true, 701 | "storageLocation": "default", 702 | "typeDescriptions": { 703 | "typeIdentifier": "t_bytes32", 704 | "typeString": "bytes32" 705 | }, 706 | "typeName": { 707 | "id": 9, 708 | "name": "bytes32", 709 | "nodeType": "ElementaryTypeName", 710 | "src": "294:7:0", 711 | "typeDescriptions": { 712 | "typeIdentifier": "t_bytes32", 713 | "typeString": "bytes32" 714 | } 715 | }, 716 | "value": { 717 | "argumentTypes": null, 718 | "arguments": [ 719 | { 720 | "argumentTypes": null, 721 | "hexValue": "4d494e5445525f524f4c45", 722 | "id": 11, 723 | "isConstant": false, 724 | "isLValue": false, 725 | "isPure": true, 726 | "kind": "string", 727 | "lValueRequested": false, 728 | "nodeType": "Literal", 729 | "src": "342:13:0", 730 | "subdenomination": null, 731 | "typeDescriptions": { 732 | "typeIdentifier": "t_stringliteral_9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6", 733 | "typeString": "literal_string \"MINTER_ROLE\"" 734 | }, 735 | "value": "MINTER_ROLE" 736 | } 737 | ], 738 | "expression": { 739 | "argumentTypes": [ 740 | { 741 | "typeIdentifier": "t_stringliteral_9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6", 742 | "typeString": "literal_string \"MINTER_ROLE\"" 743 | } 744 | ], 745 | "id": 10, 746 | "name": "keccak256", 747 | "nodeType": "Identifier", 748 | "overloadedDeclarations": [], 749 | "referencedDeclaration": -8, 750 | "src": "332:9:0", 751 | "typeDescriptions": { 752 | "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", 753 | "typeString": "function (bytes memory) pure returns (bytes32)" 754 | } 755 | }, 756 | "id": 12, 757 | "isConstant": false, 758 | "isLValue": false, 759 | "isPure": true, 760 | "kind": "functionCall", 761 | "lValueRequested": false, 762 | "names": [], 763 | "nodeType": "FunctionCall", 764 | "src": "332:24:0", 765 | "tryCall": false, 766 | "typeDescriptions": { 767 | "typeIdentifier": "t_bytes32", 768 | "typeString": "bytes32" 769 | } 770 | }, 771 | "visibility": "public" 772 | }, 773 | { 774 | "constant": false, 775 | "id": 21, 776 | "mutability": "mutable", 777 | "name": "totalSupplyCap", 778 | "nodeType": "VariableDeclaration", 779 | "overrides": null, 780 | "scope": 61, 781 | "src": "362:49:0", 782 | "stateVariable": true, 783 | "storageLocation": "default", 784 | "typeDescriptions": { 785 | "typeIdentifier": "t_uint256", 786 | "typeString": "uint256" 787 | }, 788 | "typeName": { 789 | "id": 14, 790 | "name": "uint256", 791 | "nodeType": "ElementaryTypeName", 792 | "src": "362:7:0", 793 | "typeDescriptions": { 794 | "typeIdentifier": "t_uint256", 795 | "typeString": "uint256" 796 | } 797 | }, 798 | "value": { 799 | "argumentTypes": null, 800 | "commonType": { 801 | "typeIdentifier": "t_rational_3000000000000000000000000000_by_1", 802 | "typeString": "int_const 3000000000000000000000000000" 803 | }, 804 | "id": 20, 805 | "isConstant": false, 806 | "isLValue": false, 807 | "isPure": true, 808 | "lValueRequested": false, 809 | "leftExpression": { 810 | "argumentTypes": null, 811 | "hexValue": "33303030303030303030", 812 | "id": 15, 813 | "isConstant": false, 814 | "isLValue": false, 815 | "isPure": true, 816 | "kind": "number", 817 | "lValueRequested": false, 818 | "nodeType": "Literal", 819 | "src": "388:10:0", 820 | "subdenomination": null, 821 | "typeDescriptions": { 822 | "typeIdentifier": "t_rational_3000000000_by_1", 823 | "typeString": "int_const 3000000000" 824 | }, 825 | "value": "3000000000" 826 | }, 827 | "nodeType": "BinaryOperation", 828 | "operator": "*", 829 | "rightExpression": { 830 | "argumentTypes": null, 831 | "components": [ 832 | { 833 | "argumentTypes": null, 834 | "commonType": { 835 | "typeIdentifier": "t_rational_1000000000000000000_by_1", 836 | "typeString": "int_const 1000000000000000000" 837 | }, 838 | "id": 18, 839 | "isConstant": false, 840 | "isLValue": false, 841 | "isPure": true, 842 | "lValueRequested": false, 843 | "leftExpression": { 844 | "argumentTypes": null, 845 | "hexValue": "3130", 846 | "id": 16, 847 | "isConstant": false, 848 | "isLValue": false, 849 | "isPure": true, 850 | "kind": "number", 851 | "lValueRequested": false, 852 | "nodeType": "Literal", 853 | "src": "402:2:0", 854 | "subdenomination": null, 855 | "typeDescriptions": { 856 | "typeIdentifier": "t_rational_10_by_1", 857 | "typeString": "int_const 10" 858 | }, 859 | "value": "10" 860 | }, 861 | "nodeType": "BinaryOperation", 862 | "operator": "**", 863 | "rightExpression": { 864 | "argumentTypes": null, 865 | "hexValue": "3138", 866 | "id": 17, 867 | "isConstant": false, 868 | "isLValue": false, 869 | "isPure": true, 870 | "kind": "number", 871 | "lValueRequested": false, 872 | "nodeType": "Literal", 873 | "src": "408:2:0", 874 | "subdenomination": null, 875 | "typeDescriptions": { 876 | "typeIdentifier": "t_rational_18_by_1", 877 | "typeString": "int_const 18" 878 | }, 879 | "value": "18" 880 | }, 881 | "src": "402:8:0", 882 | "typeDescriptions": { 883 | "typeIdentifier": "t_rational_1000000000000000000_by_1", 884 | "typeString": "int_const 1000000000000000000" 885 | } 886 | } 887 | ], 888 | "id": 19, 889 | "isConstant": false, 890 | "isInlineArray": false, 891 | "isLValue": false, 892 | "isPure": true, 893 | "lValueRequested": false, 894 | "nodeType": "TupleExpression", 895 | "src": "401:10:0", 896 | "typeDescriptions": { 897 | "typeIdentifier": "t_rational_1000000000000000000_by_1", 898 | "typeString": "int_const 1000000000000000000" 899 | } 900 | }, 901 | "src": "388:23:0", 902 | "typeDescriptions": { 903 | "typeIdentifier": "t_rational_3000000000000000000000000000_by_1", 904 | "typeString": "int_const 3000000000000000000000000000" 905 | } 906 | }, 907 | "visibility": "internal" 908 | }, 909 | { 910 | "body": { 911 | "id": 37, 912 | "nodeType": "Block", 913 | "src": "494:52:0", 914 | "statements": [ 915 | { 916 | "expression": { 917 | "argumentTypes": null, 918 | "arguments": [ 919 | { 920 | "argumentTypes": null, 921 | "id": 32, 922 | "name": "MINTER_ROLE", 923 | "nodeType": "Identifier", 924 | "overloadedDeclarations": [], 925 | "referencedDeclaration": 13, 926 | "src": "515:11:0", 927 | "typeDescriptions": { 928 | "typeIdentifier": "t_bytes32", 929 | "typeString": "bytes32" 930 | } 931 | }, 932 | { 933 | "argumentTypes": null, 934 | "expression": { 935 | "argumentTypes": null, 936 | "id": 33, 937 | "name": "msg", 938 | "nodeType": "Identifier", 939 | "overloadedDeclarations": [], 940 | "referencedDeclaration": -15, 941 | "src": "528:3:0", 942 | "typeDescriptions": { 943 | "typeIdentifier": "t_magic_message", 944 | "typeString": "msg" 945 | } 946 | }, 947 | "id": 34, 948 | "isConstant": false, 949 | "isLValue": false, 950 | "isPure": false, 951 | "lValueRequested": false, 952 | "memberName": "sender", 953 | "nodeType": "MemberAccess", 954 | "referencedDeclaration": null, 955 | "src": "528:10:0", 956 | "typeDescriptions": { 957 | "typeIdentifier": "t_address_payable", 958 | "typeString": "address payable" 959 | } 960 | } 961 | ], 962 | "expression": { 963 | "argumentTypes": [ 964 | { 965 | "typeIdentifier": "t_bytes32", 966 | "typeString": "bytes32" 967 | }, 968 | { 969 | "typeIdentifier": "t_address_payable", 970 | "typeString": "address payable" 971 | } 972 | ], 973 | "id": 31, 974 | "name": "_setupRole", 975 | "nodeType": "Identifier", 976 | "overloadedDeclarations": [], 977 | "referencedDeclaration": 995, 978 | "src": "504:10:0", 979 | "typeDescriptions": { 980 | "typeIdentifier": "t_function_internal_nonpayable$_t_bytes32_$_t_address_$returns$__$", 981 | "typeString": "function (bytes32,address)" 982 | } 983 | }, 984 | "id": 35, 985 | "isConstant": false, 986 | "isLValue": false, 987 | "isPure": false, 988 | "kind": "functionCall", 989 | "lValueRequested": false, 990 | "names": [], 991 | "nodeType": "FunctionCall", 992 | "src": "504:35:0", 993 | "tryCall": false, 994 | "typeDescriptions": { 995 | "typeIdentifier": "t_tuple$__$", 996 | "typeString": "tuple()" 997 | } 998 | }, 999 | "id": 36, 1000 | "nodeType": "ExpressionStatement", 1001 | "src": "504:35:0" 1002 | } 1003 | ] 1004 | }, 1005 | "documentation": null, 1006 | "id": 38, 1007 | "implemented": true, 1008 | "kind": "constructor", 1009 | "modifiers": [ 1010 | { 1011 | "arguments": [ 1012 | { 1013 | "argumentTypes": null, 1014 | "hexValue": "484f4c4120434f494e53", 1015 | "id": 24, 1016 | "isConstant": false, 1017 | "isLValue": false, 1018 | "isPure": true, 1019 | "kind": "string", 1020 | "lValueRequested": false, 1021 | "nodeType": "Literal", 1022 | "src": "445:12:0", 1023 | "subdenomination": null, 1024 | "typeDescriptions": { 1025 | "typeIdentifier": "t_stringliteral_d297255043dfd6e1c00140aa547ba42a32d4498552b04b7db47d50c5809ab286", 1026 | "typeString": "literal_string \"HOLA COINS\"" 1027 | }, 1028 | "value": "HOLA COINS" 1029 | }, 1030 | { 1031 | "argumentTypes": null, 1032 | "hexValue": "484143", 1033 | "id": 25, 1034 | "isConstant": false, 1035 | "isLValue": false, 1036 | "isPure": true, 1037 | "kind": "string", 1038 | "lValueRequested": false, 1039 | "nodeType": "Literal", 1040 | "src": "459:5:0", 1041 | "subdenomination": null, 1042 | "typeDescriptions": { 1043 | "typeIdentifier": "t_stringliteral_da0bc37554bca5519847da84319136d329a77922f37f56c0e763034a1b82b4d2", 1044 | "typeString": "literal_string \"HAC\"" 1045 | }, 1046 | "value": "HAC" 1047 | } 1048 | ], 1049 | "id": 26, 1050 | "modifierName": { 1051 | "argumentTypes": null, 1052 | "id": 23, 1053 | "name": "ERC20", 1054 | "nodeType": "Identifier", 1055 | "overloadedDeclarations": [], 1056 | "referencedDeclaration": 1768, 1057 | "src": "439:5:0", 1058 | "typeDescriptions": { 1059 | "typeIdentifier": "t_type$_t_contract$_ERC20_$1768_$", 1060 | "typeString": "type(contract ERC20)" 1061 | } 1062 | }, 1063 | "nodeType": "ModifierInvocation", 1064 | "src": "439:26:0" 1065 | }, 1066 | { 1067 | "arguments": [ 1068 | { 1069 | "argumentTypes": null, 1070 | "id": 28, 1071 | "name": "totalSupplyCap", 1072 | "nodeType": "Identifier", 1073 | "overloadedDeclarations": [], 1074 | "referencedDeclaration": 21, 1075 | "src": "478:14:0", 1076 | "typeDescriptions": { 1077 | "typeIdentifier": "t_uint256", 1078 | "typeString": "uint256" 1079 | } 1080 | } 1081 | ], 1082 | "id": 29, 1083 | "modifierName": { 1084 | "argumentTypes": null, 1085 | "id": 27, 1086 | "name": "ERC20Capped", 1087 | "nodeType": "Identifier", 1088 | "overloadedDeclarations": [], 1089 | "referencedDeclaration": 1905, 1090 | "src": "466:11:0", 1091 | "typeDescriptions": { 1092 | "typeIdentifier": "t_type$_t_contract$_ERC20Capped_$1905_$", 1093 | "typeString": "type(contract ERC20Capped)" 1094 | } 1095 | }, 1096 | "nodeType": "ModifierInvocation", 1097 | "src": "466:27:0" 1098 | } 1099 | ], 1100 | "name": "", 1101 | "nodeType": "FunctionDefinition", 1102 | "overrides": null, 1103 | "parameters": { 1104 | "id": 22, 1105 | "nodeType": "ParameterList", 1106 | "parameters": [], 1107 | "src": "429:2:0" 1108 | }, 1109 | "returnParameters": { 1110 | "id": 30, 1111 | "nodeType": "ParameterList", 1112 | "parameters": [], 1113 | "src": "494:0:0" 1114 | }, 1115 | "scope": 61, 1116 | "src": "418:128:0", 1117 | "stateMutability": "nonpayable", 1118 | "virtual": false, 1119 | "visibility": "public" 1120 | }, 1121 | { 1122 | "body": { 1123 | "id": 59, 1124 | "nodeType": "Block", 1125 | "src": "601:111:0", 1126 | "statements": [ 1127 | { 1128 | "expression": { 1129 | "argumentTypes": null, 1130 | "arguments": [ 1131 | { 1132 | "argumentTypes": null, 1133 | "arguments": [ 1134 | { 1135 | "argumentTypes": null, 1136 | "id": 47, 1137 | "name": "MINTER_ROLE", 1138 | "nodeType": "Identifier", 1139 | "overloadedDeclarations": [], 1140 | "referencedDeclaration": 13, 1141 | "src": "627:11:0", 1142 | "typeDescriptions": { 1143 | "typeIdentifier": "t_bytes32", 1144 | "typeString": "bytes32" 1145 | } 1146 | }, 1147 | { 1148 | "argumentTypes": null, 1149 | "expression": { 1150 | "argumentTypes": null, 1151 | "id": 48, 1152 | "name": "msg", 1153 | "nodeType": "Identifier", 1154 | "overloadedDeclarations": [], 1155 | "referencedDeclaration": -15, 1156 | "src": "640:3:0", 1157 | "typeDescriptions": { 1158 | "typeIdentifier": "t_magic_message", 1159 | "typeString": "msg" 1160 | } 1161 | }, 1162 | "id": 49, 1163 | "isConstant": false, 1164 | "isLValue": false, 1165 | "isPure": false, 1166 | "lValueRequested": false, 1167 | "memberName": "sender", 1168 | "nodeType": "MemberAccess", 1169 | "referencedDeclaration": null, 1170 | "src": "640:10:0", 1171 | "typeDescriptions": { 1172 | "typeIdentifier": "t_address_payable", 1173 | "typeString": "address payable" 1174 | } 1175 | } 1176 | ], 1177 | "expression": { 1178 | "argumentTypes": [ 1179 | { 1180 | "typeIdentifier": "t_bytes32", 1181 | "typeString": "bytes32" 1182 | }, 1183 | { 1184 | "typeIdentifier": "t_address_payable", 1185 | "typeString": "address payable" 1186 | } 1187 | ], 1188 | "id": 46, 1189 | "name": "hasRole", 1190 | "nodeType": "Identifier", 1191 | "overloadedDeclarations": [], 1192 | "referencedDeclaration": 858, 1193 | "src": "619:7:0", 1194 | "typeDescriptions": { 1195 | "typeIdentifier": "t_function_internal_view$_t_bytes32_$_t_address_$returns$_t_bool_$", 1196 | "typeString": "function (bytes32,address) view returns (bool)" 1197 | } 1198 | }, 1199 | "id": 50, 1200 | "isConstant": false, 1201 | "isLValue": false, 1202 | "isPure": false, 1203 | "kind": "functionCall", 1204 | "lValueRequested": false, 1205 | "names": [], 1206 | "nodeType": "FunctionCall", 1207 | "src": "619:32:0", 1208 | "tryCall": false, 1209 | "typeDescriptions": { 1210 | "typeIdentifier": "t_bool", 1211 | "typeString": "bool" 1212 | } 1213 | }, 1214 | { 1215 | "argumentTypes": null, 1216 | "hexValue": "43616c6c6572206973206e6f742061206d696e746572", 1217 | "id": 51, 1218 | "isConstant": false, 1219 | "isLValue": false, 1220 | "isPure": true, 1221 | "kind": "string", 1222 | "lValueRequested": false, 1223 | "nodeType": "Literal", 1224 | "src": "653:24:0", 1225 | "subdenomination": null, 1226 | "typeDescriptions": { 1227 | "typeIdentifier": "t_stringliteral_71abfcf6e817aaed3ce6663958bac2a3a82999ed0036c98a95b29f350f04cedf", 1228 | "typeString": "literal_string \"Caller is not a minter\"" 1229 | }, 1230 | "value": "Caller is not a minter" 1231 | } 1232 | ], 1233 | "expression": { 1234 | "argumentTypes": [ 1235 | { 1236 | "typeIdentifier": "t_bool", 1237 | "typeString": "bool" 1238 | }, 1239 | { 1240 | "typeIdentifier": "t_stringliteral_71abfcf6e817aaed3ce6663958bac2a3a82999ed0036c98a95b29f350f04cedf", 1241 | "typeString": "literal_string \"Caller is not a minter\"" 1242 | } 1243 | ], 1244 | "id": 45, 1245 | "name": "require", 1246 | "nodeType": "Identifier", 1247 | "overloadedDeclarations": [ 1248 | -18, 1249 | -18 1250 | ], 1251 | "referencedDeclaration": -18, 1252 | "src": "611:7:0", 1253 | "typeDescriptions": { 1254 | "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", 1255 | "typeString": "function (bool,string memory) pure" 1256 | } 1257 | }, 1258 | "id": 52, 1259 | "isConstant": false, 1260 | "isLValue": false, 1261 | "isPure": false, 1262 | "kind": "functionCall", 1263 | "lValueRequested": false, 1264 | "names": [], 1265 | "nodeType": "FunctionCall", 1266 | "src": "611:67:0", 1267 | "tryCall": false, 1268 | "typeDescriptions": { 1269 | "typeIdentifier": "t_tuple$__$", 1270 | "typeString": "tuple()" 1271 | } 1272 | }, 1273 | "id": 53, 1274 | "nodeType": "ExpressionStatement", 1275 | "src": "611:67:0" 1276 | }, 1277 | { 1278 | "expression": { 1279 | "argumentTypes": null, 1280 | "arguments": [ 1281 | { 1282 | "argumentTypes": null, 1283 | "id": 55, 1284 | "name": "to", 1285 | "nodeType": "Identifier", 1286 | "overloadedDeclarations": [], 1287 | "referencedDeclaration": 40, 1288 | "src": "694:2:0", 1289 | "typeDescriptions": { 1290 | "typeIdentifier": "t_address", 1291 | "typeString": "address" 1292 | } 1293 | }, 1294 | { 1295 | "argumentTypes": null, 1296 | "id": 56, 1297 | "name": "amount", 1298 | "nodeType": "Identifier", 1299 | "overloadedDeclarations": [], 1300 | "referencedDeclaration": 42, 1301 | "src": "698:6:0", 1302 | "typeDescriptions": { 1303 | "typeIdentifier": "t_uint256", 1304 | "typeString": "uint256" 1305 | } 1306 | } 1307 | ], 1308 | "expression": { 1309 | "argumentTypes": [ 1310 | { 1311 | "typeIdentifier": "t_address", 1312 | "typeString": "address" 1313 | }, 1314 | { 1315 | "typeIdentifier": "t_uint256", 1316 | "typeString": "uint256" 1317 | } 1318 | ], 1319 | "id": 54, 1320 | "name": "_mint", 1321 | "nodeType": "Identifier", 1322 | "overloadedDeclarations": [], 1323 | "referencedDeclaration": 1644, 1324 | "src": "688:5:0", 1325 | "typeDescriptions": { 1326 | "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_uint256_$returns$__$", 1327 | "typeString": "function (address,uint256)" 1328 | } 1329 | }, 1330 | "id": 57, 1331 | "isConstant": false, 1332 | "isLValue": false, 1333 | "isPure": false, 1334 | "kind": "functionCall", 1335 | "lValueRequested": false, 1336 | "names": [], 1337 | "nodeType": "FunctionCall", 1338 | "src": "688:17:0", 1339 | "tryCall": false, 1340 | "typeDescriptions": { 1341 | "typeIdentifier": "t_tuple$__$", 1342 | "typeString": "tuple()" 1343 | } 1344 | }, 1345 | "id": 58, 1346 | "nodeType": "ExpressionStatement", 1347 | "src": "688:17:0" 1348 | } 1349 | ] 1350 | }, 1351 | "documentation": null, 1352 | "functionSelector": "40c10f19", 1353 | "id": 60, 1354 | "implemented": true, 1355 | "kind": "function", 1356 | "modifiers": [], 1357 | "name": "mint", 1358 | "nodeType": "FunctionDefinition", 1359 | "overrides": null, 1360 | "parameters": { 1361 | "id": 43, 1362 | "nodeType": "ParameterList", 1363 | "parameters": [ 1364 | { 1365 | "constant": false, 1366 | "id": 40, 1367 | "mutability": "mutable", 1368 | "name": "to", 1369 | "nodeType": "VariableDeclaration", 1370 | "overrides": null, 1371 | "scope": 60, 1372 | "src": "566:10:0", 1373 | "stateVariable": false, 1374 | "storageLocation": "default", 1375 | "typeDescriptions": { 1376 | "typeIdentifier": "t_address", 1377 | "typeString": "address" 1378 | }, 1379 | "typeName": { 1380 | "id": 39, 1381 | "name": "address", 1382 | "nodeType": "ElementaryTypeName", 1383 | "src": "566:7:0", 1384 | "stateMutability": "nonpayable", 1385 | "typeDescriptions": { 1386 | "typeIdentifier": "t_address", 1387 | "typeString": "address" 1388 | } 1389 | }, 1390 | "value": null, 1391 | "visibility": "internal" 1392 | }, 1393 | { 1394 | "constant": false, 1395 | "id": 42, 1396 | "mutability": "mutable", 1397 | "name": "amount", 1398 | "nodeType": "VariableDeclaration", 1399 | "overrides": null, 1400 | "scope": 60, 1401 | "src": "578:14:0", 1402 | "stateVariable": false, 1403 | "storageLocation": "default", 1404 | "typeDescriptions": { 1405 | "typeIdentifier": "t_uint256", 1406 | "typeString": "uint256" 1407 | }, 1408 | "typeName": { 1409 | "id": 41, 1410 | "name": "uint256", 1411 | "nodeType": "ElementaryTypeName", 1412 | "src": "578:7:0", 1413 | "typeDescriptions": { 1414 | "typeIdentifier": "t_uint256", 1415 | "typeString": "uint256" 1416 | } 1417 | }, 1418 | "value": null, 1419 | "visibility": "internal" 1420 | } 1421 | ], 1422 | "src": "565:28:0" 1423 | }, 1424 | "returnParameters": { 1425 | "id": 44, 1426 | "nodeType": "ParameterList", 1427 | "parameters": [], 1428 | "src": "601:0:0" 1429 | }, 1430 | "scope": 61, 1431 | "src": "552:160:0", 1432 | "stateMutability": "nonpayable", 1433 | "virtual": false, 1434 | "visibility": "public" 1435 | } 1436 | ], 1437 | "scope": 62, 1438 | "src": "239:475:0" 1439 | } 1440 | ], 1441 | "src": "36:679:0" 1442 | }, 1443 | "legacyAST": { 1444 | "absolutePath": "/Users/sibizulu/Code/dev/knit/truffle/contracts/HolaCoin.sol", 1445 | "exportedSymbols": { 1446 | "HolaCoin": [ 1447 | 61 1448 | ] 1449 | }, 1450 | "id": 62, 1451 | "license": "Sample", 1452 | "nodeType": "SourceUnit", 1453 | "nodes": [ 1454 | { 1455 | "id": 1, 1456 | "literals": [ 1457 | "solidity", 1458 | "^", 1459 | "0.6", 1460 | ".0" 1461 | ], 1462 | "nodeType": "PragmaDirective", 1463 | "src": "36:23:0" 1464 | }, 1465 | { 1466 | "absolutePath": "@openzeppelin/contracts/token/ERC20/ERC20Capped.sol", 1467 | "file": "@openzeppelin/contracts/token/ERC20/ERC20Capped.sol", 1468 | "id": 2, 1469 | "nodeType": "ImportDirective", 1470 | "scope": 62, 1471 | "sourceUnit": 1906, 1472 | "src": "61:61:0", 1473 | "symbolAliases": [], 1474 | "unitAlias": "" 1475 | }, 1476 | { 1477 | "absolutePath": "@openzeppelin/contracts/access/AccessControl.sol", 1478 | "file": "@openzeppelin/contracts/access/AccessControl.sol", 1479 | "id": 3, 1480 | "nodeType": "ImportDirective", 1481 | "scope": 62, 1482 | "sourceUnit": 1070, 1483 | "src": "123:58:0", 1484 | "symbolAliases": [], 1485 | "unitAlias": "" 1486 | }, 1487 | { 1488 | "absolutePath": "@openzeppelin/contracts/token/ERC20/ERC20.sol", 1489 | "file": "@openzeppelin/contracts/token/ERC20/ERC20.sol", 1490 | "id": 4, 1491 | "nodeType": "ImportDirective", 1492 | "scope": 62, 1493 | "sourceUnit": 1769, 1494 | "src": "182:55:0", 1495 | "symbolAliases": [], 1496 | "unitAlias": "" 1497 | }, 1498 | { 1499 | "abstract": false, 1500 | "baseContracts": [ 1501 | { 1502 | "arguments": null, 1503 | "baseName": { 1504 | "contractScope": null, 1505 | "id": 5, 1506 | "name": "ERC20Capped", 1507 | "nodeType": "UserDefinedTypeName", 1508 | "referencedDeclaration": 1905, 1509 | "src": "260:11:0", 1510 | "typeDescriptions": { 1511 | "typeIdentifier": "t_contract$_ERC20Capped_$1905", 1512 | "typeString": "contract ERC20Capped" 1513 | } 1514 | }, 1515 | "id": 6, 1516 | "nodeType": "InheritanceSpecifier", 1517 | "src": "260:11:0" 1518 | }, 1519 | { 1520 | "arguments": null, 1521 | "baseName": { 1522 | "contractScope": null, 1523 | "id": 7, 1524 | "name": "AccessControl", 1525 | "nodeType": "UserDefinedTypeName", 1526 | "referencedDeclaration": 1069, 1527 | "src": "273:13:0", 1528 | "typeDescriptions": { 1529 | "typeIdentifier": "t_contract$_AccessControl_$1069", 1530 | "typeString": "contract AccessControl" 1531 | } 1532 | }, 1533 | "id": 8, 1534 | "nodeType": "InheritanceSpecifier", 1535 | "src": "273:13:0" 1536 | } 1537 | ], 1538 | "contractDependencies": [ 1539 | 786, 1540 | 1069, 1541 | 1768, 1542 | 1905, 1543 | 1983 1544 | ], 1545 | "contractKind": "contract", 1546 | "documentation": null, 1547 | "fullyImplemented": true, 1548 | "id": 61, 1549 | "linearizedBaseContracts": [ 1550 | 61, 1551 | 1069, 1552 | 1905, 1553 | 1768, 1554 | 1983, 1555 | 786 1556 | ], 1557 | "name": "HolaCoin", 1558 | "nodeType": "ContractDefinition", 1559 | "nodes": [ 1560 | { 1561 | "constant": true, 1562 | "functionSelector": "d5391393", 1563 | "id": 13, 1564 | "mutability": "constant", 1565 | "name": "MINTER_ROLE", 1566 | "nodeType": "VariableDeclaration", 1567 | "overrides": null, 1568 | "scope": 61, 1569 | "src": "294:62:0", 1570 | "stateVariable": true, 1571 | "storageLocation": "default", 1572 | "typeDescriptions": { 1573 | "typeIdentifier": "t_bytes32", 1574 | "typeString": "bytes32" 1575 | }, 1576 | "typeName": { 1577 | "id": 9, 1578 | "name": "bytes32", 1579 | "nodeType": "ElementaryTypeName", 1580 | "src": "294:7:0", 1581 | "typeDescriptions": { 1582 | "typeIdentifier": "t_bytes32", 1583 | "typeString": "bytes32" 1584 | } 1585 | }, 1586 | "value": { 1587 | "argumentTypes": null, 1588 | "arguments": [ 1589 | { 1590 | "argumentTypes": null, 1591 | "hexValue": "4d494e5445525f524f4c45", 1592 | "id": 11, 1593 | "isConstant": false, 1594 | "isLValue": false, 1595 | "isPure": true, 1596 | "kind": "string", 1597 | "lValueRequested": false, 1598 | "nodeType": "Literal", 1599 | "src": "342:13:0", 1600 | "subdenomination": null, 1601 | "typeDescriptions": { 1602 | "typeIdentifier": "t_stringliteral_9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6", 1603 | "typeString": "literal_string \"MINTER_ROLE\"" 1604 | }, 1605 | "value": "MINTER_ROLE" 1606 | } 1607 | ], 1608 | "expression": { 1609 | "argumentTypes": [ 1610 | { 1611 | "typeIdentifier": "t_stringliteral_9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6", 1612 | "typeString": "literal_string \"MINTER_ROLE\"" 1613 | } 1614 | ], 1615 | "id": 10, 1616 | "name": "keccak256", 1617 | "nodeType": "Identifier", 1618 | "overloadedDeclarations": [], 1619 | "referencedDeclaration": -8, 1620 | "src": "332:9:0", 1621 | "typeDescriptions": { 1622 | "typeIdentifier": "t_function_keccak256_pure$_t_bytes_memory_ptr_$returns$_t_bytes32_$", 1623 | "typeString": "function (bytes memory) pure returns (bytes32)" 1624 | } 1625 | }, 1626 | "id": 12, 1627 | "isConstant": false, 1628 | "isLValue": false, 1629 | "isPure": true, 1630 | "kind": "functionCall", 1631 | "lValueRequested": false, 1632 | "names": [], 1633 | "nodeType": "FunctionCall", 1634 | "src": "332:24:0", 1635 | "tryCall": false, 1636 | "typeDescriptions": { 1637 | "typeIdentifier": "t_bytes32", 1638 | "typeString": "bytes32" 1639 | } 1640 | }, 1641 | "visibility": "public" 1642 | }, 1643 | { 1644 | "constant": false, 1645 | "id": 21, 1646 | "mutability": "mutable", 1647 | "name": "totalSupplyCap", 1648 | "nodeType": "VariableDeclaration", 1649 | "overrides": null, 1650 | "scope": 61, 1651 | "src": "362:49:0", 1652 | "stateVariable": true, 1653 | "storageLocation": "default", 1654 | "typeDescriptions": { 1655 | "typeIdentifier": "t_uint256", 1656 | "typeString": "uint256" 1657 | }, 1658 | "typeName": { 1659 | "id": 14, 1660 | "name": "uint256", 1661 | "nodeType": "ElementaryTypeName", 1662 | "src": "362:7:0", 1663 | "typeDescriptions": { 1664 | "typeIdentifier": "t_uint256", 1665 | "typeString": "uint256" 1666 | } 1667 | }, 1668 | "value": { 1669 | "argumentTypes": null, 1670 | "commonType": { 1671 | "typeIdentifier": "t_rational_3000000000000000000000000000_by_1", 1672 | "typeString": "int_const 3000000000000000000000000000" 1673 | }, 1674 | "id": 20, 1675 | "isConstant": false, 1676 | "isLValue": false, 1677 | "isPure": true, 1678 | "lValueRequested": false, 1679 | "leftExpression": { 1680 | "argumentTypes": null, 1681 | "hexValue": "33303030303030303030", 1682 | "id": 15, 1683 | "isConstant": false, 1684 | "isLValue": false, 1685 | "isPure": true, 1686 | "kind": "number", 1687 | "lValueRequested": false, 1688 | "nodeType": "Literal", 1689 | "src": "388:10:0", 1690 | "subdenomination": null, 1691 | "typeDescriptions": { 1692 | "typeIdentifier": "t_rational_3000000000_by_1", 1693 | "typeString": "int_const 3000000000" 1694 | }, 1695 | "value": "3000000000" 1696 | }, 1697 | "nodeType": "BinaryOperation", 1698 | "operator": "*", 1699 | "rightExpression": { 1700 | "argumentTypes": null, 1701 | "components": [ 1702 | { 1703 | "argumentTypes": null, 1704 | "commonType": { 1705 | "typeIdentifier": "t_rational_1000000000000000000_by_1", 1706 | "typeString": "int_const 1000000000000000000" 1707 | }, 1708 | "id": 18, 1709 | "isConstant": false, 1710 | "isLValue": false, 1711 | "isPure": true, 1712 | "lValueRequested": false, 1713 | "leftExpression": { 1714 | "argumentTypes": null, 1715 | "hexValue": "3130", 1716 | "id": 16, 1717 | "isConstant": false, 1718 | "isLValue": false, 1719 | "isPure": true, 1720 | "kind": "number", 1721 | "lValueRequested": false, 1722 | "nodeType": "Literal", 1723 | "src": "402:2:0", 1724 | "subdenomination": null, 1725 | "typeDescriptions": { 1726 | "typeIdentifier": "t_rational_10_by_1", 1727 | "typeString": "int_const 10" 1728 | }, 1729 | "value": "10" 1730 | }, 1731 | "nodeType": "BinaryOperation", 1732 | "operator": "**", 1733 | "rightExpression": { 1734 | "argumentTypes": null, 1735 | "hexValue": "3138", 1736 | "id": 17, 1737 | "isConstant": false, 1738 | "isLValue": false, 1739 | "isPure": true, 1740 | "kind": "number", 1741 | "lValueRequested": false, 1742 | "nodeType": "Literal", 1743 | "src": "408:2:0", 1744 | "subdenomination": null, 1745 | "typeDescriptions": { 1746 | "typeIdentifier": "t_rational_18_by_1", 1747 | "typeString": "int_const 18" 1748 | }, 1749 | "value": "18" 1750 | }, 1751 | "src": "402:8:0", 1752 | "typeDescriptions": { 1753 | "typeIdentifier": "t_rational_1000000000000000000_by_1", 1754 | "typeString": "int_const 1000000000000000000" 1755 | } 1756 | } 1757 | ], 1758 | "id": 19, 1759 | "isConstant": false, 1760 | "isInlineArray": false, 1761 | "isLValue": false, 1762 | "isPure": true, 1763 | "lValueRequested": false, 1764 | "nodeType": "TupleExpression", 1765 | "src": "401:10:0", 1766 | "typeDescriptions": { 1767 | "typeIdentifier": "t_rational_1000000000000000000_by_1", 1768 | "typeString": "int_const 1000000000000000000" 1769 | } 1770 | }, 1771 | "src": "388:23:0", 1772 | "typeDescriptions": { 1773 | "typeIdentifier": "t_rational_3000000000000000000000000000_by_1", 1774 | "typeString": "int_const 3000000000000000000000000000" 1775 | } 1776 | }, 1777 | "visibility": "internal" 1778 | }, 1779 | { 1780 | "body": { 1781 | "id": 37, 1782 | "nodeType": "Block", 1783 | "src": "494:52:0", 1784 | "statements": [ 1785 | { 1786 | "expression": { 1787 | "argumentTypes": null, 1788 | "arguments": [ 1789 | { 1790 | "argumentTypes": null, 1791 | "id": 32, 1792 | "name": "MINTER_ROLE", 1793 | "nodeType": "Identifier", 1794 | "overloadedDeclarations": [], 1795 | "referencedDeclaration": 13, 1796 | "src": "515:11:0", 1797 | "typeDescriptions": { 1798 | "typeIdentifier": "t_bytes32", 1799 | "typeString": "bytes32" 1800 | } 1801 | }, 1802 | { 1803 | "argumentTypes": null, 1804 | "expression": { 1805 | "argumentTypes": null, 1806 | "id": 33, 1807 | "name": "msg", 1808 | "nodeType": "Identifier", 1809 | "overloadedDeclarations": [], 1810 | "referencedDeclaration": -15, 1811 | "src": "528:3:0", 1812 | "typeDescriptions": { 1813 | "typeIdentifier": "t_magic_message", 1814 | "typeString": "msg" 1815 | } 1816 | }, 1817 | "id": 34, 1818 | "isConstant": false, 1819 | "isLValue": false, 1820 | "isPure": false, 1821 | "lValueRequested": false, 1822 | "memberName": "sender", 1823 | "nodeType": "MemberAccess", 1824 | "referencedDeclaration": null, 1825 | "src": "528:10:0", 1826 | "typeDescriptions": { 1827 | "typeIdentifier": "t_address_payable", 1828 | "typeString": "address payable" 1829 | } 1830 | } 1831 | ], 1832 | "expression": { 1833 | "argumentTypes": [ 1834 | { 1835 | "typeIdentifier": "t_bytes32", 1836 | "typeString": "bytes32" 1837 | }, 1838 | { 1839 | "typeIdentifier": "t_address_payable", 1840 | "typeString": "address payable" 1841 | } 1842 | ], 1843 | "id": 31, 1844 | "name": "_setupRole", 1845 | "nodeType": "Identifier", 1846 | "overloadedDeclarations": [], 1847 | "referencedDeclaration": 995, 1848 | "src": "504:10:0", 1849 | "typeDescriptions": { 1850 | "typeIdentifier": "t_function_internal_nonpayable$_t_bytes32_$_t_address_$returns$__$", 1851 | "typeString": "function (bytes32,address)" 1852 | } 1853 | }, 1854 | "id": 35, 1855 | "isConstant": false, 1856 | "isLValue": false, 1857 | "isPure": false, 1858 | "kind": "functionCall", 1859 | "lValueRequested": false, 1860 | "names": [], 1861 | "nodeType": "FunctionCall", 1862 | "src": "504:35:0", 1863 | "tryCall": false, 1864 | "typeDescriptions": { 1865 | "typeIdentifier": "t_tuple$__$", 1866 | "typeString": "tuple()" 1867 | } 1868 | }, 1869 | "id": 36, 1870 | "nodeType": "ExpressionStatement", 1871 | "src": "504:35:0" 1872 | } 1873 | ] 1874 | }, 1875 | "documentation": null, 1876 | "id": 38, 1877 | "implemented": true, 1878 | "kind": "constructor", 1879 | "modifiers": [ 1880 | { 1881 | "arguments": [ 1882 | { 1883 | "argumentTypes": null, 1884 | "hexValue": "484f4c4120434f494e53", 1885 | "id": 24, 1886 | "isConstant": false, 1887 | "isLValue": false, 1888 | "isPure": true, 1889 | "kind": "string", 1890 | "lValueRequested": false, 1891 | "nodeType": "Literal", 1892 | "src": "445:12:0", 1893 | "subdenomination": null, 1894 | "typeDescriptions": { 1895 | "typeIdentifier": "t_stringliteral_d297255043dfd6e1c00140aa547ba42a32d4498552b04b7db47d50c5809ab286", 1896 | "typeString": "literal_string \"HOLA COINS\"" 1897 | }, 1898 | "value": "HOLA COINS" 1899 | }, 1900 | { 1901 | "argumentTypes": null, 1902 | "hexValue": "484143", 1903 | "id": 25, 1904 | "isConstant": false, 1905 | "isLValue": false, 1906 | "isPure": true, 1907 | "kind": "string", 1908 | "lValueRequested": false, 1909 | "nodeType": "Literal", 1910 | "src": "459:5:0", 1911 | "subdenomination": null, 1912 | "typeDescriptions": { 1913 | "typeIdentifier": "t_stringliteral_da0bc37554bca5519847da84319136d329a77922f37f56c0e763034a1b82b4d2", 1914 | "typeString": "literal_string \"HAC\"" 1915 | }, 1916 | "value": "HAC" 1917 | } 1918 | ], 1919 | "id": 26, 1920 | "modifierName": { 1921 | "argumentTypes": null, 1922 | "id": 23, 1923 | "name": "ERC20", 1924 | "nodeType": "Identifier", 1925 | "overloadedDeclarations": [], 1926 | "referencedDeclaration": 1768, 1927 | "src": "439:5:0", 1928 | "typeDescriptions": { 1929 | "typeIdentifier": "t_type$_t_contract$_ERC20_$1768_$", 1930 | "typeString": "type(contract ERC20)" 1931 | } 1932 | }, 1933 | "nodeType": "ModifierInvocation", 1934 | "src": "439:26:0" 1935 | }, 1936 | { 1937 | "arguments": [ 1938 | { 1939 | "argumentTypes": null, 1940 | "id": 28, 1941 | "name": "totalSupplyCap", 1942 | "nodeType": "Identifier", 1943 | "overloadedDeclarations": [], 1944 | "referencedDeclaration": 21, 1945 | "src": "478:14:0", 1946 | "typeDescriptions": { 1947 | "typeIdentifier": "t_uint256", 1948 | "typeString": "uint256" 1949 | } 1950 | } 1951 | ], 1952 | "id": 29, 1953 | "modifierName": { 1954 | "argumentTypes": null, 1955 | "id": 27, 1956 | "name": "ERC20Capped", 1957 | "nodeType": "Identifier", 1958 | "overloadedDeclarations": [], 1959 | "referencedDeclaration": 1905, 1960 | "src": "466:11:0", 1961 | "typeDescriptions": { 1962 | "typeIdentifier": "t_type$_t_contract$_ERC20Capped_$1905_$", 1963 | "typeString": "type(contract ERC20Capped)" 1964 | } 1965 | }, 1966 | "nodeType": "ModifierInvocation", 1967 | "src": "466:27:0" 1968 | } 1969 | ], 1970 | "name": "", 1971 | "nodeType": "FunctionDefinition", 1972 | "overrides": null, 1973 | "parameters": { 1974 | "id": 22, 1975 | "nodeType": "ParameterList", 1976 | "parameters": [], 1977 | "src": "429:2:0" 1978 | }, 1979 | "returnParameters": { 1980 | "id": 30, 1981 | "nodeType": "ParameterList", 1982 | "parameters": [], 1983 | "src": "494:0:0" 1984 | }, 1985 | "scope": 61, 1986 | "src": "418:128:0", 1987 | "stateMutability": "nonpayable", 1988 | "virtual": false, 1989 | "visibility": "public" 1990 | }, 1991 | { 1992 | "body": { 1993 | "id": 59, 1994 | "nodeType": "Block", 1995 | "src": "601:111:0", 1996 | "statements": [ 1997 | { 1998 | "expression": { 1999 | "argumentTypes": null, 2000 | "arguments": [ 2001 | { 2002 | "argumentTypes": null, 2003 | "arguments": [ 2004 | { 2005 | "argumentTypes": null, 2006 | "id": 47, 2007 | "name": "MINTER_ROLE", 2008 | "nodeType": "Identifier", 2009 | "overloadedDeclarations": [], 2010 | "referencedDeclaration": 13, 2011 | "src": "627:11:0", 2012 | "typeDescriptions": { 2013 | "typeIdentifier": "t_bytes32", 2014 | "typeString": "bytes32" 2015 | } 2016 | }, 2017 | { 2018 | "argumentTypes": null, 2019 | "expression": { 2020 | "argumentTypes": null, 2021 | "id": 48, 2022 | "name": "msg", 2023 | "nodeType": "Identifier", 2024 | "overloadedDeclarations": [], 2025 | "referencedDeclaration": -15, 2026 | "src": "640:3:0", 2027 | "typeDescriptions": { 2028 | "typeIdentifier": "t_magic_message", 2029 | "typeString": "msg" 2030 | } 2031 | }, 2032 | "id": 49, 2033 | "isConstant": false, 2034 | "isLValue": false, 2035 | "isPure": false, 2036 | "lValueRequested": false, 2037 | "memberName": "sender", 2038 | "nodeType": "MemberAccess", 2039 | "referencedDeclaration": null, 2040 | "src": "640:10:0", 2041 | "typeDescriptions": { 2042 | "typeIdentifier": "t_address_payable", 2043 | "typeString": "address payable" 2044 | } 2045 | } 2046 | ], 2047 | "expression": { 2048 | "argumentTypes": [ 2049 | { 2050 | "typeIdentifier": "t_bytes32", 2051 | "typeString": "bytes32" 2052 | }, 2053 | { 2054 | "typeIdentifier": "t_address_payable", 2055 | "typeString": "address payable" 2056 | } 2057 | ], 2058 | "id": 46, 2059 | "name": "hasRole", 2060 | "nodeType": "Identifier", 2061 | "overloadedDeclarations": [], 2062 | "referencedDeclaration": 858, 2063 | "src": "619:7:0", 2064 | "typeDescriptions": { 2065 | "typeIdentifier": "t_function_internal_view$_t_bytes32_$_t_address_$returns$_t_bool_$", 2066 | "typeString": "function (bytes32,address) view returns (bool)" 2067 | } 2068 | }, 2069 | "id": 50, 2070 | "isConstant": false, 2071 | "isLValue": false, 2072 | "isPure": false, 2073 | "kind": "functionCall", 2074 | "lValueRequested": false, 2075 | "names": [], 2076 | "nodeType": "FunctionCall", 2077 | "src": "619:32:0", 2078 | "tryCall": false, 2079 | "typeDescriptions": { 2080 | "typeIdentifier": "t_bool", 2081 | "typeString": "bool" 2082 | } 2083 | }, 2084 | { 2085 | "argumentTypes": null, 2086 | "hexValue": "43616c6c6572206973206e6f742061206d696e746572", 2087 | "id": 51, 2088 | "isConstant": false, 2089 | "isLValue": false, 2090 | "isPure": true, 2091 | "kind": "string", 2092 | "lValueRequested": false, 2093 | "nodeType": "Literal", 2094 | "src": "653:24:0", 2095 | "subdenomination": null, 2096 | "typeDescriptions": { 2097 | "typeIdentifier": "t_stringliteral_71abfcf6e817aaed3ce6663958bac2a3a82999ed0036c98a95b29f350f04cedf", 2098 | "typeString": "literal_string \"Caller is not a minter\"" 2099 | }, 2100 | "value": "Caller is not a minter" 2101 | } 2102 | ], 2103 | "expression": { 2104 | "argumentTypes": [ 2105 | { 2106 | "typeIdentifier": "t_bool", 2107 | "typeString": "bool" 2108 | }, 2109 | { 2110 | "typeIdentifier": "t_stringliteral_71abfcf6e817aaed3ce6663958bac2a3a82999ed0036c98a95b29f350f04cedf", 2111 | "typeString": "literal_string \"Caller is not a minter\"" 2112 | } 2113 | ], 2114 | "id": 45, 2115 | "name": "require", 2116 | "nodeType": "Identifier", 2117 | "overloadedDeclarations": [ 2118 | -18, 2119 | -18 2120 | ], 2121 | "referencedDeclaration": -18, 2122 | "src": "611:7:0", 2123 | "typeDescriptions": { 2124 | "typeIdentifier": "t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$", 2125 | "typeString": "function (bool,string memory) pure" 2126 | } 2127 | }, 2128 | "id": 52, 2129 | "isConstant": false, 2130 | "isLValue": false, 2131 | "isPure": false, 2132 | "kind": "functionCall", 2133 | "lValueRequested": false, 2134 | "names": [], 2135 | "nodeType": "FunctionCall", 2136 | "src": "611:67:0", 2137 | "tryCall": false, 2138 | "typeDescriptions": { 2139 | "typeIdentifier": "t_tuple$__$", 2140 | "typeString": "tuple()" 2141 | } 2142 | }, 2143 | "id": 53, 2144 | "nodeType": "ExpressionStatement", 2145 | "src": "611:67:0" 2146 | }, 2147 | { 2148 | "expression": { 2149 | "argumentTypes": null, 2150 | "arguments": [ 2151 | { 2152 | "argumentTypes": null, 2153 | "id": 55, 2154 | "name": "to", 2155 | "nodeType": "Identifier", 2156 | "overloadedDeclarations": [], 2157 | "referencedDeclaration": 40, 2158 | "src": "694:2:0", 2159 | "typeDescriptions": { 2160 | "typeIdentifier": "t_address", 2161 | "typeString": "address" 2162 | } 2163 | }, 2164 | { 2165 | "argumentTypes": null, 2166 | "id": 56, 2167 | "name": "amount", 2168 | "nodeType": "Identifier", 2169 | "overloadedDeclarations": [], 2170 | "referencedDeclaration": 42, 2171 | "src": "698:6:0", 2172 | "typeDescriptions": { 2173 | "typeIdentifier": "t_uint256", 2174 | "typeString": "uint256" 2175 | } 2176 | } 2177 | ], 2178 | "expression": { 2179 | "argumentTypes": [ 2180 | { 2181 | "typeIdentifier": "t_address", 2182 | "typeString": "address" 2183 | }, 2184 | { 2185 | "typeIdentifier": "t_uint256", 2186 | "typeString": "uint256" 2187 | } 2188 | ], 2189 | "id": 54, 2190 | "name": "_mint", 2191 | "nodeType": "Identifier", 2192 | "overloadedDeclarations": [], 2193 | "referencedDeclaration": 1644, 2194 | "src": "688:5:0", 2195 | "typeDescriptions": { 2196 | "typeIdentifier": "t_function_internal_nonpayable$_t_address_$_t_uint256_$returns$__$", 2197 | "typeString": "function (address,uint256)" 2198 | } 2199 | }, 2200 | "id": 57, 2201 | "isConstant": false, 2202 | "isLValue": false, 2203 | "isPure": false, 2204 | "kind": "functionCall", 2205 | "lValueRequested": false, 2206 | "names": [], 2207 | "nodeType": "FunctionCall", 2208 | "src": "688:17:0", 2209 | "tryCall": false, 2210 | "typeDescriptions": { 2211 | "typeIdentifier": "t_tuple$__$", 2212 | "typeString": "tuple()" 2213 | } 2214 | }, 2215 | "id": 58, 2216 | "nodeType": "ExpressionStatement", 2217 | "src": "688:17:0" 2218 | } 2219 | ] 2220 | }, 2221 | "documentation": null, 2222 | "functionSelector": "40c10f19", 2223 | "id": 60, 2224 | "implemented": true, 2225 | "kind": "function", 2226 | "modifiers": [], 2227 | "name": "mint", 2228 | "nodeType": "FunctionDefinition", 2229 | "overrides": null, 2230 | "parameters": { 2231 | "id": 43, 2232 | "nodeType": "ParameterList", 2233 | "parameters": [ 2234 | { 2235 | "constant": false, 2236 | "id": 40, 2237 | "mutability": "mutable", 2238 | "name": "to", 2239 | "nodeType": "VariableDeclaration", 2240 | "overrides": null, 2241 | "scope": 60, 2242 | "src": "566:10:0", 2243 | "stateVariable": false, 2244 | "storageLocation": "default", 2245 | "typeDescriptions": { 2246 | "typeIdentifier": "t_address", 2247 | "typeString": "address" 2248 | }, 2249 | "typeName": { 2250 | "id": 39, 2251 | "name": "address", 2252 | "nodeType": "ElementaryTypeName", 2253 | "src": "566:7:0", 2254 | "stateMutability": "nonpayable", 2255 | "typeDescriptions": { 2256 | "typeIdentifier": "t_address", 2257 | "typeString": "address" 2258 | } 2259 | }, 2260 | "value": null, 2261 | "visibility": "internal" 2262 | }, 2263 | { 2264 | "constant": false, 2265 | "id": 42, 2266 | "mutability": "mutable", 2267 | "name": "amount", 2268 | "nodeType": "VariableDeclaration", 2269 | "overrides": null, 2270 | "scope": 60, 2271 | "src": "578:14:0", 2272 | "stateVariable": false, 2273 | "storageLocation": "default", 2274 | "typeDescriptions": { 2275 | "typeIdentifier": "t_uint256", 2276 | "typeString": "uint256" 2277 | }, 2278 | "typeName": { 2279 | "id": 41, 2280 | "name": "uint256", 2281 | "nodeType": "ElementaryTypeName", 2282 | "src": "578:7:0", 2283 | "typeDescriptions": { 2284 | "typeIdentifier": "t_uint256", 2285 | "typeString": "uint256" 2286 | } 2287 | }, 2288 | "value": null, 2289 | "visibility": "internal" 2290 | } 2291 | ], 2292 | "src": "565:28:0" 2293 | }, 2294 | "returnParameters": { 2295 | "id": 44, 2296 | "nodeType": "ParameterList", 2297 | "parameters": [], 2298 | "src": "601:0:0" 2299 | }, 2300 | "scope": 61, 2301 | "src": "552:160:0", 2302 | "stateMutability": "nonpayable", 2303 | "virtual": false, 2304 | "visibility": "public" 2305 | } 2306 | ], 2307 | "scope": 62, 2308 | "src": "239:475:0" 2309 | } 2310 | ], 2311 | "src": "36:679:0" 2312 | }, 2313 | "compiler": { 2314 | "name": "solc", 2315 | "version": "0.6.12+commit.27d51765.Emscripten.clang" 2316 | }, 2317 | "networks": { 2318 | "42": { 2319 | "events": { 2320 | "0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925": { 2321 | "anonymous": false, 2322 | "inputs": [ 2323 | { 2324 | "indexed": true, 2325 | "internalType": "address", 2326 | "name": "owner", 2327 | "type": "address" 2328 | }, 2329 | { 2330 | "indexed": true, 2331 | "internalType": "address", 2332 | "name": "spender", 2333 | "type": "address" 2334 | }, 2335 | { 2336 | "indexed": false, 2337 | "internalType": "uint256", 2338 | "name": "value", 2339 | "type": "uint256" 2340 | } 2341 | ], 2342 | "name": "Approval", 2343 | "type": "event" 2344 | }, 2345 | "0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff": { 2346 | "anonymous": false, 2347 | "inputs": [ 2348 | { 2349 | "indexed": true, 2350 | "internalType": "bytes32", 2351 | "name": "role", 2352 | "type": "bytes32" 2353 | }, 2354 | { 2355 | "indexed": true, 2356 | "internalType": "bytes32", 2357 | "name": "previousAdminRole", 2358 | "type": "bytes32" 2359 | }, 2360 | { 2361 | "indexed": true, 2362 | "internalType": "bytes32", 2363 | "name": "newAdminRole", 2364 | "type": "bytes32" 2365 | } 2366 | ], 2367 | "name": "RoleAdminChanged", 2368 | "type": "event" 2369 | }, 2370 | "0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d": { 2371 | "anonymous": false, 2372 | "inputs": [ 2373 | { 2374 | "indexed": true, 2375 | "internalType": "bytes32", 2376 | "name": "role", 2377 | "type": "bytes32" 2378 | }, 2379 | { 2380 | "indexed": true, 2381 | "internalType": "address", 2382 | "name": "account", 2383 | "type": "address" 2384 | }, 2385 | { 2386 | "indexed": true, 2387 | "internalType": "address", 2388 | "name": "sender", 2389 | "type": "address" 2390 | } 2391 | ], 2392 | "name": "RoleGranted", 2393 | "type": "event" 2394 | }, 2395 | "0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b": { 2396 | "anonymous": false, 2397 | "inputs": [ 2398 | { 2399 | "indexed": true, 2400 | "internalType": "bytes32", 2401 | "name": "role", 2402 | "type": "bytes32" 2403 | }, 2404 | { 2405 | "indexed": true, 2406 | "internalType": "address", 2407 | "name": "account", 2408 | "type": "address" 2409 | }, 2410 | { 2411 | "indexed": true, 2412 | "internalType": "address", 2413 | "name": "sender", 2414 | "type": "address" 2415 | } 2416 | ], 2417 | "name": "RoleRevoked", 2418 | "type": "event" 2419 | }, 2420 | "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef": { 2421 | "anonymous": false, 2422 | "inputs": [ 2423 | { 2424 | "indexed": true, 2425 | "internalType": "address", 2426 | "name": "from", 2427 | "type": "address" 2428 | }, 2429 | { 2430 | "indexed": true, 2431 | "internalType": "address", 2432 | "name": "to", 2433 | "type": "address" 2434 | }, 2435 | { 2436 | "indexed": false, 2437 | "internalType": "uint256", 2438 | "name": "value", 2439 | "type": "uint256" 2440 | } 2441 | ], 2442 | "name": "Transfer", 2443 | "type": "event" 2444 | } 2445 | }, 2446 | "links": {}, 2447 | "address": "0xd34157ab6c4CA965f98715f3DB62C984e8CB890b", 2448 | "transactionHash": "0xf1f9a90ffa14d81a76ca80305eef69b8190813ac7cd4b62931322918d38e3569" 2449 | } 2450 | }, 2451 | "schemaVersion": "3.3.1", 2452 | "updatedAt": "2021-01-10T17:41:43.459Z", 2453 | "networkType": "ethereum", 2454 | "devdoc": { 2455 | "kind": "dev", 2456 | "methods": { 2457 | "allowance(address,address)": { 2458 | "details": "See {IERC20-allowance}." 2459 | }, 2460 | "approve(address,uint256)": { 2461 | "details": "See {IERC20-approve}. Requirements: - `spender` cannot be the zero address." 2462 | }, 2463 | "balanceOf(address)": { 2464 | "details": "See {IERC20-balanceOf}." 2465 | }, 2466 | "cap()": { 2467 | "details": "Returns the cap on the token's total supply." 2468 | }, 2469 | "decimals()": { 2470 | "details": "Returns the number of decimals used to get its user representation. For example, if `decimals` equals `2`, a balance of `505` tokens should be displayed to a user as `5,05` (`505 / 10 ** 2`). Tokens usually opt for a value of 18, imitating the relationship between Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is called. NOTE: This information is only used for _display_ purposes: it in no way affects any of the arithmetic of the contract, including {IERC20-balanceOf} and {IERC20-transfer}." 2471 | }, 2472 | "decreaseAllowance(address,uint256)": { 2473 | "details": "Atomically decreases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address. - `spender` must have allowance for the caller of at least `subtractedValue`." 2474 | }, 2475 | "getRoleAdmin(bytes32)": { 2476 | "details": "Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}." 2477 | }, 2478 | "getRoleMember(bytes32,uint256)": { 2479 | "details": "Returns one of the accounts that have `role`. `index` must be a value between 0 and {getRoleMemberCount}, non-inclusive. Role bearers are not sorted in any particular way, and their ordering may change at any point. WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure you perform all queries on the same block. See the following https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post] for more information." 2480 | }, 2481 | "getRoleMemberCount(bytes32)": { 2482 | "details": "Returns the number of accounts that have `role`. Can be used together with {getRoleMember} to enumerate all bearers of a role." 2483 | }, 2484 | "grantRole(bytes32,address)": { 2485 | "details": "Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role." 2486 | }, 2487 | "hasRole(bytes32,address)": { 2488 | "details": "Returns `true` if `account` has been granted `role`." 2489 | }, 2490 | "increaseAllowance(address,uint256)": { 2491 | "details": "Atomically increases the allowance granted to `spender` by the caller. This is an alternative to {approve} that can be used as a mitigation for problems described in {IERC20-approve}. Emits an {Approval} event indicating the updated allowance. Requirements: - `spender` cannot be the zero address." 2492 | }, 2493 | "name()": { 2494 | "details": "Returns the name of the token." 2495 | }, 2496 | "renounceRole(bytes32,address)": { 2497 | "details": "Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`." 2498 | }, 2499 | "revokeRole(bytes32,address)": { 2500 | "details": "Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role." 2501 | }, 2502 | "symbol()": { 2503 | "details": "Returns the symbol of the token, usually a shorter version of the name." 2504 | }, 2505 | "totalSupply()": { 2506 | "details": "See {IERC20-totalSupply}." 2507 | }, 2508 | "transfer(address,uint256)": { 2509 | "details": "See {IERC20-transfer}. Requirements: - `recipient` cannot be the zero address. - the caller must have a balance of at least `amount`." 2510 | }, 2511 | "transferFrom(address,address,uint256)": { 2512 | "details": "See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. Requirements: - `sender` and `recipient` cannot be the zero address. - `sender` must have a balance of at least `amount`. - the caller must have allowance for ``sender``'s tokens of at least `amount`." 2513 | } 2514 | }, 2515 | "version": 1 2516 | }, 2517 | "userdoc": { 2518 | "kind": "user", 2519 | "methods": {}, 2520 | "version": 1 2521 | } 2522 | } --------------------------------------------------------------------------------