Uniswap

0x1f9840a85d5af5bf1d1762f925bdaddc4201f984 Copy

ERC20

This contract is an ERC20 token.

Name Uniswap

Symbol UNI

Decimals 18

Total Supply 1,000,000,000 UNI

About

Uniswap (UNI) is a cryptocurrency and operates on the Ethereum platform. Uniswap has a current supply of 1,000,000,000 with 587,309,345.1031033 in circulation. The last known price of Uniswap is 16.92518225 USD and is down -0.58 over the last 24 hours. It is currently trading on 266 active market(s) with $372,473,527.39 traded over the last 24 hours. More information can be found at https://uniswap.org/blog/uni/.

Stats

Public Functions 12

Event Types 5

Code Size 23,858 bytes

Events (5)

Approval Event

Parameters

owner	address
spender	address
amount	uint256

DelegateChanged Event

Parameters

delegator	address
fromDelegate	address
toDelegate	address

DelegateVotesChanged Event

Parameters

delegate	address
previousBalance	uint
newBalance	uint

MinterChanged Event

Parameters

minter	address
newMinter	address

Transfer Event

Parameters

from	address
to	address
amount	uint256

Structs (1)

Checkpoint Struct

Members

fromBlock	uint32
votes	uint96

Constants (8)

name Constant

string

Uniswap

symbol Constant

string

UNI

decimals Constant

uint8

minimumTimeBetweenMints Constant

uint32

1 days * 365

mintCap Constant

uint8

DOMAIN_TYPEHASH Constant

bytes32

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

DELEGATION_TYPEHASH Constant

bytes32

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

PERMIT_TYPEHASH Constant

bytes32

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

State Variables (9)

totalSupply Variable

uint

minter Variable

address

mintingAllowedAfter Variable

uint

delegates Variable

mapping(address => address)

numCheckpoints Variable

mapping(address => uint32)

nonces Variable

mapping(address => uint)

allowances Variable

mapping(address => mapping(address => uint96))

Internal Variable

balances Variable

mapping(address => uint96)

Internal Variable

checkpoints Variable

mapping(address => mapping(uint32 => Checkpoint))

Internal Variable

Functions Expand All Collapse All

setMinter

Parameters

Name	Type
minter_	address

Properties

Visibility public

Mutability transaction

Requirements

minter must be equal to the sender's address

Source Code

function setMinter(address minter_) external {
  require(
    msg.sender == minter,
    "Uni::setMinter: only the minter can change the minter address"
  );
  emit MinterChanged(minter, minter_);
  minter = minter_;
}

mint

Parameters

Name	Type
dst	address
rawAmount	uint

Properties

Visibility public

Mutability transaction

Requirements

minter must be equal to the sender's address

mintingAllowedAfter must be less than or equal to block.timestamp

dst must not be equal to UNKNOWN VALUE

amount must be less than or equal to UNKNOWN VALUE

Source Code

function mint(address dst, uint256 rawAmount) external {
  require(msg.sender == minter, "Uni::mint: only the minter can mint");
  require(
    block.timestamp >= mintingAllowedAfter,
    "Uni::mint: minting not allowed yet"
  );
  require(dst != address(0), "Uni::mint: cannot transfer to the zero address");

  // record the mint
  mintingAllowedAfter = SafeMath.add(block.timestamp, minimumTimeBetweenMints);

  // mint the amount
  uint96 amount = safe96(rawAmount, "Uni::mint: amount exceeds 96 bits");
  require(
    amount <= SafeMath.div(SafeMath.mul(totalSupply, mintCap), 100),
    "Uni::mint: exceeded mint cap"
  );
  totalSupply = safe96(
    SafeMath.add(totalSupply, amount),
    "Uni::mint: totalSupply exceeds 96 bits"
  );

  // transfer the amount to the recipient
  balances[dst] = add96(
    balances[dst],
    amount,
    "Uni::mint: transfer amount overflows"
  );
  emit Transfer(address(0), dst, amount);

  // move delegates
  _moveDelegates(address(0), delegates[dst], amount);
}

allowance

Parameters

Name	Type
account	address
spender	address

Properties

Visibility public

Mutability view

Source Code

function allowance(address account, address spender)
  external
  view
  returns (uint256)
{
  return allowances[account][spender];
}

approve

Parameters

Name	Type
spender	address
rawAmount	uint

Properties

Visibility public

Mutability 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, "Uni::approve: amount exceeds 96 bits");
  }

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

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

permit

Parameters

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

Properties

Visibility public

Mutability transaction

Requirements

signatory must not be equal to UNKNOWN VALUE

signatory must be equal to owner

now must be less than or equal to deadline

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, "Uni::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), "Uni::permit: invalid signature");
  require(signatory == owner, "Uni::permit: unauthorized");
  require(now <= deadline, "Uni::permit: signature expired");

  allowances[owner][spender] = amount;

  emit Approval(owner, spender, amount);
}

balanceOf

Parameters

Name	Type
account	address

Properties

Visibility public

Mutability view

Source Code

function balanceOf(address account) external view returns (uint256) {
  return balances[account];
}

transfer

Parameters

Name	Type
dst	address
rawAmount	uint

Properties

Visibility public

Mutability transaction

Requirements

the sender's address must not be equal to UNKNOWN VALUE

dst must not be equal to UNKNOWN VALUE

Source Code

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

transferFrom

Parameters

Name	Type
src	address
dst	address
rawAmount	uint

Properties

Visibility public

Mutability transaction

Requirements

the sender's address must not be equal to UNKNOWN VALUE

dst must not be equal to UNKNOWN VALUE

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, "Uni::approve: amount exceeds 96 bits");

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

    emit Approval(src, spender, newAllowance);
  }

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

delegate

Parameters

Name	Type
delegatee	address

Properties

Visibility public

Mutability transaction

Source Code

function delegate(address delegatee) public {
  return _delegate(msg.sender, delegatee);
}

delegateBySig

Parameters

Name	Type
delegatee	address
nonce	uint
expiry	uint
v	uint8
r	bytes32
s	bytes32

Properties

Visibility public

Mutability transaction

Requirements

signatory must not be equal to UNKNOWN VALUE

nonce must be equal to UNKNOWN VALUE

now must be less than or equal to expiry

Source Code

function delegateBySig(
  address delegatee,
  uint256 nonce,
  uint256 expiry,
  uint8 v,
  bytes32 r,
  bytes32 s
) public {
  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), "Uni::delegateBySig: invalid signature");
  require(nonce == nonces[signatory]++, "Uni::delegateBySig: invalid nonce");
  require(now <= expiry, "Uni::delegateBySig: signature expired");
  return _delegate(signatory, delegatee);
}

getCurrentVotes

Parameters

Name	Type
account	address

Properties

Visibility public

Mutability view

Source Code

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

getPriorVotes

Parameters

Name	Type
account	address
blockNumber	uint

Properties

Visibility public

Mutability view

Requirements

blockNumber must be less than block.number

Source Code

function getPriorVotes(address account, uint256 blockNumber)
  public
  view
  returns (uint96)
{
  require(blockNumber < block.number, "Uni::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 Uni._delegate

Parameters

Name	Type
delegator	address
delegatee	address

Properties

Visibility internal

Mutability 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 Uni._transferTokens

Parameters

Name	Type
src	address
dst	address
amount	uint96

Properties

Visibility internal

Mutability transaction

Requirements

the sender's address must not be equal to UNKNOWN VALUE

dst must not be equal to UNKNOWN VALUE

Source Code

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

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

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

internal Uni._moveDelegates

Parameters

Name	Type
srcRep	address
dstRep	address
amount	uint96

Properties

Visibility internal

Mutability 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,
        "Uni::_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,
        "Uni::_moveVotes: vote amount overflows"
      );
      _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew);
    }
  }
}

internal Uni._writeCheckpoint

Parameters

Name	Type
delegatee	address
nCheckpoints	uint32
oldVotes	uint96
newVotes	uint96

Properties

Visibility internal

Mutability transaction

Source Code

function _writeCheckpoint(
  address delegatee,
  uint32 nCheckpoints,
  uint96 oldVotes,
  uint96 newVotes
) internal {
  uint32 blockNumber = safe32(
    block.number,
    "Uni::_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 Uni.safe32

Parameters

Name	Type
n	uint
errorMessage	string

Properties

Visibility internal

Mutability pure

Requirements

n must be less than UNKNOWN VALUE

Source Code

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

internal Uni.safe96

Parameters

Name	Type
n	uint
errorMessage	string

Properties

Visibility internal

Mutability pure

Requirements

n must be less than UNKNOWN VALUE

Source Code

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

internal Uni.add96

Parameters

Name	Type
a	uint96
b	uint96
errorMessage	string

Properties

Visibility internal

Mutability pure

Requirements

c must be greater than or equal to a

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 Uni.sub96

Parameters

Name	Type
a	uint96
b	uint96
errorMessage	string

Properties

Visibility internal

Mutability pure

Requirements

b must be less than or equal to a

Source Code

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

internal Uni.getChainId

Parameters

This function has no parameters.

Properties

Visibility internal

Mutability pure

Source Code

function getChainId() internal pure returns (uint256) {
  uint256 chainId;
  assembly {
    chainId := chainid()
  }
  return chainId;
}

Uniswap

ERC20

About link

Stats

Events (5) keyboard_arrow_up

Approval Event

Parameters help Event parameters list the data that an event contains.

DelegateChanged Event

Parameters help Event parameters list the data that an event contains.

DelegateVotesChanged Event

Parameters help Event parameters list the data that an event contains.

MinterChanged Event

Parameters help Event parameters list the data that an event contains.

Transfer Event

Parameters help Event parameters list the data that an event contains.

Structs (1) keyboard_arrow_up

Checkpoint Struct

Members

Constants (8) keyboard_arrow_up

name Constant

symbol Constant

decimals Constant

minimumTimeBetweenMints Constant

mintCap Constant

DOMAIN_TYPEHASH Constant

DELEGATION_TYPEHASH Constant

PERMIT_TYPEHASH Constant

State Variables (9) keyboard_arrow_up

totalSupply Variable

minter Variable

mintingAllowedAfter Variable

delegates Variable

numCheckpoints Variable

nonces Variable

allowances Variable

balances Variable

checkpoints Variable

Functions Expand All Collapse All

setMinter keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

mint keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

allowance keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Source Code

approve keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Source Code

permit keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

balanceOf keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Source Code

transfer keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

transferFrom keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Requirements help Requirements are checks that the function makes when it runs, and give you insight on what conditions are required for the function to succeed.

Source Code

delegate keyboard_arrow_up

Parameters help Function parameters list what input the function expects from the user. Each parameter must be given a value.

Properties

Source Code

delegateBySig keyboard_arrow_up

About

Events (5)

Parameters

Parameters

Parameters

Parameters

Parameters

Structs (1)

Constants (8)

State Variables (9)

setMinter

Parameters

Requirements

mint

Parameters

Requirements

allowance

Parameters

approve

Parameters

permit

Parameters

Requirements

balanceOf

Parameters

transfer

Parameters

Requirements

transferFrom

Parameters

Requirements

delegate

Parameters

delegateBySig

Parameters

Requirements

getCurrentVotes

Parameters

getPriorVotes

Parameters

Requirements

internal Uni._delegate

Parameters

internal Uni._transferTokens

Parameters

Requirements

internal Uni._moveDelegates

Parameters

internal Uni._writeCheckpoint

Parameters

internal Uni.safe32

Parameters

Requirements

internal Uni.safe96

Parameters

Requirements

internal Uni.add96

Parameters

Requirements

internal Uni.sub96

Parameters

Requirements

internal Uni.getChainId

Parameters