Vyper ERC-721コントラクトウォークスルー

1# @dev ERC-721非代替性トークン標準の実装。
2# @author Ryuya Nakamura (@nrryuya)
3# 変更元: https://github.com/vyperlang/vyper/blob/de74722bf2d8718cca46902be165f9fe0e3641dd/examples/tokens/ERC721.vy
コピー

1from vyper.interfaces import ERC721
2
3implements: ERC721
コピー

1# safeTransferFrom()によって呼び出されるコントラクトのインターフェイス
2interface ERC721Receiver:
3    def onERC721Received(
コピー

1            _operator: address,
2            _from: address,
コピー

1            _tokenId: uint256,
コピー

1            _data: Bytes[1024]
コピー

1        ) -> bytes32: view
コピー

1# @dev 何らかのメカニズムによってNFTの所有権が変更されたときに発行されます。このイベントは、NFTが作成
2#      (`from` == 0)および破棄(`to` == 0)されたときに発行されます。例外：コントラクト作成中、任意の
3#      数のNFTがTransferを発行せずに作成および割り当てられる場合があります。任意の
4#      送金時、そのNFTの承認済みアドレス(もしあれば)はnoneにリセットされます。
5# @param _from NFTの送信者(アドレスがゼロアドレスの場合、トークンの作成を示します)。
6# @param _to NFTの受信者(アドレスがゼロアドレスの場合、トークンの破棄を示します)。
7# @param _tokenId 送金されたNFT。
8event Transfer:
9    sender: indexed(address)
10    receiver: indexed(address)
11    tokenId: indexed(uint256)
すべて表示
コピー

1# @dev NFTの承認済みアドレスが変更または再確認されたときに発行されます。ゼロ
2#      アドレスは、承認済みアドレスがないことを示します。Transferイベントが発行されると、これも
3#      そのNFTの承認済みアドレス(もしあれば)がnoneにリセットされることを示します。
4# @param _owner NFTの所有者。
5# @param _approved 承認するアドレス。
6# @param _tokenId 承認するNFT。
7event Approval:
8    owner: indexed(address)
9    approved: indexed(address)
10    tokenId: indexed(uint256)
すべて表示
コピー

1# @dev 所有者のオペレーターが有効または無効になったときに発行されます。オペレーターは
2#      所有者のすべてのNFTを管理できます。
3# @param _owner NFTの所有者。
4# @param _operator オペレーター権限を設定するアドレス。
5# @param _approved オペレーター権限のステータス(権限が付与された場合はtrue、
6# 取り消された場合はfalse)。
7event ApprovalForAll:
8    owner: indexed(address)
9    operator: indexed(address)
10    approved: bool
すべて表示
コピー

1# @dev NFT IDからそれを所有するアドレスへのマッピング。
2idToOwner: HashMap[uint256, address]
3
4# @dev NFT IDから承認済みアドレスへのマッピング。
5idToApprovals: HashMap[uint256, address]
コピー

1# @dev 所有者アドレスからそのトークン数へのマッピング。
2ownerToNFTokenCount: HashMap[address, uint256]
コピー

1# @dev 所有者アドレスからオペレーターアドレスのマッピングへのマッピング。
2ownerToOperators: HashMap[address, HashMap[address, bool]]
コピー

1# @dev トークンをミントできるミンターのアドレス
2minter: address
コピー

1# @dev インターフェイスIDから、それがサポートされているかどうかを示すbool値へのマッピング
2supportedInterfaces: HashMap[bytes32, bool]
3
4# @dev ERC165のERC165インターフェイスID
5ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
6
7# @dev ERC721のERC165インターフェイスID
8ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd
コピー

1@external
2def __init__():
コピー

1    """
2    @dev コントラクトコンストラクタ。
3    """
コピー

1    self.supportedInterfaces[ERC165_INTERFACE_ID] = True
2    self.supportedInterfaces[ERC721_INTERFACE_ID] = True
3    self.minter = msg.sender
コピー

1@view
2@external
コピー

1def supportsInterface(_interfaceID: bytes32) -> bool:
コピー

1    """
2    @dev インターフェイスの識別はERC-165で指定されています。
3    @param _interfaceID インターフェイスのID
4    """
5    return self.supportedInterfaces[_interfaceID]
コピー

1### ビュー関数 ###
2
コピー

1@view
2@external
3def balanceOf(_owner: address) -> uint256:
4    """
5    @dev `_owner`が所有するNFTの数を返します。
6         `_owner`がゼロアドレスの場合はスローします。ゼロアドレスに割り当てられたNFTは無効と見なされます。
7    @param _owner 残高を照会するアドレス。
8    """
9    assert _owner != ZERO_ADDRESS
すべて表示
コピー

1    return self.ownerToNFTokenCount[_owner]
2
3@view
4@external
5def ownerOf(_tokenId: uint256) -> address:
6    """
7    @dev NFTの所有者のアドレスを返します。
8         `_tokenId`が有効なNFTでない場合はスローします。
9    @param _tokenId NFTの識別子。
10    """
11    owner: address = self.idToOwner[_tokenId]
12    # `_tokenId`が有効なNFTでない場合はスローします
13    assert owner != ZERO_ADDRESS
14    return owner
すべて表示
コピー

1@view
2@external
3def getApproved(_tokenId: uint256) -> address:
4    """
5    @dev 単一のNFTの承認済みアドレスを取得します。
6         `_tokenId`が有効なNFTでない場合はスローします。
7    @param _tokenId 承認を照会するNFTのID。
8    """
9    # `_tokenId`が有効なNFTでない場合はスローします
10    assert self.idToOwner[_tokenId] != ZERO_ADDRESS
11    return self.idToApprovals[_tokenId]
すべて表示
コピー

1@view
2@external
3def isApprovedForAll(_owner: address, _operator: address) -> bool:
4    """
5    @dev `_operator`が`_owner`の承認済みオペレーターであるかどうかをチェックします。
6    @param _owner NFTを所有するアドレス。
7    @param _operator 所有者の代わりに機能するアドレス。
8    """
9    return (self.ownerToOperators[_owner])[_operator]
すべて表示
コピー

1
2### 送金関数ヘルパー ###
3
4@view
5@internal
コピー

1def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
2    """
3    @dev 指定されたスペンダーが指定されたトークンIDを送金できるかどうかを返します
4    @param spender 照会するスペンダーのアドレス
5    @param tokenId 送金されるトークンのuint256 ID
6    @return bool msg.senderが指定されたトークンIDに対して承認されているか、
7        所有者のオペレーターであるか、トークンの所有者であるかどうか
8    """
9    owner: address = self.idToOwner[_tokenId]
10    spenderIsOwner: bool = owner == _spender
11    spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
12    spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
13    return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
すべて表示
コピー

1@internal
2def _addTokenTo(_to: address, _tokenId: uint256):
3    """
4    @dev 指定されたアドレスにNFTを追加します
5         `_tokenId`が誰かによって所有されている場合はスローします。
6    """
7    # `_tokenId`が誰かによって所有されている場合はスローします
8    assert self.idToOwner[_tokenId] == ZERO_ADDRESS
9    # 所有者を変更
10    self.idToOwner[_tokenId] = _to
11    # カウント追跡を変更
12    self.ownerToNFTokenCount[_to] += 1
13
14
15@internal
16def _removeTokenFrom(_from: address, _tokenId: uint256):
17    """
18    @dev 指定されたアドレスからNFTを削除します
19         `_from`が現在の所有者でない場合はスローします。
20    """
21    # `_from`が現在の所有者でない場合はスローします
22    assert self.idToOwner[_tokenId] == _from
23    # 所有者を変更
24    self.idToOwner[_tokenId] = ZERO_ADDRESS
25    # カウント追跡を変更
26    self.ownerToNFTokenCount[_from] -= 1
すべて表示
コピー

1@internal
2def _clearApproval(_owner: address, _tokenId: uint256):
3    """
4    @dev 指定されたアドレスの承認をクリアします
5         `_owner`が現在の所有者でない場合はスローします。
6    """
7    # `_owner`が現在の所有者でない場合はスローします
8    assert self.idToOwner[_tokenId] == _owner
9    if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
10        # 承認をリセット
11        self.idToApprovals[_tokenId] = ZERO_ADDRESS
すべて表示
コピー

1@internal
2def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
3    """
4    @dev NFTの送金を実行します。
5         `msg.sender`が現在の所有者、承認されたオペレーター、またはこのNFTの承認
6         済みアドレスでない限り、スローします。(注：`msg.sender`はプライベート関数では許可されていないため、`_sender`を渡します。)
7         `_to`がゼロアドレスの場合はスローします。
8         `_from`が現在の所有者でない場合はスローします。
9         `_tokenId`が有効なNFTでない場合はスローします。
10    """
すべて表示
コピー

1    # 要件をチェック
2    assert self._isApprovedOrOwner(_sender, _tokenId)
3    # `_to`がゼロアドレスの場合はスローします
4    assert _to != ZERO_ADDRESS
5    # 承認をクリアします。`_from`が現在の所有者でない場合はスローします
6    self._clearApproval(_from, _tokenId)
7    # NFTを削除します。`_tokenId`が有効なNFTでない場合はスローします
8    self._removeTokenFrom(_from, _tokenId)
9    # NFTを追加
10    self._addTokenTo(_to, _tokenId)
11    # 送金をログに記録
12    log Transfer(_from, _to, _tokenId)
すべて表示
コピー

1
2### 送金関数 ###
3
4@external
5def transferFrom(_from: address, _to: address, _tokenId: uint256):
6    """
7    @dev `msg.sender`が現在の所有者、承認されたオペレーター、またはこのNFTの承認
8         済みアドレスでない限り、スローします。
9         `_from`が現在の所有者でない場合はスローします。
10         `_to`がゼロアドレスの場合はスローします。
11         `_tokenId`が有効なNFTでない場合はスローします。
12    @notice 呼び出し元は、`_to`がNFTを受信できることを確認する責任があります。さもないと、
13            永久に失われる可能性があります。
14    @param _from NFTの現在の所有者。
15    @param _to 新しい所有者。
16    @param _tokenId 送金するNFT。
17    """
18    self._transferFrom(_from, _to, _tokenId, msg.sender)
すべて表示
コピー

1@external
2def safeTransferFrom(
3        _from: address,
4        _to: address,
5        _tokenId: uint256,
6        _data: Bytes[1024]=b""
7    ):
8    """
9    @dev NFTの所有権をあるアドレスから別のアドレスに送金します。
10         `msg.sender`が現在の所有者、承認されたオペレーター、またはこの
11         NFTの承認済みアドレスでない限り、スローします。
12         `_from`が現在の所有者でない場合はスローします。
13         `_to`がゼロアドレスの場合はスローします。
14         `_tokenId`が有効なNFTでない場合はスローします。
15         `_to`がスマートコントラクトの場合、`_to`で`onERC721Received`を呼び出し、
16         戻り値が`bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`でない場合にスローします。
17         注：bytes4はパディング付きのbytes32で表されます
18    @param _from NFTの現在の所有者。
19    @param _to 新しい所有者。
20    @param _tokenId 送金するNFT。
21    @param _data 指定されたフォーマットのない追加データで、`_to`への呼び出しで送信されます。
22    """
23    self._transferFrom(_from, _to, _tokenId, msg.sender)
すべて表示
コピー

1    if _to.is_contract: # `_to`がコントラクトアドレスかどうかをチェック
コピー

1        returnValue: bytes32 = ERC721Receiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data)
コピー

1        # 送金先が'onERC721Received'を実装していないコントラクトの場合はスローします
2        assert returnValue == method_id("onERC721Received(address,address,uint256,bytes)", output_type=bytes32)
コピー

1@external
2def approve(_approved: address, _tokenId: uint256):
3    """
4    @dev NFTの承認済みアドレスを設定または再確認します。ゼロアドレスは、承認済みアドレスがないことを示します。
5         `msg.sender`が現在のNFT所有者または現在の所有者の承認済みオペレーターでない限り、スローします。
6         `_tokenId`が有効なNFTでない場合はスローします。(注：これはEIPには書かれていません)
7         `_approved`が現在の所有者である場合はスローします。(注：これはEIPには書かれていません)
8    @param _approved 指定されたNFT IDに対して承認されるアドレス。
9    @param _tokenId 承認されるトークンのID。
10    """
11    owner: address = self.idToOwner[_tokenId]
12    # `_tokenId`が有効なNFTでない場合はスローします
13    assert owner != ZERO_ADDRESS
14    # `_approved`が現在の所有者である場合はスローします
15    assert _approved != owner
すべて表示
コピー

1    # 要件をチェック
2    senderIsOwner: bool = self.idToOwner[_tokenId] == msg.sender
3    senderIsApprovedForAll: bool = (self.ownerToOperators[owner])[msg.sender]
4    assert (senderIsOwner or senderIsApprovedForAll)
コピー

1    # 承認を設定
2    self.idToApprovals[_tokenId] = _approved
3    log Approval(owner, _approved, _tokenId)
4
5
6@external
7def setApprovalForAll(_operator: address, _approved: bool):
8    """
9    @dev サードパーティ(「オペレーター」)が`msg.sender`の
10         すべての資産を管理するための承認を有効または無効にします。また、ApprovalForAllイベントも発行します。
11         `_operator`が`msg.sender`である場合はスローします。(注：これはEIPには書かれていません)
12    @notice これは、送信者がその時点でトークンを所有していなくても機能します。
13    @param _operator 承認済みオペレーターのセットに追加するアドレス。
14    @param _approved オペレーターが承認されている場合はTrue、承認を取り消す場合はfalse。
15    """
16    # `_operator`が`msg.sender`である場合はスローします
17    assert _operator != msg.sender
18    self.ownerToOperators[msg.sender][_operator] = _approved
19    log ApprovalForAll(msg.sender, _operator, _approved)
すべて表示
コピー

1### ミント＆バーン関数 ###
2
3@external
4def mint(_to: address, _tokenId: uint256) -> bool:
コピー

1    """
2    @dev トークンをミントする関数
3         `msg.sender`がミンターでない場合はスローします。
4         `_to`がゼロアドレスの場合はスローします。
5         `_tokenId`が誰かによって所有されている場合はスローします。
6    @param _to ミントされたトークンを受け取るアドレス。
7    @param _tokenId ミントするトークンID。
8    @return 操作が成功したかどうかを示すブール値。
9    """
10    # `msg.sender`がミンターでない場合はスローします
11    assert msg.sender == self.minter
すべて表示
コピー

1    # `_to`がゼロアドレスの場合はスローします
2    assert _to != ZERO_ADDRESS
3    # NFTを追加します。`_tokenId`が誰かによって所有されている場合はスローします
4    self._addTokenTo(_to, _tokenId)
5    log Transfer(ZERO_ADDRESS, _to, _tokenId)
6    return True
コピー

1
2@external
3def burn(_tokenId: uint256):
4    """
5    @dev 特定のERC721トークンをバーンします。
6         `msg.sender`が現在の所有者、承認されたオペレーター、またはこのNFTの承認
7         済みアドレスでない限り、スローします。
8         `_tokenId`が有効なNFTでない場合はスローします。
9    @param _tokenId バーンされるERC721トークンのuint256 ID。
10    """
11    # 要件をチェック
12    assert self._isApprovedOrOwner(msg.sender, _tokenId)
13    owner: address = self.idToOwner[_tokenId]
14    # `_tokenId`が有効なNFTでない場合はスローします
15    assert owner != ZERO_ADDRESS
16    self._clearApproval(owner, _tokenId)
17    self._removeTokenFrom(owner, _tokenId)
18    log Transfer(owner, ZERO_ADDRESS, _tokenId)
すべて表示
コピー