Unnamed: 0
int64 0
3.2k
| func
stringlengths 19
4.9k
| target
bool 2
classes | project
stringlengths 11
46
|
|---|---|---|---|
2,200 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
| false |
0xa5c11e420fd480675302f8e09e40b22ff65e5dfc.sol
|
2,201 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| false |
0xa5c11e420fd480675302f8e09e40b22ff65e5dfc.sol
|
2,202 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| false |
0xa5c11e420fd480675302f8e09e40b22ff65e5dfc.sol
|
2,203 |
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| false |
0xa5c11e420fd480675302f8e09e40b22ff65e5dfc.sol
|
2,204 |
function hatchEggs(address ref) public {
require(initialized);
if(referrals[msg.sender] == 0 && referrals[msg.sender] != msg.sender){
referrals[msg.sender] = ref;
}
uint256 eggsUsed = getMyEggs();
uint256 newDragons = SafeMath.div(eggsUsed, EGGS_TO_HATCH_1DRAGON);
hatchery[msg.sender] = SafeMath.add(hatchery[msg.sender], newDragons);
claimedEggs[msg.sender] = 0;
lastHatch[msg.sender] = now;
claimedEggs[referrals[msg.sender]] = SafeMath.add(claimedEggs[referrals[msg.sender]],SafeMath.div(eggsUsed,5));
marketEggs=SafeMath.add(marketEggs,SafeMath.div(eggsUsed,10));
emit Hatch(msg.sender, eggsUsed, newDragons);
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,205 |
function sellEggs() public {
require(initialized);
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
uint256 fee = calculateDevFee(eggValue);
claimedEggs[msg.sender] = 0;
lastHatch[msg.sender] = now;
marketEggs = SafeMath.add(marketEggs,hasEggs);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(eggValue,fee));
emit Sell(msg.sender, hasEggs);
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,206 |
function buyEggs() public payable {
require(initialized);
uint256 eggsBought = calculateEggBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
eggsBought = SafeMath.sub(eggsBought, calculateDevFee(eggsBought));
ceoAddress.transfer(calculateDevFee(msg.value));
claimedEggs[msg.sender] = SafeMath.add(claimedEggs[msg.sender], eggsBought);
emit Buy(msg.sender, eggsBought);
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,207 |
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,208 |
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs,marketEggs, address(this).balance);
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,209 |
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth,contractBalance,marketEggs);
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,210 |
function calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, address(this).balance);
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,211 |
function calculateDevFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount,4),100);
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,212 |
function seedMarket(uint256 eggs) public payable{
require(marketEggs == 0);
initialized = true;
marketEggs = eggs;
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,213 |
function claimFreeDragon() public{
require(initialized);
require(hatchery[msg.sender] == 0);
lastHatch[msg.sender] = now;
hatchery[msg.sender] = 300;
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,214 |
function getBalance() public view returns(uint256){
return address(this).balance;
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,215 |
function getMyDragons() public view returns(uint256){
return hatchery[msg.sender];
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,216 |
function getMyEggs() public view returns(uint256){
return SafeMath.add(claimedEggs[msg.sender], getEggsSinceLastHatch(msg.sender));
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,217 |
function getEggsSinceLastHatch(address _address) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1DRAGON, SafeMath.sub(now, lastHatch[_address]));
return SafeMath.mul(secondsPassed, hatchery[_address]);
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,218 |
function min(uint256 a, uint256 b) private pure returns (uint256) {
return a < b ? a : b;
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,219 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,220 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,221 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,222 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
| false |
0x416768387836bd8715d127ef9065975325cfad14.sol
|
2,223 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,224 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,225 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,226 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,227 |
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,228 |
function name() public view returns(string memory) {
return _name;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,229 |
function symbol() public view returns(string memory) {
return _symbol;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,230 |
function decimals() public view returns(uint8) {
return _decimals;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,231 |
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,232 |
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,233 |
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,234 |
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,235 |
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,236 |
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _allowed[from][msg.sender]);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
_transfer(from, to, value);
return true;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,237 |
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,238 |
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,239 |
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
| false |
0x759685437c6d4658b00b5cebdf907dfdeba52357.sol
|
2,240 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,241 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,242 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,243 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,244 |
function BCEToken() public {
balances[msg.sender] = _totalSupply;
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,245 |
function totalSupply() public pure returns (uint256) {
return _totalSupply;
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,246 |
function balanceOf(address _owner) public constant returns (uint256 balance){
return balances[_owner];
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,247 |
function transfer(address _to, uint256 _value) internal returns (bool success) {
require(_to != 0x0);
require(balances[msg.sender] >= _value && _value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,248 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success){
require(_to != 0x0);
require(allowed [_from][msg.sender] >= 0 && balances[_from] >= _value && _value > 0);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,249 |
function approve(address _spender, uint256 _value) public returns (bool success){
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,250 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining){
return allowed[_owner][_spender];
}
| false |
0xa6fd6f9b44127dbdc02fa1712fbedd21d14b4f20.sol
|
2,251 |
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,252 |
function balanceOf(address owner) public view returns (uint256) {
return _balances[owner];
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,253 |
function allowance(
address owner,
address spender
)
public
view
returns (uint256)
{
return _allowed[owner][spender];
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,254 |
function transfer(address to, uint256 value) public returns (bool) {
require(value <= _balances[msg.sender]);
require(to != address(0));
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(msg.sender, to, value);
return true;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,255 |
function approve(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,256 |
function transferFrom(
address from,
address to,
uint256 value
)
public
returns (bool)
{
require(value <= _balances[from]);
require(value <= _allowed[from][msg.sender]);
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
_allowed[from][msg.sender] = _allowed[from][msg.sender].sub(value);
emit Transfer(from, to, value);
return true;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,257 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,258 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,259 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,260 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,261 |
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,262 |
function increaseAllowance(
address spender,
uint256 addedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].add(addedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,263 |
function decreaseAllowance(
address spender,
uint256 subtractedValue
)
public
returns (bool)
{
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,264 |
function _mint(address account, uint256 amount) internal {
require(account != 0);
_totalSupply = _totalSupply.add(amount);
_balances[account] = _balances[account].add(amount);
emit Transfer(address(0), account, amount);
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,265 |
function _burn(address account, uint256 amount) internal {
require(account != 0);
require(amount <= _balances[account]);
_totalSupply = _totalSupply.sub(amount);
_balances[account] = _balances[account].sub(amount);
emit Transfer(account, address(0), amount);
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,266 |
function _burnFrom(address account, uint256 amount) internal {
require(amount <= _allowed[account][msg.sender]);
_allowed[account][msg.sender] = _allowed[account][msg.sender].sub(
amount);
_burn(account, amount);
}
| false |
0x892697720ad461f019fd1f4bc4d52447a59c0687.sol
|
2,267 |
function Put(uint _unlockTime)
public
payable
{
var acc = Acc[msg.sender];
acc.balance += msg.value;
acc.unlockTime = _unlockTime>now?_unlockTime:now;
LogFile.AddMessage(msg.sender,msg.value,"Put");
}
| false |
0x7b368c4e805c3870b6c49a3f1f49f69af8662cf3.sol
|
2,268 |
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
| true |
0x7b368c4e805c3870b6c49a3f1f49f69af8662cf3.sol
|
2,269 |
function W_WALLET(address log) public{
LogFile = Log(log);
}
| false |
0x7b368c4e805c3870b6c49a3f1f49f69af8662cf3.sol
|
2,270 |
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
}
| false |
0x7b368c4e805c3870b6c49a3f1f49f69af8662cf3.sol
|
2,271 |
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
}
| false |
spank_chain_payment.sol
|
2,272 |
function transfer(address _to, uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
}
| false |
spank_chain_payment.sol
|
2,273 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value);
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
emit Transfer(_from, _to, _value);
return true;
}
| false |
spank_chain_payment.sol
|
2,274 |
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| false |
spank_chain_payment.sol
|
2,275 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
| false |
spank_chain_payment.sol
|
2,276 |
function recoverSigner(bytes32 _hashedMsg, string _sig) public pure returns (address) {
require(_hashedMsg != 0x00);
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 prefixedHash = keccak256(abi.encodePacked(prefix, _hashedMsg));
if (bytes(_sig).length != 132) {
return 0x0;
}
bytes32 r;
bytes32 s;
uint8 v;
bytes memory sig = hexstrToBytes(substring(_sig, 2, 132));
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}
if (v < 27 || v > 28) {
return 0x0;
}
return ecrecover(prefixedHash, v, r, s);
}
| false |
spank_chain_payment.sol
|
2,277 |
function isSignedBy(bytes32 _hashedMsg, string _sig, address _addr) public pure returns (bool) {
require(_addr != 0x0);
return _addr == recoverSigner(_hashedMsg, _sig);
}
| false |
spank_chain_payment.sol
|
2,278 |
function hexstrToBytes(string _hexstr) public pure returns (bytes) {
uint len = bytes(_hexstr).length;
require(len % 2 == 0);
bytes memory bstr = bytes(new string(len / 2));
uint k = 0;
string memory s;
string memory r;
for (uint i = 0; i < len; i += 2) {
s = substring(_hexstr, i, i + 1);
r = substring(_hexstr, i + 1, i + 2);
uint p = parseInt16Char(s) * 16 + parseInt16Char(r);
bstr[k++] = uintToBytes32(p)[31];
}
return bstr;
}
| false |
spank_chain_payment.sol
|
2,279 |
function parseInt16Char(string _char) public pure returns (uint) {
bytes memory bresult = bytes(_char);
if ((bresult[0] >= 48) && (bresult[0] <= 57)) {
return uint(bresult[0]) - 48;
} else if ((bresult[0] >= 65) && (bresult[0] <= 70)) {
return uint(bresult[0]) - 55;
} else if ((bresult[0] >= 97) && (bresult[0] <= 102)) {
return uint(bresult[0]) - 87;
} else {
revert();
}
}
| false |
spank_chain_payment.sol
|
2,280 |
function uintToBytes32(uint _uint) public pure returns (bytes b) {
b = new bytes(32);
assembly {mstore(add(b, 32), _uint)}
}
| false |
spank_chain_payment.sol
|
2,281 |
function toEthereumSignedMessage(string _msg) public pure returns (bytes32) {
uint len = bytes(_msg).length;
require(len > 0);
bytes memory prefix = "\x19Ethereum Signed Message:\n";
return keccak256(abi.encodePacked(prefix, uintToString(len), _msg));
}
| false |
spank_chain_payment.sol
|
2,282 |
function uintToString(uint _uint) public pure returns (string str) {
uint len = 0;
uint m = _uint + 0;
while (m != 0) {
len++;
m /= 10;
}
bytes memory b = new bytes(len);
uint i = len - 1;
while (_uint != 0) {
uint remainder = _uint % 10;
_uint = _uint / 10;
b[i--] = byte(48 + remainder);
}
str = string(b);
}
| false |
spank_chain_payment.sol
|
2,283 |
function substring(string _str, uint _startIndex, uint _endIndex) public pure returns (string) {
bytes memory strBytes = bytes(_str);
require(_startIndex <= _endIndex);
require(_startIndex >= 0);
require(_endIndex <= strBytes.length);
bytes memory result = new bytes(_endIndex - _startIndex);
for (uint i = _startIndex; i < _endIndex; i++) {
result[i - _startIndex] = strBytes[i];
}
return string(result);
}
| false |
spank_chain_payment.sol
|
2,284 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
require(_spender.call(bytes4(bytes32(keccak256("receiveApproval(address,uint256,address,bytes)"))), msg.sender, _value, this, _extraData));
return true;
}
| false |
spank_chain_payment.sol
|
2,285 |
function createChannel(
bytes32 _lcID,
address _partyI,
uint256 _confirmTime,
address _token,
uint256[2] _balances
)
public
payable
{
require(Channels[_lcID].partyAddresses[0] == address(0), "Channel has already been created.");
require(_partyI != 0x0, "No partyI address provided to LC creation");
require(_balances[0] >= 0 && _balances[1] >= 0, "Balances cannot be negative");
Channels[_lcID].partyAddresses[0] = msg.sender;
Channels[_lcID].partyAddresses[1] = _partyI;
if(_balances[0] != 0) {
require(msg.value == _balances[0], "Eth balance does not match sent value");
Channels[_lcID].ethBalances[0] = msg.value;
}
if(_balances[1] != 0) {
Channels[_lcID].token = HumanStandardToken(_token);
require(Channels[_lcID].token.transferFrom(msg.sender, this, _balances[1]),"CreateChannel: token transfer failure");
Channels[_lcID].erc20Balances[0] = _balances[1];
}
Channels[_lcID].sequence = 0;
Channels[_lcID].confirmTime = _confirmTime;
Channels[_lcID].LCopenTimeout = now + _confirmTime;
Channels[_lcID].initialDeposit = _balances;
emit DidLCOpen(_lcID, msg.sender, _partyI, _balances[0], _token, _balances[1], Channels[_lcID].LCopenTimeout);
}
| false |
spank_chain_payment.sol
|
2,286 |
function LCOpenTimeout(bytes32 _lcID) public {
require(msg.sender == Channels[_lcID].partyAddresses[0] && Channels[_lcID].isOpen == false);
require(now > Channels[_lcID].LCopenTimeout);
if(Channels[_lcID].initialDeposit[0] != 0) {
Channels[_lcID].partyAddresses[0].transfer(Channels[_lcID].ethBalances[0]);
}
if(Channels[_lcID].initialDeposit[1] != 0) {
require(Channels[_lcID].token.transfer(Channels[_lcID].partyAddresses[0], Channels[_lcID].erc20Balances[0]),"CreateChannel: token transfer failure");
}
emit DidLCClose(_lcID, 0, Channels[_lcID].ethBalances[0], Channels[_lcID].erc20Balances[0], 0, 0);
delete Channels[_lcID];
}
| true |
spank_chain_payment.sol
|
2,287 |
function joinChannel(bytes32 _lcID, uint256[2] _balances) public payable {
require(Channels[_lcID].isOpen == false);
require(msg.sender == Channels[_lcID].partyAddresses[1]);
if(_balances[0] != 0) {
require(msg.value == _balances[0], "state balance does not match sent value");
Channels[_lcID].ethBalances[1] = msg.value;
}
if(_balances[1] != 0) {
require(Channels[_lcID].token.transferFrom(msg.sender, this, _balances[1]),"joinChannel: token transfer failure");
Channels[_lcID].erc20Balances[1] = _balances[1];
}
Channels[_lcID].initialDeposit[0]+=_balances[0];
Channels[_lcID].initialDeposit[1]+=_balances[1];
Channels[_lcID].isOpen = true;
numChannels++;
emit DidLCJoin(_lcID, _balances[0], _balances[1]);
}
| false |
spank_chain_payment.sol
|
2,288 |
function deposit(bytes32 _lcID, address recipient, uint256 _balance, bool isToken) public payable {
require(Channels[_lcID].isOpen == true, "Tried adding funds to a closed channel");
require(recipient == Channels[_lcID].partyAddresses[0] || recipient == Channels[_lcID].partyAddresses[1]);
if (Channels[_lcID].partyAddresses[0] == recipient) {
if(isToken) {
require(Channels[_lcID].token.transferFrom(msg.sender, this, _balance),"deposit: token transfer failure");
Channels[_lcID].erc20Balances[2] += _balance;
} else {
require(msg.value == _balance, "state balance does not match sent value");
Channels[_lcID].ethBalances[2] += msg.value;
}
}
if (Channels[_lcID].partyAddresses[1] == recipient) {
if(isToken) {
require(Channels[_lcID].token.transferFrom(msg.sender, this, _balance),"deposit: token transfer failure");
Channels[_lcID].erc20Balances[3] += _balance;
} else {
require(msg.value == _balance, "state balance does not match sent value");
Channels[_lcID].ethBalances[3] += msg.value;
}
}
emit DidLCDeposit(_lcID, recipient, _balance, isToken);
}
| false |
spank_chain_payment.sol
|
2,289 |
function consensusCloseChannel(
bytes32 _lcID,
uint256 _sequence,
uint256[4] _balances,
string _sigA,
string _sigI
)
public
{
require(Channels[_lcID].isOpen == true);
uint256 totalEthDeposit = Channels[_lcID].initialDeposit[0] + Channels[_lcID].ethBalances[2] + Channels[_lcID].ethBalances[3];
uint256 totalTokenDeposit = Channels[_lcID].initialDeposit[1] + Channels[_lcID].erc20Balances[2] + Channels[_lcID].erc20Balances[3];
require(totalEthDeposit == _balances[0] + _balances[1]);
require(totalTokenDeposit == _balances[2] + _balances[3]);
bytes32 _state = keccak256(
abi.encodePacked(
_lcID,
true,
_sequence,
uint256(0),
bytes32(0x0),
Channels[_lcID].partyAddresses[0],
Channels[_lcID].partyAddresses[1],
_balances[0],
_balances[1],
_balances[2],
_balances[3]
)
);
require(Channels[_lcID].partyAddresses[0] == ECTools.recoverSigner(_state, _sigA));
require(Channels[_lcID].partyAddresses[1] == ECTools.recoverSigner(_state, _sigI));
Channels[_lcID].isOpen = false;
if(_balances[0] != 0 || _balances[1] != 0) {
Channels[_lcID].partyAddresses[0].transfer(_balances[0]);
Channels[_lcID].partyAddresses[1].transfer(_balances[1]);
}
if(_balances[2] != 0 || _balances[3] != 0) {
require(Channels[_lcID].token.transfer(Channels[_lcID].partyAddresses[0], _balances[2]),"happyCloseChannel: token transfer failure");
require(Channels[_lcID].token.transfer(Channels[_lcID].partyAddresses[1], _balances[3]),"happyCloseChannel: token transfer failure");
}
numChannels--;
emit DidLCClose(_lcID, _sequence, _balances[0], _balances[1], _balances[2], _balances[3]);
}
| false |
spank_chain_payment.sol
|
2,290 |
function updateLCstate(
bytes32 _lcID,
uint256[6] updateParams,
bytes32 _VCroot,
string _sigA,
string _sigI
)
public
{
Channel storage channel = Channels[_lcID];
require(channel.isOpen);
require(channel.sequence < updateParams[0]);
require(channel.ethBalances[0] + channel.ethBalances[1] >= updateParams[2] + updateParams[3]);
require(channel.erc20Balances[0] + channel.erc20Balances[1] >= updateParams[4] + updateParams[5]);
if(channel.isUpdateLCSettling == true) {
require(channel.updateLCtimeout > now);
}
bytes32 _state = keccak256(
abi.encodePacked(
_lcID,
false,
updateParams[0],
updateParams[1],
_VCroot,
channel.partyAddresses[0],
channel.partyAddresses[1],
updateParams[2],
updateParams[3],
updateParams[4],
updateParams[5]
)
);
require(channel.partyAddresses[0] == ECTools.recoverSigner(_state, _sigA));
require(channel.partyAddresses[1] == ECTools.recoverSigner(_state, _sigI));
channel.sequence = updateParams[0];
channel.numOpenVC = updateParams[1];
channel.ethBalances[0] = updateParams[2];
channel.ethBalances[1] = updateParams[3];
channel.erc20Balances[0] = updateParams[4];
channel.erc20Balances[1] = updateParams[5];
channel.VCrootHash = _VCroot;
channel.isUpdateLCSettling = true;
channel.updateLCtimeout = now + channel.confirmTime;
emit DidLCUpdateState (
_lcID,
updateParams[0],
updateParams[1],
updateParams[2],
updateParams[3],
updateParams[4],
updateParams[5],
_VCroot,
channel.updateLCtimeout
);
}
| false |
spank_chain_payment.sol
|
2,291 |
function initVCstate(
bytes32 _lcID,
bytes32 _vcID,
bytes _proof,
address _partyA,
address _partyB,
uint256[2] _bond,
uint256[4] _balances,
string sigA
)
public
{
require(Channels[_lcID].isOpen, "LC is closed.");
require(!virtualChannels[_vcID].isClose, "VC is closed.");
require(Channels[_lcID].updateLCtimeout < now, "LC timeout not over.");
require(virtualChannels[_vcID].updateVCtimeout == 0);
bytes32 _initState = keccak256(
abi.encodePacked(_vcID, uint256(0), _partyA, _partyB, _bond[0], _bond[1], _balances[0], _balances[1], _balances[2], _balances[3])
);
require(_partyA == ECTools.recoverSigner(_initState, sigA));
require(_isContained(_initState, _proof, Channels[_lcID].VCrootHash) == true);
virtualChannels[_vcID].partyA = _partyA;
virtualChannels[_vcID].partyB = _partyB;
virtualChannels[_vcID].sequence = uint256(0);
virtualChannels[_vcID].ethBalances[0] = _balances[0];
virtualChannels[_vcID].ethBalances[1] = _balances[1];
virtualChannels[_vcID].erc20Balances[0] = _balances[2];
virtualChannels[_vcID].erc20Balances[1] = _balances[3];
virtualChannels[_vcID].bond = _bond;
virtualChannels[_vcID].updateVCtimeout = now + Channels[_lcID].confirmTime;
virtualChannels[_vcID].isInSettlementState = true;
emit DidVCInit(_lcID, _vcID, _proof, uint256(0), _partyA, _partyB, _balances[0], _balances[1]);
}
| false |
spank_chain_payment.sol
|
2,292 |
function settleVC(
bytes32 _lcID,
bytes32 _vcID,
uint256 updateSeq,
address _partyA,
address _partyB,
uint256[4] updateBal,
string sigA
)
public
{
require(Channels[_lcID].isOpen, "LC is closed.");
require(!virtualChannels[_vcID].isClose, "VC is closed.");
require(virtualChannels[_vcID].sequence < updateSeq, "VC sequence is higher than update sequence.");
require(
virtualChannels[_vcID].ethBalances[1] < updateBal[1] && virtualChannels[_vcID].erc20Balances[1] < updateBal[3],
"State updates may only increase recipient balance."
);
require(
virtualChannels[_vcID].bond[0] == updateBal[0] + updateBal[1] &&
virtualChannels[_vcID].bond[1] == updateBal[2] + updateBal[3],
"Incorrect balances for bonded amount");
require(Channels[_lcID].updateLCtimeout < now);
bytes32 _updateState = keccak256(
abi.encodePacked(
_vcID,
updateSeq,
_partyA,
_partyB,
virtualChannels[_vcID].bond[0],
virtualChannels[_vcID].bond[1],
updateBal[0],
updateBal[1],
updateBal[2],
updateBal[3]
)
);
require(virtualChannels[_vcID].partyA == ECTools.recoverSigner(_updateState, sigA));
virtualChannels[_vcID].challenger = msg.sender;
virtualChannels[_vcID].sequence = updateSeq;
virtualChannels[_vcID].ethBalances[0] = updateBal[0];
virtualChannels[_vcID].ethBalances[1] = updateBal[1];
virtualChannels[_vcID].erc20Balances[0] = updateBal[2];
virtualChannels[_vcID].erc20Balances[1] = updateBal[3];
virtualChannels[_vcID].updateVCtimeout = now + Channels[_lcID].confirmTime;
emit DidVCSettle(_lcID, _vcID, updateSeq, updateBal[0], updateBal[1], msg.sender, virtualChannels[_vcID].updateVCtimeout);
}
| false |
spank_chain_payment.sol
|
2,293 |
function closeVirtualChannel(bytes32 _lcID, bytes32 _vcID) public {
require(Channels[_lcID].isOpen, "LC is closed.");
require(virtualChannels[_vcID].isInSettlementState, "VC is not in settlement state.");
require(virtualChannels[_vcID].updateVCtimeout < now, "Update vc timeout has not elapsed.");
require(!virtualChannels[_vcID].isClose, "VC is already closed");
Channels[_lcID].numOpenVC--;
virtualChannels[_vcID].isClose = true;
if(virtualChannels[_vcID].partyA == Channels[_lcID].partyAddresses[0]) {
Channels[_lcID].ethBalances[0] += virtualChannels[_vcID].ethBalances[0];
Channels[_lcID].ethBalances[1] += virtualChannels[_vcID].ethBalances[1];
Channels[_lcID].erc20Balances[0] += virtualChannels[_vcID].erc20Balances[0];
Channels[_lcID].erc20Balances[1] += virtualChannels[_vcID].erc20Balances[1];
} else if (virtualChannels[_vcID].partyB == Channels[_lcID].partyAddresses[0]) {
Channels[_lcID].ethBalances[0] += virtualChannels[_vcID].ethBalances[1];
Channels[_lcID].ethBalances[1] += virtualChannels[_vcID].ethBalances[0];
Channels[_lcID].erc20Balances[0] += virtualChannels[_vcID].erc20Balances[1];
Channels[_lcID].erc20Balances[1] += virtualChannels[_vcID].erc20Balances[0];
}
emit DidVCClose(_lcID, _vcID, virtualChannels[_vcID].erc20Balances[0], virtualChannels[_vcID].erc20Balances[1]);
}
| false |
spank_chain_payment.sol
|
2,294 |
function byzantineCloseChannel(bytes32 _lcID) public {
Channel storage channel = Channels[_lcID];
require(channel.isOpen, "Channel is not open");
require(channel.isUpdateLCSettling == true);
require(channel.numOpenVC == 0);
require(channel.updateLCtimeout < now, "LC timeout over.");
uint256 totalEthDeposit = channel.initialDeposit[0] + channel.ethBalances[2] + channel.ethBalances[3];
uint256 totalTokenDeposit = channel.initialDeposit[1] + channel.erc20Balances[2] + channel.erc20Balances[3];
uint256 possibleTotalEthBeforeDeposit = channel.ethBalances[0] + channel.ethBalances[1];
uint256 possibleTotalTokenBeforeDeposit = channel.erc20Balances[0] + channel.erc20Balances[1];
if(possibleTotalEthBeforeDeposit < totalEthDeposit) {
channel.ethBalances[0]+=channel.ethBalances[2];
channel.ethBalances[1]+=channel.ethBalances[3];
} else {
require(possibleTotalEthBeforeDeposit == totalEthDeposit);
}
if(possibleTotalTokenBeforeDeposit < totalTokenDeposit) {
channel.erc20Balances[0]+=channel.erc20Balances[2];
channel.erc20Balances[1]+=channel.erc20Balances[3];
} else {
require(possibleTotalTokenBeforeDeposit == totalTokenDeposit);
}
uint256 ethbalanceA = channel.ethBalances[0];
uint256 ethbalanceI = channel.ethBalances[1];
uint256 tokenbalanceA = channel.erc20Balances[0];
uint256 tokenbalanceI = channel.erc20Balances[1];
channel.ethBalances[0] = 0;
channel.ethBalances[1] = 0;
channel.erc20Balances[0] = 0;
channel.erc20Balances[1] = 0;
if(ethbalanceA != 0 || ethbalanceI != 0) {
channel.partyAddresses[0].transfer(ethbalanceA);
channel.partyAddresses[1].transfer(ethbalanceI);
}
if(tokenbalanceA != 0 || tokenbalanceI != 0) {
require(
channel.token.transfer(channel.partyAddresses[0], tokenbalanceA),
"byzantineCloseChannel: token transfer failure"
);
require(
channel.token.transfer(channel.partyAddresses[1], tokenbalanceI),
"byzantineCloseChannel: token transfer failure"
);
}
channel.isOpen = false;
numChannels--;
emit DidLCClose(_lcID, channel.sequence, ethbalanceA, ethbalanceI, tokenbalanceA, tokenbalanceI);
}
| false |
spank_chain_payment.sol
|
2,295 |
function _isContained(bytes32 _hash, bytes _proof, bytes32 _root) internal pure returns (bool) {
bytes32 cursor = _hash;
bytes32 proofElem;
for (uint256 i = 64; i <= _proof.length; i += 32) {
assembly { proofElem := mload(add(_proof, i)) }
if (cursor < proofElem) {
cursor = keccak256(abi.encodePacked(cursor, proofElem));
} else {
cursor = keccak256(abi.encodePacked(proofElem, cursor));
}
}
return cursor == _root;
}
| false |
spank_chain_payment.sol
|
2,296 |
function getChannel(bytes32 id) public view returns (
address[2],
uint256[4],
uint256[4],
uint256[2],
uint256,
uint256,
bytes32,
uint256,
uint256,
bool,
bool,
uint256
) {
Channel memory channel = Channels[id];
return (
channel.partyAddresses,
channel.ethBalances,
channel.erc20Balances,
channel.initialDeposit,
channel.sequence,
channel.confirmTime,
channel.VCrootHash,
channel.LCopenTimeout,
channel.updateLCtimeout,
channel.isOpen,
channel.isUpdateLCSettling,
channel.numOpenVC
);
}
| false |
spank_chain_payment.sol
|
2,297 |
function getVirtualChannel(bytes32 id) public view returns(
bool,
bool,
uint256,
address,
uint256,
address,
address,
address,
uint256[2],
uint256[2],
uint256[2]
) {
VirtualChannel memory virtualChannel = virtualChannels[id];
return(
virtualChannel.isClose,
virtualChannel.isInSettlementState,
virtualChannel.sequence,
virtualChannel.challenger,
virtualChannel.updateVCtimeout,
virtualChannel.partyA,
virtualChannel.partyB,
virtualChannel.partyI,
virtualChannel.ethBalances,
virtualChannel.erc20Balances,
virtualChannel.bond
);
}
| false |
spank_chain_payment.sol
|
2,298 |
function transferOwnership(address _newOwner) public
onlyOwner
{
require(_newOwner != address(0), "Address should not be 0x0");
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
}
| false |
0x2860685847546b39f8c75a6dfb7d8d40d34b75f6.sol
|
2,299 |
function renounceOwnership() public
onlyOwner
{
emit OwnershipRenounced(owner);
owner = address(0);
}
| false |
0x2860685847546b39f8c75a6dfb7d8d40d34b75f6.sol
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.