fix(examples): compile warnings

examples/auctions/blind_auction.vy

@@ -1,4 +1,4 @@
-# Blind Auction # Adapted to Vyper from [Solidity by Example](https://github.com/ethereum/solidity/blob/develop/docs/solidity-by-example.rst#blind-auction-1)
+# Blind Auction. Adapted to Vyper from [Solidity by Example](https://github.com/ethereum/solidity/blob/develop/docs/solidity-by-example.rst#blind-auction-1)
 
 struct Bid:
   blindedBid: bytes32
@@ -82,7 +82,7 @@ def placeBid(bidder: address, _value: uint256) -> bool:
         return False
 
     # Refund the previously highest bidder
-    if (self.highestBidder != ZERO_ADDRESS):
+    if (self.highestBidder != empty(address)):
         self.pendingReturns[self.highestBidder] += self.highestBid
 
     # Place bid successfully and update auction state
@@ -136,7 +136,7 @@ def reveal(_numBids: int128, _values: uint256[128], _fakes: bool[128], _secrets:
                 refund -= value
 
         # Make it impossible for the sender to re-claim the same deposit
-        zeroBytes32: bytes32 = EMPTY_BYTES32
+        zeroBytes32: bytes32 = empty(bytes32)
         bidToCheck.blindedBid = zeroBytes32
 
     # Send refund if non-zero

examples/name_registry/name_registry.vy

@@ -3,7 +3,7 @@ registry: HashMap[Bytes[100], address]
 
 @external
 def register(name: Bytes[100], owner: address):
-    assert self.registry[name] == ZERO_ADDRESS  # check name has not been set yet.
+    assert self.registry[name] == empty(address)  # check name has not been set yet.
     self.registry[name] = owner
 
 

examples/tokens/ERC1155ownable.vy

@@ -170,22 +170,22 @@ def transferOwnership(newOwner: address):
     assert not self.paused, "The contract has been paused"
     assert self.owner == msg.sender, "Ownable: caller is not the owner"
     assert newOwner != self.owner, "This account already owns the contract"
-    assert newOwner != ZERO_ADDRESS, "Transfer to ZERO_ADDRESS not allowed. Use renounceOwnership() instead."
+    assert newOwner != empty(address), "Transfer to the zero address not allowed. Use renounceOwnership() instead."
     oldOwner: address = self.owner
     self.owner = newOwner
     log OwnershipTransferred(oldOwner, newOwner)
 
 @external
 def renounceOwnership():
     """
-    @dev Transfer the ownership to ZERO_ADDRESS, this will lock the contract
-    @dev emits an OwnershipTransferred event with the old and new ZERO_ADDRESS owner addresses
+    @dev Transfer the ownership to the zero address, this will lock the contract
+    @dev emits an OwnershipTransferred event with the old and new zero owner addresses
     """
     assert not self.paused, "The contract has been paused"
     assert self.owner == msg.sender, "Ownable: caller is not the owner"
     oldOwner: address = self.owner
-    self.owner = ZERO_ADDRESS
-    log OwnershipTransferred(oldOwner, ZERO_ADDRESS)
+    self.owner = empty(address)
+    log OwnershipTransferred(oldOwner, empty(address))
 
 @external
 @view
@@ -218,10 +218,10 @@ def mint(receiver: address, id: uint256, amount:uint256, data:bytes32):
     """
     assert not self.paused, "The contract has been paused"
     assert self.owner == msg.sender, "Only the contract owner can mint"
-    assert receiver != ZERO_ADDRESS, "Can not mint to ZERO ADDRESS"
+    assert receiver != empty(address), "Can not mint to ZERO ADDRESS"
     operator: address = msg.sender
     self.balanceOf[receiver][id] += amount
-    log TransferSingle(operator, ZERO_ADDRESS, receiver, id, amount)
+    log TransferSingle(operator, empty(address), receiver, id, amount)
 
 
 @external
@@ -236,7 +236,7 @@ def mintBatch(receiver: address, ids: DynArray[uint256, BATCH_SIZE], amounts: Dy
     """
     assert not self.paused, "The contract has been paused"
     assert self.owner == msg.sender, "Only the contract owner can mint"
-    assert receiver != ZERO_ADDRESS, "Can not mint to ZERO ADDRESS"
+    assert receiver != empty(address), "Can not mint to ZERO ADDRESS"
     assert len(ids) == len(amounts), "ERC1155: ids and amounts length mismatch"
     operator: address = msg.sender
 
@@ -245,7 +245,7 @@ def mintBatch(receiver: address, ids: DynArray[uint256, BATCH_SIZE], amounts: Dy
             break
         self.balanceOf[receiver][ids[i]] += amounts[i]
 
-    log TransferBatch(operator, ZERO_ADDRESS, receiver, ids, amounts)
+    log TransferBatch(operator, empty(address), receiver, ids, amounts)
 
 ## burn ##
 @external
@@ -259,7 +259,7 @@ def burn(id: uint256, amount: uint256):
     assert not self.paused, "The contract has been paused"
     assert self.balanceOf[msg.sender][id] > 0 , "caller does not own this ID"
     self.balanceOf[msg.sender][id] -= amount
-    log TransferSingle(msg.sender, msg.sender, ZERO_ADDRESS, id, amount)
+    log TransferSingle(msg.sender, msg.sender, empty(address), id, amount)
 
 @external
 def burnBatch(ids: DynArray[uint256, BATCH_SIZE], amounts: DynArray[uint256, BATCH_SIZE]):
@@ -279,7 +279,7 @@ def burnBatch(ids: DynArray[uint256, BATCH_SIZE], amounts: DynArray[uint256, BAT
             break
         self.balanceOf[msg.sender][ids[i]] -= amounts[i]
 
-    log TransferBatch(msg.sender, msg.sender, ZERO_ADDRESS, ids, amounts)
+    log TransferBatch(msg.sender, msg.sender, empty(address), ids, amounts)
 
 ## approval ##
 @external
@@ -306,7 +306,7 @@ def safeTransferFrom(sender: address, receiver: address, id: uint256, amount: ui
     @param amount the amount of tokens for the specified id
     """
     assert not self.paused, "The contract has been paused"
-    assert receiver != ZERO_ADDRESS, "ERC1155: transfer to the zero address"
+    assert receiver != empty(address), "ERC1155: transfer to the zero address"
     assert sender != receiver
     assert sender == msg.sender or self.isApprovedForAll[sender][msg.sender], "Caller is neither owner nor approved operator for this ID"
     assert self.balanceOf[sender][id] > 0 , "caller does not own this ID or ZERO balance"
@@ -325,7 +325,7 @@ def safeBatchTransferFrom(sender: address, receiver: address, ids: DynArray[uint
     @param amounts a dynamic array of the amounts for the specified list of ids.
     """
     assert not self.paused, "The contract has been paused"
-    assert receiver != ZERO_ADDRESS, "ERC1155: transfer to the zero address"
+    assert receiver != empty(address), "ERC1155: transfer to the zero address"
     assert sender != receiver
     assert sender == msg.sender or self.isApprovedForAll[sender][msg.sender], "Caller is neither owner nor approved operator for this ID"
     assert len(ids) == len(amounts), "ERC1155: ids and amounts length mismatch"

examples/tokens/ERC20.vy

@@ -43,7 +43,7 @@ def __init__(_name: String[32], _symbol: String[32], _decimals: uint8, _supply:
     self.balanceOf[msg.sender] = init_supply
     self.totalSupply = init_supply
     self.minter = msg.sender
-    log Transfer(ZERO_ADDRESS, msg.sender, init_supply)
+    log Transfer(empty(address), msg.sender, init_supply)
 
 
 
@@ -107,10 +107,10 @@ def mint(_to: address, _value: uint256):
     @param _value The amount that will be created.
     """
     assert msg.sender == self.minter
-    assert _to != ZERO_ADDRESS
+    assert _to != empty(address)
     self.totalSupply += _value
     self.balanceOf[_to] += _value
-    log Transfer(ZERO_ADDRESS, _to, _value)
+    log Transfer(empty(address), _to, _value)
 
 
 @internal
@@ -121,10 +121,10 @@ def _burn(_to: address, _value: uint256):
     @param _to The account whose tokens will be burned.
     @param _value The amount that will be burned.
     """
-    assert _to != ZERO_ADDRESS
+    assert _to != empty(address)
     self.totalSupply -= _value
     self.balanceOf[_to] -= _value
-    log Transfer(_to, ZERO_ADDRESS, _value)
+    log Transfer(_to, empty(address), _value)
 
 
 @external

examples/tokens/ERC721.vy

@@ -107,7 +107,7 @@ def balanceOf(_owner: address) -> uint256:
          Throws if `_owner` is the zero address. NFTs assigned to the zero address are considered invalid.
     @param _owner Address for whom to query the balance.
     """
-    assert _owner != ZERO_ADDRESS
+    assert _owner != empty(address)
     return self.ownerToNFTokenCount[_owner]
 
 
@@ -121,7 +121,7 @@ def ownerOf(_tokenId: uint256) -> address:
     """
     owner: address = self.idToOwner[_tokenId]
     # Throws if `_tokenId` is not a valid NFT
-    assert owner != ZERO_ADDRESS
+    assert owner != empty(address)
     return owner
 
 
@@ -134,7 +134,7 @@ def getApproved(_tokenId: uint256) -> address:
     @param _tokenId ID of the NFT to query the approval of.
     """
     # Throws if `_tokenId` is not a valid NFT
-    assert self.idToOwner[_tokenId] != ZERO_ADDRESS
+    assert self.idToOwner[_tokenId] != empty(address)
     return self.idToApprovals[_tokenId]
 
 
@@ -175,7 +175,7 @@ def _addTokenTo(_to: address, _tokenId: uint256):
          Throws if `_tokenId` is owned by someone.
     """
     # Throws if `_tokenId` is owned by someone
-    assert self.idToOwner[_tokenId] == ZERO_ADDRESS
+    assert self.idToOwner[_tokenId] == empty(address)
     # Change the owner
     self.idToOwner[_tokenId] = _to
     # Change count tracking
@@ -191,7 +191,7 @@ def _removeTokenFrom(_from: address, _tokenId: uint256):
     # Throws if `_from` is not the current owner
     assert self.idToOwner[_tokenId] == _from
     # Change the owner
-    self.idToOwner[_tokenId] = ZERO_ADDRESS
+    self.idToOwner[_tokenId] = empty(address)
     # Change count tracking
     self.ownerToNFTokenCount[_from] -= 1
 
@@ -204,9 +204,9 @@ def _clearApproval(_owner: address, _tokenId: uint256):
     """
     # Throws if `_owner` is not the current owner
     assert self.idToOwner[_tokenId] == _owner
-    if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
+    if self.idToApprovals[_tokenId] != empty(address):
         # Reset approvals
-        self.idToApprovals[_tokenId] = ZERO_ADDRESS
+        self.idToApprovals[_tokenId] = empty(address)
 
 
 @internal
@@ -222,7 +222,7 @@ def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: addr
     # Check requirements
     assert self._isApprovedOrOwner(_sender, _tokenId)
     # Throws if `_to` is the zero address
-    assert _to != ZERO_ADDRESS
+    assert _to != empty(address)
     # Clear approval. Throws if `_from` is not the current owner
     self._clearApproval(_from, _tokenId)
     # Remove NFT. Throws if `_tokenId` is not a valid NFT
@@ -292,7 +292,7 @@ def approve(_approved: address, _tokenId: uint256):
     """
     owner: address = self.idToOwner[_tokenId]
     # Throws if `_tokenId` is not a valid NFT
-    assert owner != ZERO_ADDRESS
+    assert owner != empty(address)
     # Throws if `_approved` is the current owner
     assert _approved != owner
     # Check requirements
@@ -336,10 +336,10 @@ def mint(_to: address, _tokenId: uint256) -> bool:
     # Throws if `msg.sender` is not the minter
     assert msg.sender == self.minter
     # Throws if `_to` is zero address
-    assert _to != ZERO_ADDRESS
+    assert _to != empty(address)
     # Add NFT. Throws if `_tokenId` is owned by someone
     self._addTokenTo(_to, _tokenId)
-    log Transfer(ZERO_ADDRESS, _to, _tokenId)
+    log Transfer(empty(address), _to, _tokenId)
     return True
 
 
@@ -356,10 +356,10 @@ def burn(_tokenId: uint256):
     assert self._isApprovedOrOwner(msg.sender, _tokenId)
     owner: address = self.idToOwner[_tokenId]
     # Throws if `_tokenId` is not a valid NFT
-    assert owner != ZERO_ADDRESS
+    assert owner != empty(address)
     self._clearApproval(owner, _tokenId)
     self._removeTokenFrom(owner, _tokenId)
-    log Transfer(owner, ZERO_ADDRESS, _tokenId)
+    log Transfer(owner, empty(address), _tokenId)
 
 
 @view

examples/voting/ballot.vy

@@ -28,7 +28,7 @@ int128Proposals: public(int128)
 @view
 @internal
 def _delegated(addr: address) -> bool:
-    return self.voters[addr].delegate != ZERO_ADDRESS
+    return self.voters[addr].delegate != empty(address)
 
 
 @view
@@ -40,7 +40,7 @@ def delegated(addr: address) -> bool:
 @view
 @internal
 def _directlyVoted(addr: address) -> bool:
-    return self.voters[addr].voted and (self.voters[addr].delegate == ZERO_ADDRESS)
+    return self.voters[addr].voted and (self.voters[addr].delegate == empty(address))
 
 
 @view
@@ -125,7 +125,7 @@ def delegate(to: address):
     # the default address value of 0x0000000000000000000000000000000000000000
     # (the latter might not be problematic, but I don't want to think about it).
     assert to != msg.sender
-    assert to != ZERO_ADDRESS
+    assert to != empty(address)
 
     self.voters[msg.sender].voted = True
     self.voters[msg.sender].delegate = to

examples/wallet/wallet.vy

@@ -12,7 +12,7 @@ seq: public(int128)
 @external
 def __init__(_owners: address[5], _threshold: int128):
     for i in range(5):
-        if _owners[i] != ZERO_ADDRESS:
+        if _owners[i] != empty(address):
             self.owners[i] = _owners[i]
     self.threshold = _threshold