Principes de base de la programmation des contrats intelligents TON (FreeTON)

Avant de commencer à écrire notre token, puis le système de contrat intelligent, examinons rapidement les éléments importants des contrats intelligents pour FreeTON.

Dans l'article précédent Hello Word, un contrat intelligent pour TON (FreeTON), nous avons examiné le tout début de travail avec les contrats intelligents FreeTON et HelloWorld.

La structure de cet article:

1. Types de nombres int et uint, fonctions pures et événement (événements): écrivons une calculatrice sur la blockchain;

   
   
   
   
   

2. Structures et tableaux: contrats intelligents comme base de données;

   
   
   
   
   

3. Tables de hachage: mappage;

   
   
   
   
   

4. Clés publiques et exigent.

   
   
   
   
   

: tvm.accept(); -.

int ( ) uint ( ). , : int8, int16, uint128. int uint - int256 uint256. - .

- . calc, 3 uint-: 2 - , . calc pure, , , -, , .

, - , - .

pragma ton-solidity >= 0.35.0;
pragma AbiHeader expire;

contract HelloCalc {

    event UnknownOperator(uint op);

    function calc(uint a, uint b, uint op) public pure returns (uint) {
        tvm.accept();
        
        if(op == 1) {
            return a + b;
        } else if(op == 2) {
            return a - b;
        } else if(op == 3) {
            return a * b;
        } else if(op == 4) {
            return a / b;
        } else if(op == 5) {
            return a % b;
        } else if(op == 6) {
            return a ** b;
        }else {
            emit UnknownOperator(op);
            return 0;
        }
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

(event) - , , , , , 0 , , .

( ) -, , , -. , - blockchain, - blockchain . - blockchain.

pragma ton-solidity >= 0.35.0;
pragma AbiHeader expire;

contract HelloUser {

    event NewUser(uint id);
    
    struct User {
        uint weight;
        uint balance;
    }

    User[] users;

    function AddUser(uint w, uint b) public {
        tvm.accept();
        users.push(User(w, b));
        emit NewUser(users.length - 1);
    }

    function GetUser(uint id) public view returns (uint w, uint b) {
        tvm.accept();
        w = users[id].weight;
        b = users[id].balance;
    }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

User , 2 uint: . , , , . push, - NewUser.

GetUser: returns, . pure view.

-: mapping

, (User) ( , ) . mapping. , , , , . , , .

mapping :

contract HelloToken {

    event TokenCreated(uint owner, uint tid);
    
    struct Token {
        string name;
        string symbol;
    }

    Token[] tokens;

    mapping (uint => uint) accounts;

    function NewToken() public {
        tvm.accept();

        tokens.push(Token("", ""));
        accounts[tokens.length-1] = msg.pubkey();
        emit TokenCreated(msg.pubkey(), tokens.length-1);
    }

   function GetTokenOwner(uint tid) public view returns (uint) {
       tvm.accept();
       return accounts[tid];
   }

   function GetTokenInfo(uint tid) public view returns (string _name, string _symbol) {
       tvm.accept();
       _name = tokens[tid].name;
       _symbol = tokens[tid].symbol;
   }

 function SetTokenInfo(uint tid, string _name, string _symbol) public {
       require(msg.pubkey() == accounts[tid], 101);
       tvm.accept();
       tokens[tid].name = _name;
       tokens[tid].symbol = _symbol;
   }
}
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
    

require

- , , - , ( ). : , , value TON Crystal . . - API msg.pubkey(). NewToken() accounts[tokens.length-1] = msg.pubkey(); ID accounts , , tokens. SetTokenInfo() , , . tid accounts . .

Des aspects ont été décrits ici pour les lecteurs qui étudient le sujet des contrats intelligents FreeTON «à partir de zéro», et dans les prochains articles, nous commencerons à créer notre propre token.