سمارٹ کنٹریکٹ کی زبانیں

// SPDX-License-Identifier: GPL-3.0
pragma solidity >= 0.7.0;

contract Coin {
    // لفظ "public" ویری ایبلز کو
    // دوسرے کنٹریکٹس سے قابل رسائی بناتا ہے
    address public minter;
    mapping (address => uint) public balances;

    // ایونٹس کلائنٹس کو مخصوص
    // کنٹریکٹ کی تبدیلیوں پر ردعمل ظاہر کرنے کی اجازت دیتے ہیں جو آپ ڈکلیئر کرتے ہیں
    event Sent(address from, address to, uint amount);

    // کنسٹرکٹر کوڈ صرف اسی وقت چلتا ہے جب کنٹریکٹ
    // بنایا جاتا ہے
    constructor() {
        minter = msg.sender;
    }

    // نئے بنائے گئے کوائنز کی ایک مقدار کسی ایڈریس پر بھیجتا ہے
    // اسے صرف کنٹریکٹ بنانے والا ہی کال کر سکتا ہے
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount < 1e60);
        balances[receiver] += amount;
    }

    // موجودہ کوائنز کی ایک مقدار بھیجتا ہے
    // کسی بھی کالر سے کسی ایڈریس پر
    function send(address receiver, uint amount) public {
        require(amount <= balances[msg.sender], "Insufficient balance.");
        balances[msg.sender] -= amount;
        balances[receiver] += amount;
        emit Sent(msg.sender, receiver, amount);
    }
}

# کھلی نیلامی

# نیلامی کے پیرامیٹرز
# فائدہ اٹھانے والا سب سے زیادہ بولی لگانے والے سے رقم وصول کرتا ہے
beneficiary: public(address)
auctionStart: public(uint256)
auctionEnd: public(uint256)

# نیلامی کی موجودہ حالت
highestBidder: public(address)
highestBid: public(uint256)

# آخر میں true پر سیٹ کیا جاتا ہے، کسی بھی تبدیلی کی اجازت نہیں دیتا
ended: public(bool)

# ریفنڈ کی گئی بولیوں کا ریکارڈ رکھیں تاکہ ہم ودڈرا (withdraw) پیٹرن کی پیروی کر سکیں
pendingReturns: public(HashMap[address, uint256])

# `_bidding_time` کے ساتھ ایک سادہ نیلامی بنائیں
# سیکنڈز بولی کا وقت، جو کہ
# فائدہ اٹھانے والے کے ایڈریس `_beneficiary` کی طرف سے ہو۔
@external
def __init__(_beneficiary: address, _bidding_time: uint256):
    self.beneficiary = _beneficiary
    self.auctionStart = block.timestamp
    self.auctionEnd = self.auctionStart + _bidding_time

# بھیجی گئی ویلیو کے ساتھ نیلامی پر بولی لگائیں
# جو اس ٹرانزیکشن کے ساتھ ہو۔
# ویلیو صرف اسی صورت میں ریفنڈ کی جائے گی اگر
# نیلامی جیتی نہ جائے۔
@external
@payable
def bid():
    # چیک کریں کہ کیا بولی کا وقت ختم ہو گیا ہے۔
    assert block.timestamp < self.auctionEnd
    # چیک کریں کہ کیا بولی کافی زیادہ ہے
    assert msg.value > self.highestBid
    # پچھلے سب سے زیادہ بولی لگانے والے کے ریفنڈ کو ٹریک کریں
    self.pendingReturns[self.highestBidder] += self.highestBid
    # نئی سب سے زیادہ بولی کو ٹریک کریں
    self.highestBidder = msg.sender
    self.highestBid = msg.value

# پہلے سے ریفنڈ کی گئی بولی کو ودڈرا (withdraw) کریں۔ ودڈرا پیٹرن کو
# یہاں سیکیورٹی کے مسئلے سے بچنے کے لیے استعمال کیا گیا ہے۔ اگر ریفنڈز براہ راست
# bid() کے حصے کے طور پر بھیجے جاتے، تو ایک بدنیتی پر مبنی بولی لگانے والا کنٹریکٹ
# ان ریفنڈز کو بلاک کر سکتا تھا اور اس طرح نئی زیادہ بولیوں کو آنے سے روک سکتا تھا۔
@external
def withdraw():
    pending_amount: uint256 = self.pendingReturns[msg.sender]
    self.pendingReturns[msg.sender] = 0
    send(msg.sender, pending_amount)

# نیلامی ختم کریں اور سب سے زیادہ بولی
# فائدہ اٹھانے والے کو بھیجیں۔
@external
def endAuction():
    # یہ ایک اچھی گائیڈ لائن ہے کہ ان فنکشنز کو اسٹرکچر کیا جائے جو
    # دوسرے کنٹریکٹس کے ساتھ تعامل کرتے ہیں (یعنی، وہ فنکشنز کو کال کرتے ہیں یا ایتھر بھیجتے ہیں)
    # تین مراحل میں:
    # 1. شرائط چیک کرنا
    # 2. ایکشنز پرفارم کرنا (ممکنہ طور پر شرائط کو تبدیل کرنا)
    # 3. دوسرے کنٹریکٹس کے ساتھ تعامل کرنا
    # اگر ان مراحل کو ملا دیا جائے، تو دوسرا کنٹریکٹ
    # موجودہ کنٹریکٹ میں واپس کال کر سکتا ہے اور اسٹیٹ کو تبدیل کر سکتا ہے یا
    # اثرات (ایتھر کی ادائیگی) کو کئی بار پرفارم کرنے کا سبب بن سکتا ہے۔
    # اگر اندرونی طور پر کال کیے گئے فنکشنز میں بیرونی
    # کنٹریکٹس کے ساتھ تعامل شامل ہے، تو انہیں بھی
    # بیرونی کنٹریکٹس کے ساتھ تعامل سمجھا جانا چاہیے۔

    # 1. شرائط
    # چیک کریں کہ کیا نیلامی کے اختتام کا وقت آ گیا ہے
    assert block.timestamp >= self.auctionEnd
    # چیک کریں کہ کیا یہ فنکشن پہلے ہی کال کیا جا چکا ہے
    assert not self.ended

    # 2. اثرات
    self.ended = True

    # 3. تعامل
    send(self.beneficiary, self.highestBid)

{
    function power(base, exponent) -> result
    {
        switch exponent
        case 0 { result := 1 }
        case 1 { result := base }
        default
        {
            result := power(mul(base, base), div(exponent, 2))
            if mod(exponent, 2) { result := mul(base, result) }
        }
    }
    let res := power(calldataload(0), calldataload(32))
    mstore(0, res)
    return(0, 32)
}

type BookMsg = bytes[100]

contract GuestBook:
    pub guest_book: map<address, BookMsg>

    event Signed:
        book_msg: BookMsg

    pub def sign(book_msg: BookMsg):
        self.guest_book[msg.sender] = book_msg

        emit Signed(book_msg=book_msg)

    pub def get_msg(addr: address) -> BookMsg:
        return self.guest_book[addr].to_mem()