Solidez – Fundamentos de los Contratos

Los Contratos de Solidez son como una clase en cualquier otro lenguaje de programación orientado a objetos. Contienen firmemente datos como variables de estado y funciones que pueden modificar estas variables. Cuando se llama a una función en una instancia diferente (contrato), ocurre la llamada a la función EVM y el contexto cambia de tal manera que las variables de estado son inaccesibles. Es necesario llamar a un contrato o su función para que algo suceda. Algunas propiedades básicas de los contratos son las siguientes:

• Constructor: método especial creado con la palabra clave constructor, que se invoca solo una vez cuando se crea el contrato.
• Variables de estado: Estas son las variables que se utilizan para almacenar el estado del contrato.
• Funciones: Las funciones se utilizan para manipular el estado de los contratos modificando las variables de estado.

Crear un contrato

La creación de contratos mediante programación generalmente se realiza mediante el uso de la API de JavaScript web3.js, que tiene una función integrada web3.eth.Contract para crear los contratos. Cuando se crea un contrato, se ejecuta su constructor, un constructor es un método especial opcional definido mediante el uso de la palabra clave constructor que ejecuta uno por contrato. Una vez que se llama al constructor, el código final del contrato se agrega a la string de bloques.

Sintaxis:

contract <contract_name>{

    constructor() <visibility>{
        .......
    }
    // rest code
}

Ejemplo: En el siguiente ejemplo, se crea la Prueba de contrato para demostrar cómo crear un contrato en Solidity.

// Solidity program to demonstrate 
// how to create a contract
pragma solidity ^0.4.23;
  
// Creating a contract
contract Test {
    
  // Declaring variable
  string str;
   
  // Defining a constructor
  constructor(string str_in){
      str = str_in;
  }
  
  // Defining a function to 
  // return value of variable 'str'
  function str_out(
  ) public view returns(string memory){
      return str;
  }
}

Producción : 

Modificadores de visibilidad

Solidity proporciona cuatro tipos de visibilidades para funciones y variables de estado. Las funciones deben especificarse mediante cualquiera de las cuatro visibilidades, pero no se permiten  variables de estado externas .

1. Externo: Las funciones externas pueden ser llamadas por otros contratos a través de transacciones. Una función externa no se puede llamar internamente. Para llamar a una función externa dentro del contrato se usa este método.function_name() . A veces, las funciones externas son más eficientes cuando tienen grandes conjuntos de datos.
2. Público: las funciones o variables públicas se pueden llamar tanto externa como internamente a través de mensajes. Para las variables estáticas públicas, se crea automáticamente un método getter en Solidity.
3. Interno: Estas funciones o variables se pueden acceder sólo internamente, es decir, dentro del contrato o los contratos derivados.
4. Privado: Estas funciones o variables solo pueden ser visibles para los contratos en los que están definidas. Tampoco son accesibles a los contratos derivados.

Ejemplo: En el siguiente ejemplo, el contrato contract_example se crea para demostrar diferentes modificadores de visibilidad discutidos anteriormente.

// Solidity program to demonstrate 
// visibility modifiers
pragma solidity ^0.5.0;
  
// Creating a contract
contract contract_example {
  
   // Declaring private 
   // state variable
   uint private num1;
     
   // Declaring public 
   // state variable
   uint public num2;
  
  // Declaring Internal 
  // state variable
   string internal str;
  
   // Defining a constructor
   constructor() public {
      num2 = 10;
   }
  
   // Defining a private function
   function increment(
     uint data1) private pure returns(
     uint) { return data1 + 1; }
     
   // Defining public functions
   function updateValue(
     uint data1) public { num1 = data1; }
   function getValue(
   ) public view returns(
     uint) { return num1; }
  
   // Declaring public functions
   function setStr(
     string memory _str) public;
   function getStr(
   ) public returns (string memory);
 }
  
   // Child contract inheriting 
   // from the parent contract
   // 'contract_example'
   contract derived_contract is contract_example{
  
   // Defining public function of 
   // parent contract
   function setStr(
     string memory _str) public{
   str = _str;
   }
  
  // Defining public function 
  // of parent contract   
  function getStr(
  ) public returns (
    string memory){ return str; }
}
  
//External Contract
contract D {
  
   // Defining a public function to create 
   // an object of child contract access the
   // functions from child and parent contract
   function readData(
   ) public payable returns(
     string memory, uint) {
      contract_example c 
        = new derived_contract();
     c.setStr("GeeksForGeeks");
      c.updateValue(16);         
      return (c.getStr(), c.getValue());
   }
}

Producción :