Guia rápido para interfaces Solidity

Neste artigo, examinaremos mais de perto as interfaces do Solidity e exploraremos como elas podem ser usadas para criar projetos de contrato flexíveis e modulares.

Índice-

Guia rápido para interfaces Solidity:
- Interface de Solidez:
- Benefícios do uso de interfaces:

Interface Solidity

A interface Solidity é a mesma coisa que um contrato abstrato criado com a palavra-chave interface.

Não há variáveis de estado , construtores ou funções com implementações. Em vez disso, eles contêm apenas declarações de funções, ou seja, funções de interface não são declarações.

As funções de interface só podem ter tipos externos. É possível herdar de outras interfaces, mas não de outros contratos.

Pode haver enums e structs em interfaces, que podem ser acessados usando a notação de ponto do nome da interface.

O exemplo a seguir ajudará você a entender o conceito de interfaces e seu uso:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
pragma solidity ^0.8.0;
interface  SolidityTest{  // Here we declare an interface
  function get_String(string memory mrx) external view returns(string memory);  // only external methods can be initialized inside the interface methods
}
contract SolidityTest1 is SolidityTest{  // Here we have inherited the SolidityTest using SolidityTest1
  function get_String (string memory mrx) public pure returns(string memory){
    return mrx;
  }
}
contract SolidityTest2{
 SolidityTest obj;
 constructor(){
  obj=new SolidityTest1();
 
  }
  function show_String() public view returns(string memory){
    return obj.get_String("Mr.Examples");
  }
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Para entender melhor o funcionamento das Interfaces veja o exemplo abaixo:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
pragma solidity ^0.8.0;
interface  SolidityTest{  // Here we declare an interface
  // only external methods can be initialized inside the interface methods
  function get_Sum(uint mrx,uint ample) external view returns(uint);
  function get_Product(uint mrx,uint ample) external view returns(uint);
  function get_Difference(uint mrx,uint ample) external view returns(uint);
  function get_Modulus(uint mrx,uint ample) external view returns(uint);
 
 
}
contract SolidityTest1 is SolidityTest{ // Here we have created another contract named as SolidityTest1 and have inherited from SolidityTest
   function get_Sum(uint mrx,uint ample) public pure returns(uint){
   return mrx+ample;
   }
    function get_Product(uint mrx,uint ample) public pure returns(uint){
   return mrx*ample;
   }
    function get_Difference(uint mrx,uint ample) public pure returns(uint){
   return mrx-ample;
   }
    function get_Modulus(uint mrx,uint ample) public pure returns(uint){
   return mrx%ample;
   }
}
contract SolidityTest2{
  SolidityTest mrx_obj;
 
  constructor(){
  mrx_obj=new SolidityTest1();
}
function obtain_Values() public view returns(uint,uint,uint,uint){
  return(mrx_obj.get_Sum(2,3),mrx_obj.get_Product(4,6),mrx_obj.get_Difference(7,3),mrx_obj.get_Modulus(6,3));
  }
} 
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

<div class="spinner-border" role="status"><span class="sr-only">Loading...</span></div>

Exemplo de Explicação

No exemplo acima, definimos uma interface chamada SolidityTest que inclui quatro assinaturas de função. Essas funções são declaradas como visão externa, o que significa que não modificam o estado do contrato e podem ser chamadas de fora do contrato.

Em seguida, definimos um contrato chamado SolidityTest1 que implementa as funções de SolidityTest. Essas implementações usam o modificador pure, que indica que as funções não leem ou modificam o estado do contrato.

Por fim, definimos um segundo contrato chamado SolidityTest2 que cria uma instância de SolidityTest1 e a utiliza para chamar as funções get_Sum, get_Product, get_Difference e get_Modulus. Essas chamadas de função são feitas usando a instância mrx_obj de SolidityTest1, que é armazenada como uma variável de estado em SolidityTest2.

Benefícios do uso de interfaces

As interfaces Solidity são benéficas para o desenvolvimento de contratos por vários motivos:

As interfaces permitem que os contratos interajam de maneira padronizada. As interfaces fornecem uma maneira consistente e confiável para os contratos se comunicarem uns com os outros, definindo um conjunto de funções.
Os contratos podem se tornar mais flexíveis e modulares usando interfaces. É possível projetar contratos que funcionem juntos de maneira plug-and-play utilizando interfaces, que permitem aos desenvolvedores trocar uma implementação de contrato por outra sem afetar o sistema geral.
As interfaces permitem desacoplar os contratos entre si. Como resultado, os contratos podem ser desenvolvidos e testados de forma independente, o que melhora a eficiência geral do desenvolvimento.
Interfaces permitem que contratos e sistemas trabalhem juntos. As interfaces padrão permitem que os contratos interajam entre si em diferentes plataformas e sistemas, permitindo maior conectividade e compatibilidade.

Conclusão

As interfaces Solidity são conceitos críticos para o desenvolvimento de contratos inteligentes que aumentam a flexibilidade, padronização e interoperabilidade. Eles permitem que os contratos se comuniquem e interajam de maneira confiável e consistente, o que é essencial para o desenvolvimento de aplicativos descentralizados complexos.

Usando interfaces, você pode criar contratos modulares, interoperáveis e padronizados que funcionam perfeitamente dentro de um ecossistema descentralizado, especificando um conjunto de funções que os contratos precisam executar. Portanto, as interfaces do Solidity podem ser usadas para criar contratos inteligentes confiáveis, seguros e escaláveis.

Nós valorizamos o seu feedback.

Guia rápido para interfaces Solidity

Interface Solidity

Example:

Example:

Exemplo de Explicação

Benefícios do uso de interfaces

Conclusão

Sentindo entediado?