Bibliotecas Solidity

Nosso objetivo neste artigo é dar a você uma compreensão básica das bibliotecas Solidity , suas vantagens e como você pode implementá-las em seus contratos inteligentes.

Índice-

Bibliotecas Solidity:
- Bibliotecas Solidity – O que são?:
- Usando para:

Bibliotecas Solidity – O que são?

Uma biblioteca de solidity é semelhante a um contrato que contém código reutilizável.

Existem funções em uma biblioteca que podem ser acessadas por outros contratos.

O custo do gás é reduzido quando o código comum é implantado por meio de bibliotecas.

Apenas as funções pure e view podem ser chamadas diretamente de fora da biblioteca, pois não modificam as variáveis de estado .

Devido à suposição de que é apátrida, não pode ser destruído. As variáveis de estado não estão presentes na biblioteca, não podem herdar nada e não podem ser herdadas.

Sintaxe

Uma biblioteca em solidity pode ser construída usando a seguinte sintaxe:

library <libraryName> {
// Your Code
}

O exemplo abaixo mostra a criação de uma biblioteca customizada e sua utilização em contrato de solidez :

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
pragma solidity ^0.8.0;
library My_Library{  // Here we have created a library and have named it as My_Library
  function get_String(string memory mrx) public pure returns(string memory){
  return mrx;
 
  }
  function factorial(uint limit) public pure returns(uint){
 
  if(limit==0){
    return 0;
  }
  else{
   uint result = 1;
     for (uint i = 2; i <= limit; i++) {
      result *= i;
     }
     return result;
    }
   }
}
contract SolidityTest{
  function use_String_Method_From_My_Library(string memory ample) external pure returns(string memory){
  return My_Library.get_String(ample);  
 
  }
  function calculate_Factorial(uint mrx_Number) external pure returns(uint){
  return My_Library.factorial(mrx_Number);  
  }
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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

Da mesma forma, para criar uma biblioteca própria com funções que executam diferentes tipos de operações matemáticas, pode-se fazer o seguinte:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
pragma solidity ^0.8.0;
library Mrx_Library{  // Here we have created a library by ourselves and have named it as Mrx_Library
 function maximum(uint256 a, uint256 b) public pure returns (uint256) {
     return a > b ? a : b;
    }
 function minimum(uint256 a, uint256 b) public pure returns (uint256) {
     return a < b ? a : b;
    }
  function power(uint256 base, uint256 _exponent) public pure returns (uint256) {
     if (_exponent == 0) {
      return 1;
     } else if (_exponent % 2 == 0) {
      uint256 temp = power(base, _exponent / 2);
      return temp * temp;
     } else {
      uint256 temp = power(base, (_exponent -- 1) / 2);
      return base * temp * temp;
     }
    }
 
   function exponent(uint256 x) public pure returns (uint256) {
     uint256 result = 1;
     uint256 factorial = 1;
     for (uint256 i = 1; i <= 10; i++) {
      factorial *= i;
      result += (x ** i) / factorial;
     }
     return result;
    }
}
contract SolidityTest{  // The use of library functions in the contract can be done as shown below
  function get_Maximum(uint mrx,uint ample) external pure returns(uint){
  
  return Mrx_Library.maximum(mrx,ample); 
  }
  function get_Minimum(uint mrx,uint ample) external pure returns(uint){
  
  return Mrx_Library.minimum(mrx,ample); 
  }
  function Calculate_Power(uint mrx,uint ample) external pure returns(uint){
  
  return Mrx_Library.power(mrx,ample); 
  }
  function Calculate_Exponent(uint mrx) external pure returns(uint){
  
  return Mrx_Library.exponent(mrx); 
  }
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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

Usando para

Você pode anexar funções de biblioteca da biblioteca A a um tipo B usando a diretiva using A for B. Os tipos de chamador serão usados como o primeiro parâmetro dessas funções (identificados usando self).

O programa fornecido mostra o uso de uma palavra-chave for para criar uma melhor compreensão entre os alunos. O programa a seguir obtém uma entrada do usuário e, em seguida, usa o método table() da biblioteca personalizada para calcular sua tabela:

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
 pragma solidity ^0.5.0;
library My_Library{
   function table(uint n) public pure returns(uint[] memory) {
     uint[] memory table = new uint[](10);
     for(uint i = 1; i <= 10; i++) {
      table[i-1] = n * i;
     }
     return table;
    }
}
contract SolidityTest{
  using My_Library for uint; // Here we have made a use of Library we created above
  function get_Table(uint number) external pure returns(uint[] memory){
  return My_Library.table(number);   
  }
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

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

Conclusão

As bibliotecas Solidity desempenham um papel fundamental na escrita de contratos inteligentes eficientes, modulares e reutilizáveis.

A complexidade do código é reduzida, a segurança do contrato é aprimorada e os custos de gás são economizados.

O uso eficaz de bibliotecas permite que os desenvolvedores criem contratos inteligentes que são mais auditáveis, testáveis e implantáveis.

Nós valorizamos o seu feedback.

Bibliotecas Solidity

Bibliotecas Solidity – O que são?

Sintaxe

Example:

Example:

Usando para

Example:

Conclusão

Sentindo entediado?