స్మార్ట్ కాంట్రాక్ట్ భాషలు

ఎథీరియం గురించిన ఒక గొప్ప విషయం ఏమిటంటే, స్మార్ట్ కాంట్రాక్ట్‌లను డెవలపర్‌లకు అనుకూలమైన భాషలను ఉపయోగించి ప్రోగ్రామ్ చేయవచ్చు. మీకు Python లేదా ఏదైనా కర్లీ-బ్రాకెట్ భాష (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)తో అనుభవం ఉంటే, మీకు తెలిసిన సింటాక్స్‌తో కూడిన భాషను మీరు కనుగొనవచ్చు.

అత్యంత చురుకైన మరియు నిర్వహించబడుతున్న రెండు భాషలు:

Solidity
Vyper

Remix IDE అనేది Solidity మరియు Vyper రెండింటిలోనూ కాంట్రాక్ట్‌లను సృష్టించడానికి మరియు పరీక్షించడానికి ఒక సమగ్ర అభివృద్ధి పర్యావరణాన్ని అందిస్తుంది. కోడింగ్ ప్రారంభించడానికి ఇన్-బ్రౌజర్ Remix IDEని ప్రయత్నించండి (కొత్త ట్యాబ్‌లో తెరవబడుతుంది).

మరింత అనుభవజ్ఞులైన డెవలపర్‌లు ఈథీరియం వర్చువల్ మెషీన్ (EVM) కోసం ఇంటర్మీడియట్ భాష అయిన Yul లేదా Yulకి పొడిగింపు అయిన Yul+ని ఉపయోగించాలనుకోవచ్చు.

మీకు ఆసక్తి ఉండి, ఇంకా భారీ అభివృద్ధిలో ఉన్న కొత్త భాషలను పరీక్షించడంలో సహాయపడాలనుకుంటే, మీరు ప్రస్తుతం ప్రారంభ దశలో ఉన్న అభివృద్ధి చెందుతున్న స్మార్ట్ కాంట్రాక్ట్ భాష అయిన Feతో ప్రయోగాలు చేయవచ్చు.

ముందస్తు అవసరాలు

ప్రోగ్రామింగ్ భాషల గురించి, ముఖ్యంగా JavaScript లేదా Python గురించి మునుపటి జ్ఞానం, స్మార్ట్ కాంట్రాక్ట్ భాషలలోని తేడాలను అర్థం చేసుకోవడంలో మీకు సహాయపడుతుంది. భాషా పోలికలలోకి లోతుగా వెళ్లే ముందు స్మార్ట్ కాంట్రాక్ట్‌లను ఒక కాన్సెప్ట్‌గా అర్థం చేసుకోవాలని కూడా మేము సిఫార్సు చేస్తున్నాము. స్మార్ట్ కాంట్రాక్ట్‌ల పరిచయం.

Solidity

స్మార్ట్ కాంట్రాక్ట్‌లను అమలు చేయడానికి ఆబ్జెక్ట్-ఓరియెంటెడ్, హై-లెవల్ భాష.
C++ ద్వారా అత్యంత లోతుగా ప్రభావితమైన కర్లీ-బ్రాకెట్ భాష.
స్టాటికల్లీ టైప్ చేయబడింది (వేరియబుల్ రకం కంపైల్ సమయంలో తెలుస్తుంది).
వీటికి మద్దతు ఇస్తుంది:
- ఇన్‌హెరిటెన్స్ (మీరు ఇతర కాంట్రాక్ట్‌లను విస్తరించవచ్చు).
- లైబ్రరీలు (మీరు వివిధ కాంట్రాక్ట్‌ల నుండి కాల్ చేయగల పునర్వినియోగ కోడ్‌ను సృష్టించవచ్చు – ఇతర ఆబ్జెక్ట్ ఓరియెంటెడ్ ప్రోగ్రామింగ్ భాషలలోని స్టాటిక్ క్లాస్‌లోని స్టాటిక్ ఫంక్షన్‌ల వలె).
- సంక్లిష్టమైన వినియోగదారు-నిర్వచించిన రకాలు.

ముఖ్యమైన లింక్‌లు

ఉదాహరణ కాంట్రాక్ట్

// 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);
    }
}

ఈ ఉదాహరణ మీకు Solidity కాంట్రాక్ట్ సింటాక్స్ ఎలా ఉంటుందో ఒక అవగాహనను ఇస్తుంది. ఫంక్షన్‌లు మరియు వేరియబుల్స్ యొక్క మరింత వివరణాత్మక వివరణ కోసం, డాక్స్‌ని చూడండి (కొత్త ట్యాబ్‌లో తెరవబడుతుంది).

Vyper

పైథానిక్ ప్రోగ్రామింగ్ భాష
స్ట్రాంగ్ టైపింగ్
చిన్న మరియు అర్థమయ్యే కంపైలర్ కోడ్
సమర్థవంతమైన బైట్‌కోడ్ ఉత్పత్తి
కాంట్రాక్ట్‌లను మరింత సురక్షితంగా మరియు ఆడిట్ చేయడానికి సులభంగా చేయాలనే లక్ష్యంతో ఉద్దేశపూర్వకంగా Solidity కంటే తక్కువ ఫీచర్‌లను కలిగి ఉంది. Vyper వీటికి మద్దతు ఇవ్వదు:
- మాడిఫైయర్‌లు
- ఇన్‌హెరిటెన్స్
- ఇన్‌లైన్ అసెంబ్లీ
- ఫంక్షన్ ఓవర్‌లోడింగ్
- ఆపరేటర్ ఓవర్‌లోడింగ్
- రికర్సివ్ కాలింగ్
- అనంతమైన-పొడవు లూప్‌లు
- బైనరీ ఫిక్స్‌డ్ పాయింట్‌లు

v0.4.0 నుండి, Vyper మాడ్యూల్ సిస్టమ్ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)కి మద్దతు ఇస్తుంది. క్లాస్ ఇన్‌హెరిటెన్స్ ద్వారా కాకుండా కంపోజిషన్ ద్వారా కోడ్ పునర్వినియోగం సాధించబడుతుంది.

మరింత సమాచారం కోసం, Vyper హేతుబద్ధతను చదవండి (కొత్త ట్యాబ్‌లో తెరవబడుతుంది).

ముఖ్యమైన లింక్‌లు

ఉదాహరణ

# ఓపెన్ వేలం

# వేలం పారామితులు
# అత్యధిక బిడ్డర్ నుండి లబ్ధిదారుడు డబ్బును అందుకుంటాడు
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`.
@deploy
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)

ఈ ఉదాహరణ మీకు Vyper కాంట్రాక్ట్ సింటాక్స్ ఎలా ఉంటుందో ఒక అవగాహనను ఇస్తుంది. ఫంక్షన్‌లు మరియు వేరియబుల్స్ యొక్క మరింత వివరణాత్మక వివరణ కోసం, డాక్స్‌ని చూడండి (కొత్త ట్యాబ్‌లో తెరవబడుతుంది).

Yul మరియు Yul+

మీరు ఎథీరియంకి కొత్త అయితే మరియు ఇంకా స్మార్ట్ కాంట్రాక్ట్ భాషలతో ఎలాంటి కోడింగ్ చేయకపోతే, Solidity లేదా Vyperతో ప్రారంభించాలని మేము సిఫార్సు చేస్తున్నాము. మీరు స్మార్ట్ కాంట్రాక్ట్ భద్రతా ఉత్తమ పద్ధతులు మరియు EVMతో పనిచేయడంలోని ప్రత్యేకతలతో పరిచయం పెంచుకున్న తర్వాత మాత్రమే Yul లేదా Yul+ని పరిశీలించండి.

Yul

ఎథీరియం కోసం ఇంటర్మీడియట్ భాష.
EVM మరియు ఎథీరియం ఫ్లేవర్డ్ WebAssembly అయిన Ewasm (కొత్త ట్యాబ్‌లో తెరవబడుతుంది)కి మద్దతు ఇస్తుంది మరియు రెండు ప్లాట్‌ఫారమ్‌ల యొక్క ఉపయోగించదగిన సాధారణ హారంగా రూపొందించబడింది.
EVM మరియు Ewasm ప్లాట్‌ఫారమ్‌లు రెండింటికీ సమానంగా ప్రయోజనం చేకూర్చే హై-లెవల్ ఆప్టిమైజేషన్ దశలకు మంచి లక్ష్యం.

Yul+

Yulకి తక్కువ-స్థాయి, అత్యంత సమర్థవంతమైన పొడిగింపు.
ప్రారంభంలో ఆశావాద రోలప్ కాంట్రాక్ట్ కోసం రూపొందించబడింది.
Yul+ని Yulకి ప్రయోగాత్మక అప్‌గ్రేడ్ ప్రతిపాదనగా చూడవచ్చు, దానికి కొత్త ఫీచర్‌లను జోడిస్తుంది.

ముఖ్యమైన లింక్‌లు

ఉదాహరణ కాంట్రాక్ట్

కింది సాధారణ ఉదాహరణ పవర్ ఫంక్షన్‌ను అమలు చేస్తుంది. దీన్ని solc --strict-assembly --bin input.yul ఉపయోగించి కంపైల్ చేయవచ్చు. ఉదాహరణను input.yul ఫైల్‌లో నిల్వ చేయాలి.

{
    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)
}

మీరు ఇప్పటికే స్మార్ట్ కాంట్రాక్ట్‌లతో మంచి అనుభవం కలిగి ఉంటే, Yulలో పూర్తి ERC-20 అమలును ఇక్కడ (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) కనుగొనవచ్చు.

Fe

ఈథీరియం వర్చువల్ మెషీన్ (EVM) కోసం స్టాటికల్లీ టైప్ చేయబడిన భాష.
Python మరియు Rust ద్వారా ప్రేరణ పొందింది.
ఎథీరియం పర్యావరణ వ్యవస్థకు కొత్త అయిన డెవలపర్‌లకు కూడా -- నేర్చుకోవడానికి సులభంగా ఉండాలని లక్ష్యంగా పెట్టుకుంది.
Fe అభివృద్ధి ఇంకా ప్రారంభ దశలోనే ఉంది, ఈ భాష జనవరి 2021లో దాని ఆల్ఫా విడుదలను కలిగి ఉంది.

ముఖ్యమైన లింక్‌లు

ఉదాహరణ కాంట్రాక్ట్

కిందిది Feలో అమలు చేయబడిన ఒక సాధారణ కాంట్రాక్ట్.

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()

ఎలా ఎంచుకోవాలి

ఏదైనా ఇతర ప్రోగ్రామింగ్ భాష వలె, ఇది ఎక్కువగా సరైన పని కోసం సరైన సాధనాన్ని ఎంచుకోవడంతో పాటు వ్యక్తిగత ప్రాధాన్యతలకు సంబంధించినది.

మీరు ఇంకా ఏ భాషలనూ ప్రయత్నించకపోతే పరిగణించవలసిన కొన్ని విషయాలు ఇక్కడ ఉన్నాయి:

Solidity గురించి గొప్ప విషయం ఏమిటి?

మీరు అనుభవశూన్యుడు అయితే, అక్కడ అనేక ట్యుటోరియల్స్ మరియు అభ్యాస సాధనాలు ఉన్నాయి. కోడింగ్ ద్వారా నేర్చుకోండి విభాగంలో దాని గురించి మరింత చూడండి.
మంచి డెవలపర్ టూలింగ్ అందుబాటులో ఉంది.
Solidity పెద్ద డెవలపర్ కమ్యూనిటీని కలిగి ఉంది, అంటే మీరు మీ ప్రశ్నలకు చాలా త్వరగా సమాధానాలను కనుగొనే అవకాశం ఉంది.

Vyper గురించి గొప్ప విషయం ఏమిటి?

స్మార్ట్ కాంట్రాక్ట్‌లను వ్రాయాలనుకునే Python డెవలపర్‌లు ప్రారంభించడానికి గొప్ప మార్గం.
Vyper తక్కువ సంఖ్యలో ఫీచర్‌లను కలిగి ఉంది, ఇది ఆలోచనల యొక్క శీఘ్ర నమూనా కోసం గొప్పగా చేస్తుంది.
Vyper ఆడిట్ చేయడానికి సులభంగా మరియు గరిష్టంగా మానవులు చదవగలిగేలా ఉండాలని లక్ష్యంగా పెట్టుకుంది.

Yul మరియు Yul+ గురించి గొప్ప విషయం ఏమిటి?

సరళమైన మరియు క్రియాత్మకమైన తక్కువ-స్థాయి భాష.
ముడి EVMకి మరింత దగ్గరగా వెళ్లడానికి అనుమతిస్తుంది, ఇది మీ కాంట్రాక్ట్‌ల గ్యాస్ వినియోగాన్ని ఆప్టిమైజ్ చేయడంలో సహాయపడుతుంది.

భాషా పోలికలు

ప్రాథమిక సింటాక్స్, కాంట్రాక్ట్ జీవితచక్రం, ఇంటర్‌ఫేస్‌లు, ఆపరేటర్‌లు, డేటా స్ట్రక్చర్‌లు, ఫంక్షన్‌లు, కంట్రోల్ ఫ్లో మరియు మరిన్నింటి పోలికల కోసం Auditless వారి ఈ చీట్‌షీట్‌ని (కొత్త ట్యాబ్‌లో తెరవబడుతుంది) చూడండి

స్మార్ట్ కాంట్రాక్ట్ భాషలు

ముందస్తు అవసరాలు

Solidity

ముఖ్యమైన లింక్‌లు

ఉదాహరణ కాంట్రాక్ట్

Vyper

ముఖ్యమైన లింక్‌లు

ఉదాహరణ

Yul మరియు Yul+

ముఖ్యమైన లింక్‌లు

ఉదాహరణ కాంట్రాక్ట్

Fe

ముఖ్యమైన లింక్‌లు

ఉదాహరణ కాంట్రాక్ట్

ఎలా ఎంచుకోవాలి

Solidity గురించి గొప్ప విషయం ఏమిటి?

Vyper గురించి గొప్ప విషయం ఏమిటి?

Yul మరియు Yul+ గురించి గొప్ప విషయం ఏమిటి?

భాషా పోలికలు

తదుపరి పఠనం