Bahasa kontrak pintar

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

contract Coin {
    // The keyword "public" makes variables // Kata kunci "public" membuat variabel
    // accessible from other contracts // dapat diakses dari kontrak lain
    address public minter;
    mapping (address => uint) public balances;

    // Events allow clients to react to specific // Event memungkinkan klien bereaksi terhadap
    // contract changes you declare // perubahan kontrak tertentu yang Anda deklarasikan
    event Sent(address from, address to, uint amount);

    // Constructor code is only run when the contract // Kode konstruktor hanya dijalankan ketika kontrak
    // is created // dibuat
    constructor() {
        minter = msg.sender;
    }

    // Sends an amount of newly created coins to an address // Mengirim sejumlah koin yang baru dibuat ke sebuah alamat
    // Can only be called by the contract creator // Hanya dapat dipanggil oleh pembuat kontrak
    function mint(address receiver, uint amount) public {
        require(msg.sender == minter);
        require(amount < 1e60);
        balances[receiver] += amount;
    }

    // Sends an amount of existing coins // Mengirim sejumlah koin yang ada
    // from any caller to an address // dari pemanggil mana pun ke sebuah alamat
    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);
    }
}

# Open Auction # Lelang Terbuka

# Auction params # Parameter lelang
# Beneficiary receives money from the highest bidder # Penerima manfaat menerima uang dari penawar tertinggi
beneficiary: public(address)
auctionStart: public(uint256)
auctionEnd: public(uint256)

# Current state of auction # Status lelang saat ini
highestBidder: public(address)
highestBid: public(uint256)

# Set to true at the end, disallows any change # Ditetapkan menjadi true pada akhirnya, tidak mengizinkan perubahan apa pun
ended: public(bool)

# Keep track of refunded bids so we can follow the withdraw pattern # Melacak penawaran yang dikembalikan sehingga kita dapat mengikuti pola penarikan
pendingReturns: public(HashMap[address, uint256])

# Create a simple auction with `_bidding_time` # Buat lelang sederhana dengan `_bidding_time`
# seconds bidding time on behalf of the # detik waktu penawaran atas nama
# beneficiary address `_beneficiary`. # alamat penerima manfaat `_beneficiary`.
@external
def __init__(_beneficiary: address, _bidding_time: uint256):
    self.beneficiary = _beneficiary
    self.auctionStart = block.timestamp
    self.auctionEnd = self.auctionStart + _bidding_time

# Bid on the auction with the value sent # Menawar pada lelang dengan nilai yang dikirimkan
# together with this transaction. # bersama dengan transaksi ini.
# The value will only be refunded if the # Nilai hanya akan dikembalikan jika
# auction is not won. # lelang tidak dimenangkan.
@external
@payable
def bid():
    # Check if bidding period is over. # Periksa apakah periode penawaran telah berakhir.
    assert block.timestamp < self.auctionEnd
    # Check if bid is high enough # Periksa apakah penawaran cukup tinggi
    assert msg.value > self.highestBid
    # Track the refund for the previous high bidder # Lacak pengembalian dana untuk penawar tertinggi sebelumnya
    self.pendingReturns[self.highestBidder] += self.highestBid
    # Track new high bid # Lacak penawaran tertinggi baru
    self.highestBidder = msg.sender
    self.highestBid = msg.value

# Withdraw a previously refunded bid. The withdraw pattern is # Tarik penawaran yang sebelumnya dikembalikan. Pola penarikan
# used here to avoid a security issue. If refunds were directly # digunakan di sini untuk menghindari masalah keamanan. Jika pengembalian dana langsung
# sent as part of bid(), a malicious bidding contract could block # dikirim sebagai bagian dari bid(), kontrak penawaran berbahaya dapat memblokir
# those refunds and thus block new higher bids from coming in. # pengembalian dana tersebut dan dengan demikian memblokir penawaran baru yang lebih tinggi untuk masuk.
@external
def withdraw():
    pending_amount: uint256 = self.pendingReturns[msg.sender]
    self.pendingReturns[msg.sender] = 0
    send(msg.sender, pending_amount)

# End the auction and send the highest bid # Akhiri lelang dan kirim penawaran tertinggi
# to the beneficiary. # ke penerima manfaat.
@external
def endAuction():
    # It is a good guideline to structure functions that interact # Ini adalah pedoman yang baik untuk menyusun fungsi yang berinteraksi
    # with other contracts (i.e., they call functions or send ether) # dengan kontrak lain (yaitu, mereka memanggil fungsi atau mengirim ether)
    # into three phases: # ke dalam tiga fase:
    # 1. checking conditions # 1. memeriksa kondisi
    # 2. performing actions (potentially changing conditions) # 2. melakukan tindakan (berpotensi mengubah kondisi)
    # 3. interacting with other contracts # 3. berinteraksi dengan kontrak lain
    # If these phases are mixed up, the other contract could call # Jika fase-fase ini dicampuradukkan, kontrak lain dapat memanggil
    # back into the current contract and modify the state or cause # kembali ke kontrak saat ini dan memodifikasi status atau menyebabkan
    # effects (ether payout) to be performed multiple times. # efek (pembayaran ether) dilakukan berkali-kali.
    # If functions called internally include interaction with external # Jika fungsi yang dipanggil secara internal mencakup interaksi dengan
    # contracts, they also have to be considered interaction with # kontrak eksternal, mereka juga harus dianggap sebagai interaksi dengan
    # external contracts. # kontrak eksternal.

    # 1. Conditions # 1. Kondisi
    # Check if auction endtime has been reached # Periksa apakah waktu akhir lelang telah tercapai
    assert block.timestamp >= self.auctionEnd
    # Check if this function has already been called # Periksa apakah fungsi ini sudah dipanggil
    assert not self.ended

    # 2. Effects # 2. Efek
    self.ended = True

    # 3. Interaction # 3. Interaksi
    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()