Skip to content
View cloudugba's full-sized avatar
🎯
Focusing
🎯
Focusing
  • Ugba De Tech Inc
  • N/A
  • 18:52 (UTC -12:00)

Block or report cloudugba

Block user

Prevent this user from interacting with your repositories and sending you notifications. Learn more about blocking users.

You must be logged in to block users.

Please don't include any personal information such as legal names or email addresses. Maximum 100 characters, markdown supported. This note will be visible to only you.
Report abuse

Contact GitHub support about this user’s behavior. Learn more about reporting abuse.

Report abuse
cloudugba/README.md

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

contract Ownable { address public owner;

event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

modifier onlyOwner() {
    require(msg.sender == owner, "Ownable: caller is not the owner");
    _;
}

function transferOwnership(address newOwner) public onlyOwner {
    require(newOwner != address(0), "Ownable: new owner is the zero address");
    emit OwnershipTransferred(owner, newOwner);
    owner = newOwner;
}

}

contract Pausable is Ownable { event Pause(); event Unpause();

bool public paused = false;

modifier whenNotPaused() {
    require(!paused, "Pausable: paused");
    _;
}

modifier whenPaused() {
    require(paused, "Pausable: not paused");
    _;
}

function pause() onlyOwner whenNotPaused public {
    paused = true;
    emit Pause();
}

function unpause() onlyOwner whenPaused public {
    paused = false;
    emit Unpause();
}

}

abstract contract ERC20Basic { uint256 public totalSupply;

function balanceOf(address who) virtual public view returns (uint256);
function transfer(address to, uint256 value) virtual  public returns (bool);

event Transfer(address indexed from, address indexed to, uint256 value);

}

abstract contract ERC20 is ERC20Basic { function allowance(address owner, address spender) virtual public view returns (uint256); function transferFrom(address from, address to, uint256 value) virtual public returns (bool); function approve(address spender, uint256 value) virtual public returns (bool);

event Approval(address indexed owner, address indexed spender, uint256 value);

}

contract StandardToken is ERC20 { mapping(address => mapping(address => uint256)) internal allowed; mapping(address => bool) tokenBlacklist; event Blacklist(address indexed blackListed, bool value);

mapping(address => uint256) balances;

function transfer(address _to, uint256 _value) virtual override  public returns (bool) {
    require(!tokenBlacklist[msg.sender], "StandardToken: sender is blacklisted");
    require(_to != address(0), "StandardToken: transfer to the zero address");
    require(_value <= balances[msg.sender], "StandardToken: insufficient balance");

    balances[msg.sender] -= _value;
    balances[_to] += _value;
    emit Transfer(msg.sender, _to, _value);
    return true;
}

function balanceOf(address _owner) override public view returns (uint256 balance) {
    return balances[_owner];
}

function transferFrom(address _from, address _to, uint256 _value) virtual override public returns (bool) {
    require(!tokenBlacklist[msg.sender], "StandardToken: sender is blacklisted");
    require(_to != address(0), "StandardToken: transfer to the zero address");
    require(_value <= balances[_from], "StandardToken: insufficient balance");
    require(_value <= allowed[_from][msg.sender], "StandardToken: allowance exceeded");

    balances[_from] -= _value;
    balances[_to] += _value;
    allowed[_from][msg.sender] -= _value;
    emit Transfer(_from, _to, _value);
    return true;
}

function approve(address _spender, uint256 _value) virtual override public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
}

function allowance(address _owner, address _spender) virtual override  public view returns (uint256) {
    return allowed[_owner][_spender];
}

function increaseApproval(address _spender, uint _addedValue) virtual public returns (bool) {
    allowed[msg.sender][_spender] += _addedValue;
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
}

function decreaseApproval(address _spender, uint _subtractedValue) virtual public returns (bool) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
        allowed[msg.sender][_spender] = 0;
    } else {
        allowed[msg.sender][_spender] = oldValue - _subtractedValue;
    }
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
}

function _blackList(address _address, bool _isBlackListed) internal returns (bool) {
    require(tokenBlacklist[_address] != _isBlackListed, "StandardToken: address already in the given state");
    tokenBlacklist[_address] = _isBlackListed;
    emit Blacklist(_address, _isBlackListed);
    return true;
}

}

contract PausableToken is StandardToken, Pausable {

function transfer(address _to, uint256 _value) override public whenNotPaused returns (bool) {
    return super.transfer(_to, _value);
}

function transferFrom(address _from, address _to, uint256 _value) override public whenNotPaused returns (bool) {
    return super.transferFrom(_from, _to, _value);
}

function approve(address _spender, uint256 _value) override public whenNotPaused returns (bool) {
    return super.approve(_spender, _value);
}

function increaseApproval(address _spender, uint _addedValue) override public whenNotPaused returns (bool success) {
    return super.increaseApproval(_spender, _addedValue);
}

function decreaseApproval(address _spender, uint _subtractedValue) override public whenNotPaused returns (bool success) {
    return super.decreaseApproval(_spender, _subtractedValue);
}

function blackListAddress(address listAddress, bool isBlackListed) public whenNotPaused onlyOwner returns (bool success) {
    return super._blackList(listAddress, isBlackListed);
}

}

contract Rokda is PausableToken { string public name; string public symbol; uint public decimals;

event Mint(address indexed from, address indexed to, uint256 value);
event Burn(address indexed burner, uint256 value);

constructor(string memory _name, string memory _symbol, uint256 _decimals, uint256 _supply, address tokenOwner) {
    name = _name;
    symbol = _symbol;
    decimals = _decimals;
    totalSupply = _supply * 10 ** _decimals;
    balances[tokenOwner] = totalSupply;
    owner = tokenOwner;
    emit Transfer(address(0), tokenOwner, totalSupply);
}

function burn(uint256 _value) public {
    _burn(msg.sender, _value);
}

function _burn(address _who, uint256 _value) internal {
    require(_value <= balances[_who], "Rokda: burn amount exceeds balance");
    balances[_who] -= _value;
    totalSupply -= _value;
    emit Burn(_who, _value);
    emit Transfer(_who, address(0), _value);
}

function mint(address account, uint256 amount) onlyOwner public {
    totalSupply += amount;
    balances[account] += amount;
    emit Mint(address(0), account, amount);
    emit Transfer(address(0), account, amount);
}

} version: 2 updates:

  • package-ecosystem: "npm" # Change to your package manager (e.g., pip, maven, gradle) directory: "/" # Location of package manifests schedule: interval: "weekly" Authorization: Bearer YOUR_PERSONAL_ACCESS_TOKEN Accept: application/vnd.github.v3+json

Popular repositories Loading

  1. vscode-docs vscode-docs Public

    Forked from microsoft/vscode-docs

    Public documentation for Visual Studio Code

    Markdown 1

  2. cloudugb cloudugb Public template

    first project for testing

    HTML

  3. cloudugba cloudugba Public

  4. sftware-development sftware-development Public template

    Software development is an exciting and dynamic field! Whether you're into building websites, creating apps, working on AI (like me!), or coding games, there's always something new to learn. It inv…

  5. cloudugba-studious-tribble cloudugba-studious-tribble Public

  6. .github .github Public

    Forked from skills/.github

    <<Not a course>> .github is a special repository.