Blockwell

Plasma

ERC20

This contract is an ERC20 token.

Name Plasma
Symbol PPAY
Decimals 18
Total Supply 1,000,000,000 PPAY

About link description

Plasma Finance (PPAY) is a cryptocurrency and operates on the Ethereum platform. Plasma Finance has a current supply of 1,000,000,000 with 123,116,295.46 in circulation. The last known price of Plasma Finance is 0.04254516 USD and is down -3.80 over the last 24 hours. It is currently trading on 13 active market(s) with $210,607.27 traded over the last 24 hours. More information can be found at https://plasma.finance.

Stats

Public Functions 10
Event Types 4
Code Size 20,840 bytes

Events (4) keyboard_arrow_up

Approval Event

Parameters help
owner
address help
spender
address help
amount
uint256 help

DelegateChanged Event

Parameters help
delegator
address help
fromDelegate
address help
toDelegate
address help

DelegateVotesChanged Event

Parameters help
delegate
address help
previousBalance
uint256 help
newBalance
uint256 help

Transfer Event

Parameters help
from
address help
to
address help
amount
uint256 help

Checkpoint Struct

Members
fromBlock
uint32 help
votes
uint96 help

name Constant

string help
Plasma

symbol Constant

string help
PPAY

decimals Constant

uint8 help
18

totalSupply Constant

uint256 help
1_000_000_000e18

DOMAIN_TYPEHASH Constant

bytes32 help
the result of calling keccak256 with "EIP712Domain(string name,uint256 chainId,address verifyingContract)"

DELEGATION_TYPEHASH Constant

bytes32 help
the result of calling keccak256 with "Delegation(address delegatee,uint256 nonce,uint256 expiry)"

PERMIT_TYPEHASH Constant

bytes32 help
the result of calling keccak256 with "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"

delegates Variable

mapping(address => address) help

numCheckpoints Variable

mapping(address => uint32) help

nonces Variable

mapping(address => uint256) help

allowances Variable

mapping(address => mapping(address => uint96)) help
Internal Variable

balances Variable

mapping(address => uint96) help
Internal Variable

checkpoints Variable

mapping(address => mapping(uint32 => Checkpoint)) help
Internal Variable

Functions Expand All Collapse All

Parameters help

Name Type
account
address help
spender
address help

Properties

Visibility help public
Mutability help view
Source Code
function allowance(address account, address spender)
  external
  view
  returns (uint256)
{
  return allowances[account][spender];
}

Parameters help

Name Type
spender
address help
rawAmount
uint256 help

Properties

Visibility help public
Mutability help transaction
Source Code
function approve(address spender, uint256 rawAmount) external returns (bool) {
  uint96 amount;
  if (rawAmount == uint256(-1)) {
    amount = uint96(-1);
  } else {
    amount = safe96(rawAmount, "Ppay::approve: amount exceeds 96 bits");
  }

  allowances[msg.sender][spender] = amount;

  emit Approval(msg.sender, spender, amount);
  return true;
}

Parameters help

Name Type
owner
address help
spender
address help
rawAmount
uint256 help
deadline
uint256 help
v
uint8 help
r
bytes32 help
s
bytes32 help

Properties

Visibility help public
Mutability help transaction
Source Code
function permit(
  address owner,
  address spender,
  uint256 rawAmount,
  uint256 deadline,
  uint8 v,
  bytes32 r,
  bytes32 s
) external {
  uint96 amount;
  if (rawAmount == uint256(-1)) {
    amount = uint96(-1);
  } else {
    amount = safe96(rawAmount, "Ppay::permit: amount exceeds 96 bits");
  }

  bytes32 domainSeparator = keccak256(
    abi.encode(
      DOMAIN_TYPEHASH,
      keccak256(bytes(name)),
      getChainId(),
      address(this)
    )
  );
  bytes32 structHash = keccak256(
    abi.encode(
      PERMIT_TYPEHASH,
      owner,
      spender,
      rawAmount,
      nonces[owner]++,
      deadline
    )
  );
  bytes32 digest = keccak256(
    abi.encodePacked("\x19\x01", domainSeparator, structHash)
  );
  address signatory = ecrecover(digest, v, r, s);
  require(signatory != address(0), "Ppay::permit: invalid signature");
  require(signatory == owner, "Ppay::permit: unauthorized");
  require(now <= deadline, "Ppay::permit: signature expired");

  allowances[owner][spender] = amount;

  emit Approval(owner, spender, amount);
}

Parameters help

Name Type
account
address help

Properties

Visibility help public
Mutability help view
Source Code
function balanceOf(address account) external view returns (uint256) {
  return balances[account];
}

Parameters help

Name Type
dst
address help
rawAmount
uint256 help

Properties

Visibility help public
Mutability help transaction

Requirements help

Source Code
function transfer(address dst, uint256 rawAmount) external returns (bool) {
  uint96 amount = safe96(rawAmount, "Ppay::transfer: amount exceeds 96 bits");
  _transferTokens(msg.sender, dst, amount);
  return true;
}

Parameters help

Name Type
src
address help
dst
address help
rawAmount
uint256 help

Properties

Visibility help public
Mutability help transaction

Requirements help

Source Code
function transferFrom(
  address src,
  address dst,
  uint256 rawAmount
) external returns (bool) {
  address spender = msg.sender;
  uint96 spenderAllowance = allowances[src][spender];
  uint96 amount = safe96(rawAmount, "Ppay::approve: amount exceeds 96 bits");

  if (spender != src && spenderAllowance != uint96(-1)) {
    uint96 newAllowance = sub96(
      spenderAllowance,
      amount,
      "Ppay::transferFrom: transfer amount exceeds spender allowance"
    );
    allowances[src][spender] = newAllowance;

    emit Approval(src, spender, newAllowance);
  }

  _transferTokens(src, dst, amount);
  return true;
}

Parameters help

Name Type
delegatee
address help

Properties

Visibility help public
Mutability help transaction
Source Code
function delegate(address delegatee) external {
  return _delegate(msg.sender, delegatee);
}

Parameters help

Name Type
delegatee
address help
nonce
uint256 help
expiry
uint256 help
v
uint8 help
r
bytes32 help
s
bytes32 help

Properties

Visibility help public
Mutability help transaction
Source Code
function delegateBySig(
  address delegatee,
  uint256 nonce,
  uint256 expiry,
  uint8 v,
  bytes32 r,
  bytes32 s
) external {
  bytes32 domainSeparator = keccak256(
    abi.encode(
      DOMAIN_TYPEHASH,
      keccak256(bytes(name)),
      getChainId(),
      address(this)
    )
  );
  bytes32 structHash = keccak256(
    abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry)
  );
  bytes32 digest = keccak256(
    abi.encodePacked("\x19\x01", domainSeparator, structHash)
  );
  address signatory = ecrecover(digest, v, r, s);
  require(signatory != address(0), "Ppay::delegateBySig: invalid signature");
  require(nonce == nonces[signatory]++, "Ppay::delegateBySig: invalid nonce");
  require(now <= expiry, "Ppay::delegateBySig: signature expired");
  return _delegate(signatory, delegatee);
}

Parameters help

Name Type
account
address help

Properties

Visibility help public
Mutability help view
Source Code
function getCurrentVotes(address account) external view returns (uint96) {
  uint32 nCheckpoints = numCheckpoints[account];
  return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0;
}

Parameters help

Name Type
account
address help
blockNumber
uint help

Properties

Visibility help public
Mutability help view

Requirements help

Source Code
function getPriorVotes(address account, uint256 blockNumber)
  external
  view
  returns (uint96)
{
  require(
    blockNumber < block.number,
    "Ppay::getPriorVotes: not yet determined"
  );

  uint32 nCheckpoints = numCheckpoints[account];
  if (nCheckpoints == 0) {
    return 0;
  }

  // First check most recent balance
  if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) {
    return checkpoints[account][nCheckpoints - 1].votes;
  }

  // Next check implicit zero balance
  if (checkpoints[account][0].fromBlock > blockNumber) {
    return 0;
  }

  uint32 lower = 0;
  uint32 upper = nCheckpoints - 1;
  while (upper > lower) {
    uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow
    Checkpoint memory cp = checkpoints[account][center];
    if (cp.fromBlock == blockNumber) {
      return cp.votes;
    } else if (cp.fromBlock < blockNumber) {
      lower = center;
    } else {
      upper = center - 1;
    }
  }
  return checkpoints[account][lower].votes;
}

Internal Functions Expand All Collapse All

Internal functions are parts of the contract that can't be used directly, but instead are used by the public functions listed above.

internal Ppay._delegate keyboard_arrow_up

Parameters help

Name Type
delegator
address help
delegatee
address help

Properties

Visibility help internal
Mutability help transaction
Source Code
function _delegate(address delegator, address delegatee) internal {
  address currentDelegate = delegates[delegator];
  uint96 delegatorBalance = balances[delegator];
  delegates[delegator] = delegatee;

  emit DelegateChanged(delegator, currentDelegate, delegatee);

  _moveDelegates(currentDelegate, delegatee, delegatorBalance);
}

internal Ppay._transferTokens keyboard_arrow_up

Parameters help

Name Type
src
address help
dst
address help
amount
uint96 help

Properties

Visibility help internal
Mutability help transaction

Requirements help

Source Code
function _transferTokens(
  address src,
  address dst,
  uint96 amount
) internal {
  require(
    src != address(0),
    "Ppay::_transferTokens: cannot transfer from the zero address"
  );
  require(
    dst != address(0),
    "Ppay::_transferTokens: cannot transfer to the zero address"
  );

  balances[src] = sub96(
    balances[src],
    amount,
    "Ppay::_transferTokens: transfer amount exceeds balance"
  );
  balances[dst] = add96(
    balances[dst],
    amount,
    "Ppay::_transferTokens: transfer amount overflows"
  );
  emit Transfer(src, dst, amount);

  _moveDelegates(delegates[src], delegates[dst], amount);
}

internal Ppay._moveDelegates keyboard_arrow_up

Parameters help

Name Type
srcRep
address help
dstRep
address help
amount
uint96 help

Properties

Visibility help internal
Mutability help transaction
Source Code
function _moveDelegates(
  address srcRep,
  address dstRep,
  uint96 amount
) internal {
  if (srcRep != dstRep && amount > 0) {
    if (srcRep != address(0)) {
      uint32 srcRepNum = numCheckpoints[srcRep];
      uint96 srcRepOld = srcRepNum > 0
        ? checkpoints[srcRep][srcRepNum - 1].votes
        : 0;
      uint96 srcRepNew = sub96(
        srcRepOld,
        amount,
        "Ppay::_moveVotes: vote amount underflows"
      );
      _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew);
    }

    if (dstRep != address(0)) {
      uint32 dstRepNum = numCheckpoints[dstRep];
      uint96 dstRepOld = dstRepNum > 0
        ? checkpoints[dstRep][dstRepNum - 1].votes
        : 0;
      uint96 dstRepNew = add96(
        dstRepOld,
        amount,
        "Ppay::_moveVotes: vote amount overflows"
      );
      _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
    }
  }
}

internal Ppay._writeCheckpoint keyboard_arrow_up

Parameters help

Name Type
delegatee
address help
nCheckpoints
uint32 help
oldVotes
uint96 help
newVotes
uint96 help

Properties

Visibility help internal
Mutability help transaction
Source Code
function _writeCheckpoint(
  address delegatee,
  uint32 nCheckpoints,
  uint96 oldVotes,
  uint96 newVotes
) internal {
  uint32 blockNumber = safe32(
    block.number,
    "Ppay::_writeCheckpoint: block number exceeds 32 bits"
  );

  if (
    nCheckpoints > 0 &&
    checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber
  ) {
    checkpoints[delegatee][nCheckpoints - 1].votes = newVotes;
  } else {
    checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes);
    numCheckpoints[delegatee] = nCheckpoints + 1;
  }

  emit DelegateVotesChanged(delegatee, oldVotes, newVotes);
}

internal Ppay.safe32 keyboard_arrow_up

Parameters help

Name Type
n
uint256 help
errorMessage
string help

Properties

Visibility help internal
Mutability help pure

Requirements help

Source Code
function safe32(uint256 n, string memory errorMessage)
  internal
  pure
  returns (uint32)
{
  require(n < 2**32, errorMessage);
  return uint32(n);
}

internal Ppay.safe96 keyboard_arrow_up

Parameters help

Name Type
n
uint256 help
errorMessage
string help

Properties

Visibility help internal
Mutability help pure

Requirements help

Source Code
function safe96(uint256 n, string memory errorMessage)
  internal
  pure
  returns (uint96)
{
  require(n < 2**96, errorMessage);
  return uint96(n);
}

internal Ppay.add96 keyboard_arrow_up

Parameters help

Name Type
a
uint96 help
b
uint96 help
errorMessage
string help

Properties

Visibility help internal
Mutability help pure

Requirements help

Source Code
function add96(
  uint96 a,
  uint96 b,
  string memory errorMessage
) internal pure returns (uint96) {
  uint96 c = a + b;
  require(c >= a, errorMessage);
  return c;
}

internal Ppay.sub96 keyboard_arrow_up

Parameters help

Name Type
a
uint96 help
b
uint96 help
errorMessage
string help

Properties

Visibility help internal
Mutability help pure

Requirements help

Source Code
function sub96(
  uint96 a,
  uint96 b,
  string memory errorMessage
) internal pure returns (uint96) {
  require(b <= a, errorMessage);
  return a - b;
}

internal Ppay.getChainId keyboard_arrow_up

Parameters help

This function has no parameters.

Properties

Visibility help internal
Mutability help pure
Source Code
function getChainId() internal pure returns (uint256) {
  uint256 chainId;
  assembly {
    chainId := chainid()
  }
  return chainId;
}