// File: contracts/DkargoPrefix.sol pragma solidity >=0.5.0 <0.6.0; /// @title DkargoPrefix /// @notice 디카르고 컨트랙트 여부 식별용 prefix 컨트랙트 정의 /// @author jhhong contract DkargoPrefix { string internal _dkargoPrefix; // 디카르고-프리픽스 /// @author jhhong /// @notice 디카르고 프리픽스를 반환한다. /// @return 디카르고 프리픽스 (string) function getDkargoPrefix() public view returns(string memory) { return _dkargoPrefix; } /// @author jhhong /// @notice 디카르고 프리픽스를 설정한다. /// @param prefix 설정할 프리픽스 function _setDkargoPrefix(string memory prefix) internal { _dkargoPrefix = prefix; } } // File: contracts/authority/Ownership.sol pragma solidity >=0.5.0 <0.6.0; /// @title Onwership /// @dev 오너 확인 및 소유권 이전 처리 /// @author jhhong contract Ownership { address private _owner; event OwnershipTransferred(address indexed old, address indexed expected); /// @author jhhong /// @notice 소유자만 접근할 수 있음을 명시한다. modifier onlyOwner() { require(isOwner() == true, "Ownership: only the owner can call"); _; } /// @author jhhong /// @notice 컨트랙트 생성자이다. constructor() internal { emit OwnershipTransferred(_owner, msg.sender); _owner = msg.sender; } /// @author jhhong /// @notice 소유권을 넘겨준다. /// @param expected 새로운 오너 계정 function transferOwnership(address expected) public onlyOwner { require(expected != address(0), "Ownership: new owner is the zero address"); emit OwnershipTransferred(_owner, expected); _owner = expected; } /// @author jhhong /// @notice 오너 주소를 반환한다. /// @return 오너 주소 function owner() public view returns (address) { return _owner; } /// @author jhhong /// @notice 소유자인지 확인한다. /// @return 확인 결과 (boolean) function isOwner() public view returns (bool) { return msg.sender == _owner; } } // File: contracts/libs/refs/SafeMath.sol pragma solidity >=0.5.0 <0.6.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * - Subtraction cannot overflow. * * NOTE: This is a feature of the next version of OpenZeppelin Contracts. * @dev Get it via `npm install @openzeppelin/contracts@next`. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { // Solidity only automatically asserts when dividing by 0 require(b > 0, "SafeMath: division by zero"); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, "SafeMath: modulo by zero"); return a % b; } } // File: contracts/chain/AddressChain.sol pragma solidity >=0.5.0 <0.6.0; /// @title AddressChain /// @notice 주소 체인 정의 및 관리 /// @dev 토큰홀더, 회원정보 등과 같은 유저 리스트 관리에 쓰인다. /// @author jhhong contract AddressChain { using SafeMath for uint256; // 구조체 : 노드 정보 struct NodeInfo { address prev; // 이전 노드 address next; // 다음 노드 } // 구조체 : 노드 체인 struct NodeList { uint256 count; // 노드의 총 개수 address head; // 체인의 머리 address tail; // 체인의 꼬리 mapping(address => NodeInfo) map; // 계정에 대한 노드 정보 매핑 } // 변수 선언 NodeList private _slist; // 노드 체인 (싱글리스트) // 이벤트 선언 event AddressChainLinked(address indexed node); // 이벤트: 체인에 추가됨 event AddressChainUnlinked(address indexed node); // 이벤트: 체인에서 빠짐 /// @author jhhong /// @notice 체인에 연결된 원소의 개수를 반환한다. /// @return 체인에 연결된 원소의 개수 function count() public view returns(uint256) { return _slist.count; } /// @author jhhong /// @notice 체인 헤드 정보를 반환한다. /// @return 체인 헤드 정보 function head() public view returns(address) { return _slist.head; } /// @author jhhong /// @notice 체인 꼬리 정보를 반환한다. /// @return 체인 꼬리 정보 function tail() public view returns(address) { return _slist.tail; } /// @author jhhong /// @notice node의 다음 노드 정보를 반환한다. /// @param node 노드 정보 (체인에 연결되어 있을 수도 있고 아닐 수도 있음) /// @return node의 다음 노드 정보 function nextOf(address node) public view returns(address) { return _slist.map[node].next; } /// @author jhhong /// @notice node의 이전 노드 정보를 반환한다. /// @param node 노드 정보 (체인에 연결되어 있을 수도 있고 아닐 수도 있음) /// @return node의 이전 노드 정보 function prevOf(address node) public view returns(address) { return _slist.map[node].prev; } /// @author jhhong /// @notice node가 체인에 연결된 상태인지를 확인한다. /// @param node 체인 연결 여부를 확인할 노드 주소 /// @return 연결 여부 (boolean), true: 연결됨(linked), false: 연결되지 않음(unlinked) function isLinked(address node) public view returns (bool) { if(_slist.count == 1 && _slist.head == node && _slist.tail == node) { return true; } else { return (_slist.map[node].prev == address(0) && _slist.map[node].next == address(0))? (false) :(true); } } /// @author jhhong /// @notice 새로운 노드 정보를 노드 체인에 연결한다. /// @param node 노드 체인에 연결할 노드 주소 function _linkChain(address node) internal { require(node != address(0), "AddressChain: try to link to the zero address"); require(!isLinked(node), "AddressChain: the node is aleady linked"); if(_slist.count == 0) { _slist.head = _slist.tail = node; } else { _slist.map[node].prev = _slist.tail; _slist.map[_slist.tail].next = node; _slist.tail = node; } _slist.count = _slist.count.add(1); emit AddressChainLinked(node); } /// @author jhhong /// @notice node 노드를 체인에서 연결 해제한다. /// @param node 노드 체인에서 연결 해제할 노드 주소 function _unlinkChain(address node) internal { require(node != address(0), "AddressChain: try to unlink to the zero address"); require(isLinked(node), "AddressChain: the node is aleady unlinked"); address tempPrev = _slist.map[node].prev; address tempNext = _slist.map[node].next; if (_slist.head == node) { _slist.head = tempNext; } if (_slist.tail == node) { _slist.tail = tempPrev; } if (tempPrev != address(0)) { _slist.map[tempPrev].next = tempNext; _slist.map[node].prev = address(0); } if (tempNext != address(0)) { _slist.map[tempNext].prev = tempPrev; _slist.map[node].next = address(0); } _slist.count = _slist.count.sub(1); emit AddressChainUnlinked(node); } } // File: contracts/introspection/ERC165/IERC165.sol pragma solidity >=0.5.0 <0.6.0; /// @title IERC165 /// @dev EIP165 interface 선언 /// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md /// @author jhhong interface IERC165 { function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: contracts/introspection/ERC165/ERC165.sol pragma solidity >=0.5.0 <0.6.0; /// @title ERC165 /// @dev EIP165 interface 구현 /// @author jhhong contract ERC165 is IERC165 { mapping(bytes4 => bool) private _infcs; // INTERFACE ID별 지원여부를 저장하기 위한 매핑 변수 /// @author jhhong /// @notice 컨트랙트 생성자이다. /// @dev bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 constructor() internal { _registerInterface(0x01ffc9a7); // supportsInterface()의 INTERFACE ID 등록 } /// @author jhhong /// @notice 컨트랙트가 INTERFACE ID를 지원하는지의 여부를 반환한다. /// @param infcid 지원여부를 확인할 INTERFACE ID (Function Selector) /// @return 지원여부 (boolean) function supportsInterface(bytes4 infcid) external view returns (bool) { return _infcs[infcid]; } /// @author jhhong /// @notice INTERFACE ID를 등록한다. /// @param infcid 등록할 INTERFACE ID (Function Selector) function _registerInterface(bytes4 infcid) internal { require(infcid != 0xffffffff, "ERC165: invalid interface id"); _infcs[infcid] = true; } } // File: contracts/token/ERC20/IERC20.sol pragma solidity >=0.5.0 <0.6.0; /// @title IERC20 /// @notice EIP20 interface 선언 /// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md /// @author jhhong interface IERC20 { function transfer(address recipient, uint256 amount) external returns (bool); function approve(address spender, uint256 amount) external returns (bool); function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); function totalSupply() external view returns (uint256); function balanceOf(address account) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } // File: contracts/token/ERC20/ERC20.sol pragma solidity >=0.5.0 <0.6.0; /// @title ERC20 /// @notice EIP20 interface 정의 및 mint/burn (internal) 함수 구현 /// @author jhhong contract ERC20 is IERC20 { using SafeMath for uint256; uint256 private _supply; // 총 통화량 mapping(address => uint256) private _balances; // 계정별 통화량 저장소 mapping(address => mapping(address => uint256)) private _allowances; // 각 계정에 대해 "계정별 위임량"을 저장 /// @author jhhong /// @notice 컨트랙트 생성자이다. /// @param supply 초기 발행량 constructor(uint256 supply) internal { uint256 pebs = supply; _mint(msg.sender, pebs); } /// @author jhhong /// @notice 계정(spender)에게 통화량(value)을 위임한다. /// @param spender 위임받을 계정 /// @param amount 위임할 통화량 /// @return 정상처리 시 true function approve(address spender, uint256 amount) public returns (bool) { _approve(msg.sender, spender, amount); return true; } /// @author jhhong /// @notice 계정(recipient)에게 통화량(amount)을 전송한다. /// @param recipient 전송받을 계정 /// @param amount 금액 /// @return 정상처리 시 true function transfer(address recipient, uint256 amount) public returns (bool) { _transfer(msg.sender, recipient, amount); return true; } /// @author jhhong /// @notice 계정(sender)이 계정(recipient)에게 통화량(amount)을 전송한다. /// @param sender 전송할 계정 /// @param recipient 전송받을 계정 /// @param amount 금액 /// @return 정상처리 시 true function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) { _transfer(sender, recipient, amount); _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /// @author jhhong /// @notice 발행된 총 통화량을 반환한다. /// @return 총 통화량 function totalSupply() public view returns (uint256) { return _supply; } /// @author jhhong /// @notice 계정(account)이 보유한 통화량을 반환한다. /// @param account 계정 /// @return 계정(account)이 보유한 통화량 function balanceOf(address account) public view returns (uint256) { return _balances[account]; } /// @author jhhong /// @notice 계정(approver)이 계정(spender)에게 위임한 통화량을 반환한다. /// @param approver 위임할 계정 /// @param spender 위임받을 계정 /// @return 계정(approver)이 계정(spender)에게 위임한 통화량 function allowance(address approver, address spender) public view returns (uint256) { return _allowances[approver][spender]; } /// @author jhhong /// @notice 계정(approver)이 계정(spender)에게 통화량(value)을 위임한다. /// @param approver 위임할 계정 /// @param spender 위임받을 계정 /// @param value 위임할 통화량 function _approve(address approver, address spender, uint256 value) internal { require(approver != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[approver][spender] = value; emit Approval(approver, spender, value); } /// @author jhhong /// @notice 계정(sender)이 계정(recipient)에게 통화량(amount)을 전송한다. /// @param sender 위임할 계정 /// @param recipient 위임받을 계정 /// @param amount 금액 function _transfer(address sender, address recipient, uint256 amount) internal { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /// @author jhhong /// @notice 통화량(amount)만큼 주조하여 계정(account)의 통화량에 더해준다. /// @dev ERC20Mint에 정의하면 private 속성인 supply와 balances에 access할 수 없어서 ERC20에 internal로 정의함. /// @param account 주조된 통화량을 받을 계정 /// @param amount 주조할 통화량 function _mint(address account, uint256 amount) internal { require(account != address(0), "ERC20: mint to the zero address"); _supply = _supply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /// @author jhhong /// @notice 통화량(value)만큼 소각하여 계정(account)의 통화량에서 뺀다. /// @dev ERC20Mint에 정의하면 private 속성인 supply와 balances에 access할 수 없어서 ERC20에 internal로 정의함. /// @param account 통화량을 소각시킬 계정 /// @param value 소각시킬 통화량 function _burn(address account, uint256 value) internal { require(account != address(0), "ERC20: burn from the zero address"); _balances[account] = _balances[account].sub(value, "ERC20: burn amount exceeds balance"); _supply = _supply.sub(value); emit Transfer(account, address(0), value); } } // File: contracts/token/ERC20/ERC20Safe.sol pragma solidity >=0.5.0 <0.6.0; /// @title ERC20Safe /// @notice Approve Bug Fix 버전 (중복 위임 방지) /// @author jhhong contract ERC20Safe is ERC20 { using SafeMath for uint256; /// @author jhhong /// @notice 계정(spender)에게 통화량(amount)을 위임한다. /// @dev 값이 덮어써짐을 방지하기 위해 기존에 위임받은 통화량이 0인 경우에만 호출을 허용한다. /// @param spender 위임받을 계정 /// @param amount 위임할 통화량 /// @return 정상처리 시 true function approve(address spender, uint256 amount) public returns (bool) { require((amount == 0) || (allowance(msg.sender, spender) == 0), "ERC20Safe: approve from non-zero to non-zero allowance"); return super.approve(spender, amount); } /// @author jhhong /// @notice 계정(spender)에 위임된 통화량에 통화량(addedValue)를 더한값을 위임한다. /// @dev 위임된 통화량이 있을 경우, 통화량 증가는 상기 함수로 수행할 것 /// @param spender 위임받을 계정 /// @param addedValue 더해질 통화량 /// @return 정상처리 시 true function increaseAllowance(address spender, uint256 addedValue) public returns (bool) { uint256 amount = allowance(msg.sender, spender).add(addedValue); return super.approve(spender, amount); } /// @author jhhong /// @notice 계정(spender)에 위임된 통화량에 통화량(subtractedValue)를 뺀값을 위임한다. /// @dev 위임된 통화량이 있을 경우, 통화량 감소는 상기 함수로 수행할 것 /// @param spender 위임받을 계정 /// @param subtractedValue 빼질 통화량 /// @return 정상처리 시 true function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) { uint256 amount = allowance(msg.sender, spender).sub(subtractedValue, "ERC20: decreased allowance below zero"); return super.approve(spender, amount); } } // File: contracts/DkargoToken.sol pragma solidity >=0.5.0 <0.6.0; /// @title DkargoToken /// @notice 디카르고 토큰 컨트랙트 정의 (메인넷 deploy용) /// @dev burn 기능 추가 (public) /// @author jhhong contract DkargoToken is Ownership, ERC20Safe, AddressChain, ERC165, DkargoPrefix { string private _name; // 토큰 이름 string private _symbol; // 토큰 심볼 /// @author jhhong /// @notice 컨트랙트 생성자이다. /// @dev 초기 발행량이 있을 경우, msg.sender를 홀더 리스트에 추가한다. /// @param name 토큰 이름 /// @param symbol 토큰 심볼 /// @param supply 초기 발행량 constructor(string memory name, string memory symbol, uint256 supply) ERC20(supply) public { _setDkargoPrefix("token"); // 프리픽스 설정 (token) _registerInterface(0x946edbed); // INTERFACE ID 등록 (getDkargoPrefix) _name = name; _symbol = symbol; _linkChain(msg.sender); } /// @author jhhong /// @notice 본인의 보유금액 중 지정된 금액만큼 소각한다. /// @param amount 소각시킬 통화량 function burn(uint256 amount) external { _burn(msg.sender, amount); } /// @author jhhong /// @notice 토큰을 전송한다. (전송주체: msg.sender) /// @dev 전송 후 변경된 토큰 홀더 상태를 체인에 기록한다. /// @param to 토큰을 받을 주소 /// @param value 전송 금액 (토큰량) function transfer(address to, uint256 value) public returns (bool) { bool ret = super.transfer(to, value); if(isLinked(msg.sender) && balanceOf(msg.sender) == 0) { _unlinkChain(msg.sender); } if(!isLinked(to) && balanceOf(to) > 0) { _linkChain(to); } return ret; } /// @author jhhong /// @notice 토큰을 전송한다. (전송주체: from) /// @dev 전송 후 변경된 토큰 홀더 상태를 체인에 기록한다. /// @param from 토큰을 보낼 계정 /// @param to 토큰을 받을 계정 /// @param value 전송 금액 (토큰량) function transferFrom(address from, address to, uint256 value) public returns (bool) { bool ret = super.transferFrom(from, to, value); if(isLinked(from) && balanceOf(from) == 0) { _unlinkChain(from); } if(!isLinked(to) && balanceOf(to) > 0) { _linkChain(to); } return ret; } /// @author jhhong /// @notice 토큰의 이름을 반환한다. /// @return 토큰 이름 function name() public view returns(string memory) { return _name; } /// @author jhhong /// @notice 토큰의 심볼을 반환한다. /// @return 토큰 심볼 function symbol() public view returns(string memory) { return _symbol; } /// @author jhhong /// @notice 토큰 데시멀을 반환한다. /// @dev 데시멀 값은 18 (peb) 로 고정이다. /// @return 토큰 데시멀 function decimals() public pure returns(uint256) { return 18; } }

dKargo

Start building on QuickNode

Source code: