Grupo de criptomercados: interfaz en contratos inteligentes de solidez

¿Qué es una interfaz en Solidity?

Las interfaces se encuentran a menudo en la parte superior de un contrato inteligente. Se identifican mediante la palabra clave «interfaz». La interfaz contiene firmas de funciones sin la implementación de la definición de función (los detalles de implementación son menos importantes). Puede utilizar una interfaz en su contrato para llamar a funciones en otro contrato.

El siguiente ejemplo ilustra un contrato inteligente de muestra con la interfaz IERC20. Las firmas de funciones de esta interfaz están en formato de lista y terminan con un punto y coma. La interfaz no necesita el cuerpo (detalles de implementación) de cada función. La adición de esta interfaz hace que las funciones de IERC20 estén disponibles para su uso en el contrato de muestra.

//import the IERC20 interface
//the IERC20 interface lists functions available but no definitions
//as an example you do not know what totalSupply, balanceOf and transfer do
//because there is no function definition or function implementation listed
//you do know that the functions are available to use

pragma solidity ^0.8.7;

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient,uint256 amount) external returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract sampleContract{
     // do something     
     // do something
 }

Las interfaces son más útiles en escenarios donde su aplicación requiere extensibilidad pero no desea introducir complejidad adicional. Reducen la duplicación de código y la sobrecarga.

Características de la interfaz

• Cree una interfaz con la palabra clave «interfaz»
• Algunos nombres de interfaz comienzan con una «I» para que sean más fáciles de identificar en el código.
• Todas las funciones de la interfaz son implícitamente virtuales
• Puede anular una función de interfaz
• Los contratos pueden heredar interfaces como heredarían otros contratos
• Las interfaces pueden heredar de otras interfaces, que son las mismas reglas que la herencia normal.
• Todas las funciones que heredan de la interfaz deben establecer el modificador de anulación en cada función que anula una función de interfaz. Si no, el compilador arrojará un error
• Se puede acceder a los tipos de datos definidos dentro de las interfaces desde otros contratos. Por ejemplo, un contrato que utiliza la interfaz de muestra a continuación puede acceder a Iauto.carType e Iauto.vehicle.

pragma solidity ^0.8.7;

interface Iauto {
    enum carType { gas, electric}
    struct vehicle { string car; string truck; }
    function transfer(address recipient, uint amount) external;
}

Restricciones de interfaz

• No pueden heredar de otros contratos, pero pueden heredar de otras interfaces
• Las funciones de una interfaz solo pueden ser de tipo externo
• No pueden declarar un constructor
• No pueden declarar variables de estado

Cómo crear una interfaz en Solidity

En este ejemplo vamos a crear:

• Un contrato que contiene funciones que devuelven datos
• Un segundo contrato con interfaces al primer contrato
• El segundo contrato accederá a todas las funciones del primer contrato utilizando la interfaz

Primero, copie e implemente el contrato a continuación en Remix. Este contrato llamado dataContract contiene varias funciones que devuelven datos de muestra.

pragma solidity ^0.8.6;

contract dataContract {
    
  function getAge() external pure returns(uint) {
    return 25;
  }
  
  function getHeight() external pure returns(uint) {
    return 6;
  }
  
  function getName() external pure returns(string memory) {
    return 'Bob';
  }

  function getCar() external pure returns(string memory) {
    return 'truck';
  }
}

Pruébalo en Remezclar

A continuación, copie e implemente el contrato a continuación en Remix. Este contrato contiene una interfaz con el contrato anterior. Pegue la dirección del contrato arriba en la variable de estado en el contrato a continuación.

pragma solidity ^0.8.6;

//defined interface with functions that do not contain an implementation
//declared as type external

interface IDataContractInterface {
  function getAge() external pure returns(uint);
  function getHeight() external pure returns(uint);
  function getName() external pure returns(string memory);
  function getCar() external pure returns(string memory);
}


contract MainContract {
    
    // state variable called DataContractAddress that represents the address of the data contract
    
    address private constant DataContractAddress = PASTEFIRSTCONTRACTADDRESSHERE;
    
    
    // to access the functions in the data contract
    // use the interface declared above and wrap the data contract address in ()
    // example interfaceName(address).functionName
   
    

    function getAge() external pure returns(uint) {
        return IDataContractInterface(DataContractAddress).getAge();
  }
  
    function getHeight() external pure returns(uint) {
        return IDataContractInterface(DataContractAddress).getHeight();
  }
  
    function getName() external pure returns(string memory) {
        return IDataContractInterface(DataContractAddress).getName();
  } 
  
    function getCar() external pure returns(string memory) {
        return IDataContractInterface(DataContractAddress).getCar();
  }
}

Pruébalo en Remezclar

Finalmente, después de implementar el contrato anterior, ejecute cada una de las funciones. Las funciones utilizan la interfaz para comunicarse con el primer contrato para obtener los valores de los datos.

¿Cuál es la diferencia entre una interfaz y un contrato abstracto?

Las interfaces y los contratos abstractos son similares en muchos aspectos. Las interfaces tienden a ser más abstractas que los contratos abstractos. Todas las funciones de la interfaz carecen de implementación y, en los contratos abstractos, al menos una función carece de implementación. Como resultado, no puede compilar una interfaz o un contrato abstracto debido a la falta de implementación.

Contratos abstractos:

• Ayude a inculcar patrones de codificación en su aplicación
• Defina y auto-documente la estructura de su aplicación
• Otros tipos de contrato pueden heredar de contratos abstractos
• Por el contrario, en un contrato inteligente, las interfaces se utilizan como representaciones.

¿Cuál es la diferencia entre una interfaz y una biblioteca?

Las interfaces y bibliotecas son similares en que pProporcionar abstracción para la capacidad de actualización que se puede revisar en múltiples formas de actualizar un contrato inteligente Solidity. Sin embargo, son diferentes y resuelven diferentes casos de uso.

Interfaces:

• No puede contener lógica solo la definición de interfaz
• Principalmente útil como importaciones para interactuar con otros contratos.
• Las interfaces son más pequeñas para implementar / importar

Bibliotecas:

• Contener lógica
• Extraiga el código del contrato para fines de mantenimiento y reutilización
• Implementado una vez y luego referenciado en contratos
• El código de bytes se implementa por separado y no es parte de los contratos que los hace referencia.