Vyper ERC-721 کنٹریکٹ کا جائزہ

1# @dev ERC-721 نان فنجیبل ٹوکن (non-fungible token) سٹینڈرڈ کی امپلیمینٹیشن۔
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 کی ملکیت تبدیل ہوتی ہے تو یہ ایمٹ (emit) ہوتا ہے۔ یہ ایونٹ تب ایمٹ ہوتا ہے جب NFTs
2# بنائے جاتے ہیں (`from` == 0) اور ختم کیے جاتے ہیں (`to` == 0)۔ استثنیٰ: کانٹریکٹ بننے کے دوران، کوئی بھی
3# تعداد میں NFTs بنائے اور تفویض کیے جا سکتے ہیں بغیر 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 یہ تب ایمٹ ہوتا ہے جب کسی مالک کے لیے کوئی آپریٹر فعال (enable) یا غیر فعال (disable) کیا جاتا ہے۔ آپریٹر مالک کے
2# تمام NFTs کو مینج کر سکتا ہے۔
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 سے اس کے مالک کے ایڈریس تک کی میپنگ (Mapping)۔
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 منٹر (minter) کا ایڈریس، جو ٹوکن منٹ (mint) کر سکتا ہے
2minter: address
کاپی کریں

1# @dev انٹرفیس آئی ڈی سے بولین (bool) تک کی میپنگ کہ آیا یہ سپورٹڈ ہے یا نہیں
2supportedInterfaces: HashMap[bytes32, bool]
3
4# @dev ERC165 کی ERC165 انٹرفیس آئی ڈی
5ERC165_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000001ffc9a7
6
7# @dev ERC721 کی ERC165 انٹرفیس آئی ڈی
8ERC721_INTERFACE_ID: constant(bytes32) = 0x0000000000000000000000000000000000000000000000000000000080ac58cd
کاپی کریں

1@external
2def __init__():
کاپی کریں

1    # @dev Contract constructor.
کاپی کریں

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    # @dev انٹرفیس کی شناخت ERC-165 میں بیان کی گئی ہے۔
2    @param _interfaceID انٹرفیس کی آئی ڈی
3    return self.supportedInterfaces[_interfaceID]
کاپی کریں

1# ## ویو فنکشنز (VIEW FUNCTIONS) ###
کاپی کریں

1@view
2@external
3def balanceOf(_owner: address) -> uint256:
4    # @dev `_owner` کی ملکیت میں موجود NFTs کی تعداد واپس کرتا ہے۔
5         اگر `_owner` زیرو ایڈریس ہو تو ایرر تھرو کرتا ہے۔ زیرو ایڈریس کو تفویض کردہ NFTs کو نامعتبر سمجھا جاتا ہے۔
6    @param _owner وہ ایڈریس جس کا بیلنس معلوم کرنا ہے۔
7    assert _owner != ZERO_ADDRESS
کاپی کریں

1    return self.ownerToNFTokenCount[_owner]
2
3@view
4@external
5def ownerOf(_tokenId: uint256) -> address:
6    # @dev NFT کے مالک کا ایڈریس واپس کرتا ہے۔
7         اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے۔
8    @param _tokenId NFT کا شناخت کنندہ (identifier)۔
9    owner: address = self.idToOwner[_tokenId]
10    # اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے
11    assert owner != ZERO_ADDRESS
12    return owner
سب دکھائیں
کاپی کریں

1@view
2@external
3def getApproved(_tokenId: uint256) -> address:
4    # @dev کسی ایک NFT کا منظور شدہ ایڈریس حاصل کریں۔
5         اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے۔
6    @param _tokenId اس NFT کی آئی ڈی جس کی منظوری معلوم کرنی ہے۔
7    # اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے
8    assert self.idToOwner[_tokenId] != ZERO_ADDRESS
9    return self.idToApprovals[_tokenId]
سب دکھائیں
کاپی کریں

1@view
2@external
3def isApprovedForAll(_owner: address, _operator: address) -> bool:
4    # @dev چیک کرتا ہے کہ کیا `_operator`، `_owner` کے لیے ایک منظور شدہ آپریٹر ہے۔
5    @param _owner وہ ایڈریس جو NFTs کا مالک ہے۔
6    @param _operator وہ ایڈریس جو مالک کی طرف سے کام کرتا ہے۔
7    return (self.ownerToOperators[_owner])[_operator]
کاپی کریں

1
2# ## ٹرانسفر فنکشن ہیلپرز (TRANSFER FUNCTION HELPERS) ###
3
4@view
5@internal
کاپی کریں

1def _isApprovedOrOwner(_spender: address, _tokenId: uint256) -> bool:
2    # @dev بتاتا ہے کہ آیا دیا گیا سپینڈر (spender) دی گئی ٹوکن آئی ڈی کو ٹرانسفر کر سکتا ہے یا نہیں
3    @param spender سپینڈر کا ایڈریس جس کے بارے میں معلوم کرنا ہے
4    @param tokenId ٹرانسفر کیے جانے والے ٹوکن کی uint256 آئی ڈی
5    @return bool کیا msg.sender دی گئی ٹوکن آئی ڈی کے لیے منظور شدہ ہے،
6        مالک کا آپریٹر ہے، یا ٹوکن کا مالک ہے
7    owner: address = self.idToOwner[_tokenId]
8    spenderIsOwner: bool = owner == _spender
9    spenderIsApproved: bool = _spender == self.idToApprovals[_tokenId]
10    spenderIsApprovedForAll: bool = (self.ownerToOperators[owner])[_spender]
11    return (spenderIsOwner or spenderIsApproved) or spenderIsApprovedForAll
سب دکھائیں
کاپی کریں

1@internal
2def _addTokenTo(_to: address, _tokenId: uint256):
3    # @dev دیے گئے ایڈریس میں ایک NFT شامل کریں
4         اگر `_tokenId` پہلے سے کسی کی ملکیت ہو تو ایرر تھرو کرتا ہے۔
5    # اگر `_tokenId` پہلے سے کسی کی ملکیت ہو تو ایرر تھرو کرتا ہے
6    assert self.idToOwner[_tokenId] == ZERO_ADDRESS
7    # مالک کو تبدیل کریں
8    self.idToOwner[_tokenId] = _to
9    # کاؤنٹ ٹریکنگ کو تبدیل کریں
10    self.ownerToNFTokenCount[_to] += 1
11
12
13@internal
14def _removeTokenFrom(_from: address, _tokenId: uint256):
15    # @dev دیے گئے ایڈریس سے ایک NFT ہٹائیں
16         اگر `_from` موجودہ مالک نہ ہو تو ایرر تھرو کرتا ہے۔
17    # اگر `_from` موجودہ مالک نہ ہو تو ایرر تھرو کرتا ہے
18    assert self.idToOwner[_tokenId] == _from
19    # مالک کو تبدیل کریں
20    self.idToOwner[_tokenId] = ZERO_ADDRESS
21    # کاؤنٹ ٹریکنگ کو تبدیل کریں
22    self.ownerToNFTokenCount[_from] -= 1
سب دکھائیں
کاپی کریں

1@internal
2def _clearApproval(_owner: address, _tokenId: uint256):
3    # @dev دیے گئے ایڈریس کی منظوری (approval) کو کلیئر کریں
4         اگر `_owner` موجودہ مالک نہ ہو تو ایرر تھرو کرتا ہے۔
5    # اگر `_owner` موجودہ مالک نہ ہو تو ایرر تھرو کرتا ہے
6    assert self.idToOwner[_tokenId] == _owner
7    if self.idToApprovals[_tokenId] != ZERO_ADDRESS:
8        # منظوریوں (approvals) کو ری سیٹ کریں
9        self.idToApprovals[_tokenId] = ZERO_ADDRESS
سب دکھائیں
کاپی کریں

1@internal
2def _transferFrom(_from: address, _to: address, _tokenId: uint256, _sender: address):
3    # @dev NFT کا ٹرانسفر انجام دیں۔
4         ایرر تھرو کرتا ہے جب تک کہ `msg.sender` موجودہ مالک، ایک مجاز آپریٹر، یا اس NFT کے لیے منظور شدہ
5         ایڈریس نہ ہو۔ (نوٹ: پرائیویٹ فنکشن میں `msg.sender` کی اجازت نہیں ہے اس لیے `_sender` پاس کریں۔)
6         اگر `_to` زیرو ایڈریس ہو تو ایرر تھرو کرتا ہے۔
7         اگر `_from` موجودہ مالک نہ ہو تو ایرر تھرو کرتا ہے۔
8         اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے۔
کاپی کریں

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    # ٹرانسفر کو لاگ (Log) کریں
12    log Transfer(_from, _to, _tokenId)
سب دکھائیں
کاپی کریں

1
2# ## ٹرانسفر فنکشنز (TRANSFER FUNCTIONS) ###
3
4@external
5def transferFrom(_from: address, _to: address, _tokenId: uint256):
6    # @dev ایرر تھرو کرتا ہے جب تک کہ `msg.sender` موجودہ مالک، ایک مجاز آپریٹر، یا اس NFT کے لیے منظور شدہ
7         ایڈریس نہ ہو۔
8         اگر `_from` موجودہ مالک نہ ہو تو ایرر تھرو کرتا ہے۔
9         اگر `_to` زیرو ایڈریس ہو تو ایرر تھرو کرتا ہے۔
10         اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے۔
11    @notice کال کرنے والے کی ذمہ داری ہے کہ وہ تصدیق کرے کہ `_to` NFTs وصول کرنے کی صلاحیت رکھتا ہے ورنہ
12            وہ ہمیشہ کے لیے ضائع ہو سکتے ہیں۔
13    @param _from NFT کا موجودہ مالک۔
14    @param _to نیا مالک۔
15    @param _tokenId ٹرانسفر کیا جانے والا NFT۔
16    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    # @dev ایک NFT کی ملکیت کو ایک ایڈریس سے دوسرے ایڈریس پر ٹرانسفر کرتا ہے۔
9         ایرر تھرو کرتا ہے جب تک کہ `msg.sender` موجودہ مالک، ایک مجاز آپریٹر، یا اس NFT کے لیے
10         منظور شدہ ایڈریس نہ ہو۔
11         اگر `_from` موجودہ مالک نہ ہو تو ایرر تھرو کرتا ہے۔
12         اگر `_to` زیرو ایڈریس ہو تو ایرر تھرو کرتا ہے۔
13         اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے۔
14         اگر `_to` ایک سمارٹ کانٹریکٹ ہے، تو یہ `_to` پر `onERC721Received` کو کال کرتا ہے اور اگر
15         ریٹرن ویلیو `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` نہ ہو تو ایرر تھرو کرتا ہے۔
16         نوٹ: bytes4 کو پیڈنگ کے ساتھ bytes32 سے ظاہر کیا جاتا ہے
17    @param _from NFT کا موجودہ مالک۔
18    @param _to نیا مالک۔
19    @param _tokenId ٹرانسفر کیا جانے والا NFT۔
20    @param _data بغیر کسی مخصوص فارمیٹ کے اضافی ڈیٹا، جو `_to` کی کال میں بھیجا جاتا ہے۔
21    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    # @dev کسی NFT کے لیے منظور شدہ ایڈریس سیٹ کریں یا دوبارہ تصدیق کریں۔ زیرو ایڈریس ظاہر کرتا ہے کہ کوئی منظور شدہ ایڈریس نہیں ہے۔
4         ایرر تھرو کرتا ہے جب تک کہ `msg.sender` موجودہ NFT کا مالک، یا موجودہ مالک کا کوئی مجاز آپریٹر نہ ہو۔
5         اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے۔ (نوٹ: یہ EIP میں نہیں لکھا گیا)
6         اگر `_approved` موجودہ مالک ہو تو ایرر تھرو کرتا ہے۔ (نوٹ: یہ EIP میں نہیں لکھا گیا)
7    @param _approved دی گئی NFT آئی ڈی کے لیے منظور کیا جانے والا ایڈریس۔
8    @param _tokenId منظور کیے جانے والے ٹوکن کی آئی ڈی۔
9    owner: address = self.idToOwner[_tokenId]
10    # اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے
11    assert owner != ZERO_ADDRESS
12    # اگر `_approved` موجودہ مالک ہو تو ایرر تھرو کرتا ہے
13    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    # منظوری (approval) سیٹ کریں
2    self.idToApprovals[_tokenId] = _approved
3    log Approval(owner, _approved, _tokenId)
4
5
6@external
7def setApprovalForAll(_operator: address, _approved: bool):
8    # @dev کسی تیسرے فریق ("آپریٹر") کے لیے `msg.sender` کے تمام اثاثوں کو مینج کرنے کی منظوری کو فعال یا غیر فعال کرتا ہے۔
9         یہ ApprovalForAll ایونٹ بھی ایمٹ کرتا ہے۔
10         اگر `_operator` ہی `msg.sender` ہو تو ایرر تھرو کرتا ہے۔ (نوٹ: یہ EIP میں نہیں لکھا گیا)
11    @notice یہ تب بھی کام کرتا ہے جب بھیجنے والے کے پاس اس وقت کوئی ٹوکن نہ ہو۔
12    @param _operator مجاز آپریٹرز کے سیٹ میں شامل کرنے کے لیے ایڈریس۔
13    @param _approved اگر آپریٹرز منظور شدہ ہیں تو True، منظوری منسوخ کرنے کے لیے false۔
14    # اگر `_operator` ہی `msg.sender` ہو تو ایرر تھرو کرتا ہے
15    assert _operator != msg.sender
16    self.ownerToOperators[msg.sender][_operator] = _approved
17    log ApprovalForAll(msg.sender, _operator, _approved)
سب دکھائیں
کاپی کریں

1# ## منٹ اور برن فنکشنز (MINT & BURN FUNCTIONS) ###
2
3@external
4def mint(_to: address, _tokenId: uint256) -> bool:
کاپی کریں

1    # @dev ٹوکنز منٹ (mint) کرنے کا فنکشن
2         اگر `msg.sender` منٹر (minter) نہ ہو تو ایرر تھرو کرتا ہے۔
3         اگر `_to` زیرو ایڈریس ہو تو ایرر تھرو کرتا ہے۔
4         اگر `_tokenId` پہلے سے کسی کی ملکیت ہو تو ایرر تھرو کرتا ہے۔
5    @param _to وہ ایڈریس جو منٹ کیے گئے ٹوکنز وصول کرے گا۔
6    @param _tokenId منٹ کی جانے والی ٹوکن آئی ڈی۔
7    @return ایک بولین (boolean) جو ظاہر کرتا ہے کہ آیا آپریشن کامیاب رہا۔
8    # اگر `msg.sender` منٹر (minter) نہ ہو تو ایرر تھرو کرتا ہے
9    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    # @dev ایک مخصوص ERC721 ٹوکن کو برن (burn) کرتا ہے۔
5         ایرر تھرو کرتا ہے جب تک کہ `msg.sender` موجودہ مالک، ایک مجاز آپریٹر، یا اس NFT کے لیے منظور شدہ
6         ایڈریس نہ ہو۔
7         اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے۔
8    @param _tokenId برن کیے جانے والے ERC721 ٹوکن کی uint256 آئی ڈی۔
9    # ضروریات چیک کریں
10    assert self._isApprovedOrOwner(msg.sender, _tokenId)
11    owner: address = self.idToOwner[_tokenId]
12    # اگر `_tokenId` ایک معتبر NFT نہ ہو تو ایرر تھرو کرتا ہے
13    assert owner != ZERO_ADDRESS
14    self._clearApproval(owner, _tokenId)
15    self._removeTokenFrom(owner, _tokenId)
16    log Transfer(owner, ZERO_ADDRESS, _tokenId)
سب دکھائیں
کاپی کریں