├── .gitignore ├── src ├── apostila │ ├── README.md │ ├── extra-avancado │ │ ├── 24.-heranca.md │ │ ├── README.md │ │ ├── 19.-fallback-functions.md │ │ ├── 21.-bibliotecas-librarys.md │ │ └── 20.-assembly.md │ ├── 14.-interagindo-com-outro-contrato.md │ ├── 16.-criando-contratos-a-partir-de-um-contrato..md │ ├── 17.-erros.md │ ├── 15.-constructor.md │ ├── visibilidade-de-variaveis-external-public-internal-and-private.md │ ├── 14.-eventos.md │ ├── visibilidade-de-funcoes-external-public-internal-and-private.md │ ├── 18.-modificadores.md │ ├── modificadores-de-funcoes-view-pure-constant.md │ ├── estrutura-de-contratos-inteligentes.md │ ├── controladores-de-fluxo-if-for-while.md │ ├── arrays-listas.md │ ├── 13.-memory-vs-storage.md │ ├── 12.-enums.md │ └── 15.-funcoes-pagaveis-function-payable.md ├── es │ ├── apostila │ │ ├── README.md │ │ ├── extra-avancado │ │ │ ├── 24.-heranca.md │ │ │ ├── README.md │ │ │ ├── 23.-bibliotecas-librarys.md │ │ │ ├── 21.-fallback-functions.md │ │ │ └── 22.-assembly.md │ │ ├── 18.-interagindo-com-outro-contrato.md │ │ ├── 19.-criando-contratos-a-partir-de-um-contrato..md │ │ ├── 20.-erros.md │ │ ├── 16.-constructor.md │ │ ├── 6.-visibilidade-de-variaveis-external-public-internal-and-private.md │ │ ├── 14.-eventos.md │ │ ├── 4.-modificadores-de-funcoes-view-pure-constant.md │ │ ├── 5.-visibilidade-de-funcoes-external-public-internal-and-private.md │ │ ├── 1.-estrutura-de-contratos-inteligentes.md │ │ ├── 9.-controladores-de-fluxo-if-for-while.md │ │ ├── 15.-modificadores.md │ │ ├── 8.-arrays-listas.md │ │ └── 13.-memory-vs-storage.md │ ├── exemplos │ │ ├── defi │ │ │ ├── README.md │ │ │ └── oraculo-de-preco-da-chainlink.md │ │ ├── hacks │ │ │ ├── README.md │ │ │ ├── manipulacao-do-bloco-timestamp.md │ │ │ ├── ignorar-a-verificacao-do-tamanho-do-contrato.md │ │ │ ├── fonte-de-aleatoriedade.md │ │ │ ├── escondendo-codigos-maliciosos-com-contrato-externo.md │ │ │ └── front-running.md │ │ ├── aplicacoes │ │ │ ├── README.md │ │ │ ├── leilao-holandes.md │ │ │ └── implante-qualquer-contrato.md │ │ ├── linguagem-v0.8.3 │ │ │ ├── README.md │ │ │ ├── ola-mundo.md │ │ │ ├── constantes.md │ │ │ ├── ether-e-wei.md │ │ │ ├── imutaveis.md │ │ │ ├── primeira-aplicacao.md │ │ │ ├── funcoes-view-e-pure.md │ │ │ ├── eventos.md │ │ │ ├── if-else.md │ │ │ ├── lendo-e-escrevendo-para-uma-variavel-de-estado.md │ │ │ ├── variaveis.md │ │ │ ├── for-e-while-loop.md │ │ │ ├── sombreamento-de-variaveis-de-estado-herdadas.md │ │ │ ├── seletor-de-funcao.md │ │ │ ├── delegatecall.md │ │ │ ├── chamando-outro-contrato.md │ │ │ ├── gas.md │ │ │ ├── import.md │ │ │ ├── fallback.md │ │ │ ├── hashing-with-keccak256.md │ │ │ ├── constructor.md │ │ │ ├── pagavel.md │ │ │ ├── tipos-de-dados-primarios.md │ │ │ ├── localizacoes-de-dados-armazenamento-memoria-e-calldata.md │ │ │ ├── mapping.md │ │ │ ├── call.md │ │ │ ├── contrato-que-cria-outros-contratos.md │ │ │ ├── enum.md │ │ │ ├── interface.md │ │ │ ├── chamando-contratos-de-classe-pai.md │ │ │ ├── modificador-de-funcao.md │ │ │ ├── biblioteca.md │ │ │ ├── try-catch.md │ │ │ └── heranca.md │ │ └── README.md │ ├── ambiente │ │ ├── truffle.md │ │ ├── hardhat.md │ │ └── untitled.md │ ├── seguranca │ │ ├── README.md │ │ └── vulnerabilidades-conhecidas │ │ │ ├── README.md │ │ │ ├── funcao-de-re-entrada-reetrancy.md │ │ │ └── overflow-e-underflow-aritmetico.md │ ├── evm-maquina-virtual-ethereum │ │ ├── accounts.md │ │ ├── bytecodes.md │ │ ├── op_codes.md │ │ ├── gas-taxas.md │ │ ├── transactions.md │ │ ├── README.md │ │ └── patterns-and-standards │ │ │ └── README.md │ └── README.md ├── exemplos │ ├── defi │ │ ├── README.md │ │ └── oraculo-de-preco-da-chainlink.md │ ├── testes │ │ └── README.md │ ├── hacks │ │ ├── README.md │ │ ├── manipulacao-do-bloco-timestamp.md │ │ ├── ignorar-a-verificacao-do-tamanho-do-contrato.md │ │ ├── fonte-de-aleatoriedade.md │ │ ├── escondendo-codigos-maliciosos-com-contrato-externo.md │ │ └── front-running.md │ ├── aplicacoes │ │ ├── README.md │ │ ├── leilao-holandes.md │ │ └── implante-qualquer-contrato.md │ ├── linguagem-v0.8.3 │ │ ├── README.md │ │ ├── ola-mundo.md │ │ ├── constantes.md │ │ ├── ether-e-wei.md │ │ ├── imutaveis.md │ │ ├── primeira-aplicacao.md │ │ ├── funcoes-view-e-pure.md │ │ ├── eventos.md │ │ ├── if-else.md │ │ ├── chamando-outro-contrato.md │ │ ├── lendo-e-escrevendo-para-uma-variavel-de-estado.md │ │ ├── for-e-while-loop.md │ │ ├── variaveis.md │ │ ├── sombreamento-de-variaveis-de-estado-herdadas.md │ │ ├── seletor-de-funcao.md │ │ ├── delegatecall.md │ │ ├── fallback.md │ │ ├── gas.md │ │ ├── import.md │ │ ├── hashing-with-keccak256.md │ │ ├── constructor.md │ │ ├── pagavel.md │ │ ├── localizacoes-de-dados-armazenamento-memoria-e-calldata.md │ │ ├── tipos-de-dados-primarios.md │ │ ├── mapping.md │ │ ├── call.md │ │ ├── contrato-que-cria-outros-contratos.md │ │ ├── enum.md │ │ ├── chamando-contratos-de-classe-pai.md │ │ ├── interface.md │ │ ├── modificador-de-funcao.md │ │ ├── funcao.md │ │ ├── biblioteca.md │ │ ├── try-catch.md │ │ └── heranca.md │ └── README.md ├── ambiente │ ├── truffle.md │ ├── hardhat.md │ └── untitled.md ├── seguranca │ ├── README.md │ └── vulnerabilidades-conhecidas │ │ ├── README.md │ │ ├── funcao-de-re-entrada-reetrancy.md │ │ └── overflow-e-underflow-aritmetico.md ├── .vuepress │ └── styles │ │ ├── config.scss │ │ └── palette.styl ├── evm-maquina-virtual-ethereum │ ├── accounts.md │ ├── bytecodes.md │ ├── op_codes.md │ ├── gas-taxas.md │ ├── transactions.md │ ├── README.md │ └── patterns-and-standards │ │ └── README.md ├── assets │ ├── x.png │ ├── hero.png │ ├── image.png │ ├── image(1).png │ ├── image(10).png │ ├── image(11).png │ ├── image(12).png │ ├── image(13).png │ ├── image(14).png │ ├── image(15).png │ ├── image(16).png │ ├── image(17).png │ ├── image(18).png │ ├── image(19).png │ ├── image(2).png │ ├── image(20).png │ ├── image(21).png │ ├── image(22).png │ ├── image(23).png │ ├── image(24).png │ ├── image(25).png │ ├── image(26).png │ ├── image(27).png │ ├── image(28).png │ ├── image(29).png │ ├── image(3).png │ ├── image(30).png │ ├── image(31).png │ ├── image(32).png │ ├── image(33).png │ ├── image(34).png │ ├── image(35).png │ ├── image(36).png │ ├── image(37).png │ ├── image(38).png │ ├── image(39).png │ ├── image(4).png │ ├── image(40).png │ ├── image(41).png │ ├── image(42).png │ ├── image(43).png │ ├── image(44).png │ ├── image(45).png │ ├── image(46).png │ ├── image(47).png │ ├── image(48).png │ ├── image(49).png │ ├── image(5).png │ ├── image(50).png │ ├── image(51).png │ ├── image(52).png │ ├── image(53).png │ ├── image(54).png │ ├── image(55).png │ ├── image(56).png │ ├── image(57).png │ ├── image(58).png │ ├── image(59).png │ ├── image(6).png │ ├── image(60).png │ ├── image(61).png │ ├── image(62).png │ ├── image(63).png │ ├── image(64).png │ ├── image(65).png │ ├── image(66).png │ ├── image(67).png │ ├── image(68).png │ ├── image(69).png │ ├── image(7).png │ ├── image(70).png │ ├── image(71).png │ ├── image(72).png │ ├── image(73).png │ ├── image(74).png │ ├── image(75).png │ ├── image(76).png │ ├── image(77).png │ ├── image(78).png │ ├── image(79).png │ ├── image(8).png │ ├── image(80).png │ ├── image(81).png │ ├── image(82).png │ ├── image(83).png │ ├── image(84).png │ ├── image(85).png │ ├── image(86).png │ ├── image(87).png │ ├── image(88).png │ ├── image(89).png │ ├── image(9).png │ ├── image(90).png │ ├── image(91).png │ ├── image(92).png │ ├── image(93).png │ ├── image(94).png │ ├── image(95).png │ ├── image(96).png │ ├── image(97).png │ ├── image(98).png │ ├── image(99).png │ ├── image(100).png │ ├── image(101).png │ ├── image(102).png │ ├── image(103).png │ ├── image(104).png │ ├── image(105).png │ ├── image(106).png │ ├── image(107).png │ ├── image(108).png │ ├── image(109).png │ ├── image(110).png │ ├── image(111).png │ ├── image(112).png │ ├── image(113).png │ ├── image(114).png │ ├── image(115).png │ ├── image(116).png │ ├── image(117).png │ ├── image(118).png │ ├── image(119).png │ ├── image(120).png │ ├── image(121).png │ ├── image(122).png │ ├── image(123).png │ ├── image(124).png │ ├── image(125).png │ ├── image(126).png │ └── image(40)(1).png └── README.md ├── package.json └── README.md /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | dist -------------------------------------------------------------------------------- /src/apostila/README.md: -------------------------------------------------------------------------------- 1 | [[toc]] -------------------------------------------------------------------------------- /src/es/apostila/README.md: -------------------------------------------------------------------------------- 1 | [[toc]] 2 | -------------------------------------------------------------------------------- /src/exemplos/defi/README.md: -------------------------------------------------------------------------------- 1 | # DeFi 2 | 3 | -------------------------------------------------------------------------------- /src/exemplos/testes/README.md: -------------------------------------------------------------------------------- 1 | # Testes 2 | -------------------------------------------------------------------------------- /src/es/exemplos/defi/README.md: -------------------------------------------------------------------------------- 1 | # DeFi 2 | 3 | -------------------------------------------------------------------------------- /src/es/exemplos/hacks/README.md: -------------------------------------------------------------------------------- 1 | # Hacks 2 | 3 | -------------------------------------------------------------------------------- /src/exemplos/hacks/README.md: -------------------------------------------------------------------------------- 1 | # Hacks 2 | 3 | -------------------------------------------------------------------------------- /src/ambiente/truffle.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Truffle 3 | --- -------------------------------------------------------------------------------- /src/ambiente/hardhat.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Hardhat 3 | --- 4 | -------------------------------------------------------------------------------- /src/ambiente/untitled.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Remix IDE 3 | --- -------------------------------------------------------------------------------- /src/es/ambiente/truffle.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Truffle 3 | --- -------------------------------------------------------------------------------- /src/es/exemplos/aplicacoes/README.md: -------------------------------------------------------------------------------- 1 | # Aplicações 2 | 3 | -------------------------------------------------------------------------------- /src/es/seguranca/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Seguridad 3 | --- -------------------------------------------------------------------------------- /src/exemplos/aplicacoes/README.md: -------------------------------------------------------------------------------- 1 | # Aplicações 2 | 3 | -------------------------------------------------------------------------------- /src/seguranca/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Segurança 3 | --- -------------------------------------------------------------------------------- /src/es/ambiente/hardhat.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Hardhat 3 | --- 4 | -------------------------------------------------------------------------------- /src/es/ambiente/untitled.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Remix IDE 3 | --- -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/README.md: -------------------------------------------------------------------------------- 1 | # Lenguaje (v0.8.3) 2 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/README.md: -------------------------------------------------------------------------------- 1 | # Linguagem (v0.8.3) 2 | 3 | -------------------------------------------------------------------------------- /src/.vuepress/styles/config.scss: -------------------------------------------------------------------------------- 1 | $code-dark-theme: dracula; 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /src/apostila/extra-avancado/24.-heranca.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 24. Herança 3 | --- -------------------------------------------------------------------------------- /src/apostila/extra-avancado/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Extra (avançado) 3 | --- -------------------------------------------------------------------------------- /src/es/evm-maquina-virtual-ethereum/accounts.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Cuentas 3 | --- -------------------------------------------------------------------------------- /src/evm-maquina-virtual-ethereum/accounts.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Accounts 3 | --- -------------------------------------------------------------------------------- /src/evm-maquina-virtual-ethereum/bytecodes.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Bytecodes 3 | --- -------------------------------------------------------------------------------- /src/evm-maquina-virtual-ethereum/op_codes.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: OP\_CODES 3 | --- -------------------------------------------------------------------------------- /src/es/apostila/extra-avancado/24.-heranca.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 24. Herencia 3 | --- -------------------------------------------------------------------------------- /src/es/apostila/extra-avancado/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Extras (Avanzado) 3 | --- -------------------------------------------------------------------------------- /src/es/evm-maquina-virtual-ethereum/bytecodes.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Bytecodes 3 | --- -------------------------------------------------------------------------------- /src/es/evm-maquina-virtual-ethereum/op_codes.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: OP\_CODES 3 | --- -------------------------------------------------------------------------------- /src/evm-maquina-virtual-ethereum/gas-taxas.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Gas (Taxas) 3 | --- -------------------------------------------------------------------------------- /src/evm-maquina-virtual-ethereum/transactions.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Transactions 3 | --- -------------------------------------------------------------------------------- /src/es/evm-maquina-virtual-ethereum/gas-taxas.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Gas (Tarifas) 3 | --- -------------------------------------------------------------------------------- /src/es/evm-maquina-virtual-ethereum/transactions.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Transacciones 3 | --- -------------------------------------------------------------------------------- /src/assets/x.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/x.png -------------------------------------------------------------------------------- /src/evm-maquina-virtual-ethereum/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: EVM Máquina Virtual Ethereum 3 | --- -------------------------------------------------------------------------------- /src/apostila/extra-avancado/19.-fallback-functions.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 21. Fallback functions 3 | --- -------------------------------------------------------------------------------- /src/assets/hero.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/hero.png -------------------------------------------------------------------------------- /src/es/evm-maquina-virtual-ethereum/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: EVM Máquina Virtual Ethereum 3 | --- -------------------------------------------------------------------------------- /src/assets/image.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image.png -------------------------------------------------------------------------------- /src/es/seguranca/vulnerabilidades-conhecidas/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Vulnerabilidades Conocidas 3 | --- -------------------------------------------------------------------------------- /src/seguranca/vulnerabilidades-conhecidas/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Vulnerabilidades Conhecidas 3 | --- -------------------------------------------------------------------------------- /src/apostila/14.-interagindo-com-outro-contrato.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 18. Interagindo com outro Contrato 3 | --- -------------------------------------------------------------------------------- /src/apostila/extra-avancado/21.-bibliotecas-librarys.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 23. Bibliotecas (libraries) 3 | --- -------------------------------------------------------------------------------- /src/assets/image(1).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(1).png -------------------------------------------------------------------------------- /src/assets/image(10).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(10).png -------------------------------------------------------------------------------- /src/assets/image(11).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(11).png -------------------------------------------------------------------------------- /src/assets/image(12).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(12).png -------------------------------------------------------------------------------- /src/assets/image(13).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(13).png -------------------------------------------------------------------------------- /src/assets/image(14).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(14).png -------------------------------------------------------------------------------- /src/assets/image(15).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(15).png -------------------------------------------------------------------------------- /src/assets/image(16).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(16).png -------------------------------------------------------------------------------- /src/assets/image(17).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(17).png -------------------------------------------------------------------------------- /src/assets/image(18).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(18).png -------------------------------------------------------------------------------- /src/assets/image(19).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(19).png -------------------------------------------------------------------------------- /src/assets/image(2).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(2).png -------------------------------------------------------------------------------- /src/assets/image(20).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(20).png -------------------------------------------------------------------------------- /src/assets/image(21).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(21).png -------------------------------------------------------------------------------- /src/assets/image(22).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(22).png -------------------------------------------------------------------------------- /src/assets/image(23).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(23).png -------------------------------------------------------------------------------- /src/assets/image(24).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(24).png -------------------------------------------------------------------------------- /src/assets/image(25).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(25).png -------------------------------------------------------------------------------- /src/assets/image(26).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(26).png -------------------------------------------------------------------------------- /src/assets/image(27).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(27).png -------------------------------------------------------------------------------- /src/assets/image(28).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(28).png -------------------------------------------------------------------------------- /src/assets/image(29).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(29).png -------------------------------------------------------------------------------- /src/assets/image(3).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(3).png -------------------------------------------------------------------------------- /src/assets/image(30).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(30).png -------------------------------------------------------------------------------- /src/assets/image(31).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(31).png -------------------------------------------------------------------------------- /src/assets/image(32).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(32).png -------------------------------------------------------------------------------- /src/assets/image(33).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(33).png -------------------------------------------------------------------------------- /src/assets/image(34).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(34).png -------------------------------------------------------------------------------- /src/assets/image(35).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(35).png -------------------------------------------------------------------------------- /src/assets/image(36).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(36).png -------------------------------------------------------------------------------- /src/assets/image(37).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(37).png -------------------------------------------------------------------------------- /src/assets/image(38).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(38).png -------------------------------------------------------------------------------- /src/assets/image(39).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(39).png -------------------------------------------------------------------------------- /src/assets/image(4).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(4).png -------------------------------------------------------------------------------- /src/assets/image(40).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(40).png -------------------------------------------------------------------------------- /src/assets/image(41).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(41).png -------------------------------------------------------------------------------- /src/assets/image(42).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(42).png -------------------------------------------------------------------------------- /src/assets/image(43).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(43).png -------------------------------------------------------------------------------- /src/assets/image(44).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(44).png -------------------------------------------------------------------------------- /src/assets/image(45).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(45).png -------------------------------------------------------------------------------- /src/assets/image(46).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(46).png -------------------------------------------------------------------------------- /src/assets/image(47).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(47).png -------------------------------------------------------------------------------- /src/assets/image(48).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(48).png -------------------------------------------------------------------------------- /src/assets/image(49).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(49).png -------------------------------------------------------------------------------- /src/assets/image(5).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(5).png -------------------------------------------------------------------------------- /src/assets/image(50).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(50).png -------------------------------------------------------------------------------- /src/assets/image(51).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(51).png -------------------------------------------------------------------------------- /src/assets/image(52).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(52).png -------------------------------------------------------------------------------- /src/assets/image(53).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(53).png -------------------------------------------------------------------------------- /src/assets/image(54).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(54).png -------------------------------------------------------------------------------- /src/assets/image(55).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(55).png -------------------------------------------------------------------------------- /src/assets/image(56).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(56).png -------------------------------------------------------------------------------- /src/assets/image(57).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(57).png -------------------------------------------------------------------------------- /src/assets/image(58).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(58).png -------------------------------------------------------------------------------- /src/assets/image(59).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(59).png -------------------------------------------------------------------------------- /src/assets/image(6).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(6).png -------------------------------------------------------------------------------- /src/assets/image(60).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(60).png -------------------------------------------------------------------------------- /src/assets/image(61).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(61).png -------------------------------------------------------------------------------- /src/assets/image(62).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(62).png -------------------------------------------------------------------------------- /src/assets/image(63).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(63).png -------------------------------------------------------------------------------- /src/assets/image(64).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(64).png -------------------------------------------------------------------------------- /src/assets/image(65).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(65).png -------------------------------------------------------------------------------- /src/assets/image(66).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(66).png -------------------------------------------------------------------------------- /src/assets/image(67).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(67).png -------------------------------------------------------------------------------- /src/assets/image(68).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(68).png -------------------------------------------------------------------------------- /src/assets/image(69).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(69).png -------------------------------------------------------------------------------- /src/assets/image(7).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(7).png -------------------------------------------------------------------------------- /src/assets/image(70).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(70).png -------------------------------------------------------------------------------- /src/assets/image(71).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(71).png -------------------------------------------------------------------------------- /src/assets/image(72).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(72).png -------------------------------------------------------------------------------- /src/assets/image(73).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(73).png -------------------------------------------------------------------------------- /src/assets/image(74).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(74).png -------------------------------------------------------------------------------- /src/assets/image(75).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(75).png -------------------------------------------------------------------------------- /src/assets/image(76).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(76).png -------------------------------------------------------------------------------- /src/assets/image(77).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(77).png -------------------------------------------------------------------------------- /src/assets/image(78).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(78).png -------------------------------------------------------------------------------- /src/assets/image(79).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(79).png -------------------------------------------------------------------------------- /src/assets/image(8).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(8).png -------------------------------------------------------------------------------- /src/assets/image(80).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(80).png -------------------------------------------------------------------------------- /src/assets/image(81).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(81).png -------------------------------------------------------------------------------- /src/assets/image(82).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(82).png -------------------------------------------------------------------------------- /src/assets/image(83).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(83).png -------------------------------------------------------------------------------- /src/assets/image(84).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(84).png -------------------------------------------------------------------------------- /src/assets/image(85).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(85).png -------------------------------------------------------------------------------- /src/assets/image(86).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(86).png -------------------------------------------------------------------------------- /src/assets/image(87).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(87).png -------------------------------------------------------------------------------- /src/assets/image(88).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(88).png -------------------------------------------------------------------------------- /src/assets/image(89).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(89).png -------------------------------------------------------------------------------- /src/assets/image(9).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(9).png -------------------------------------------------------------------------------- /src/assets/image(90).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(90).png -------------------------------------------------------------------------------- /src/assets/image(91).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(91).png -------------------------------------------------------------------------------- /src/assets/image(92).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(92).png -------------------------------------------------------------------------------- /src/assets/image(93).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(93).png -------------------------------------------------------------------------------- /src/assets/image(94).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(94).png -------------------------------------------------------------------------------- /src/assets/image(95).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(95).png -------------------------------------------------------------------------------- /src/assets/image(96).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(96).png -------------------------------------------------------------------------------- /src/assets/image(97).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(97).png -------------------------------------------------------------------------------- /src/assets/image(98).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(98).png -------------------------------------------------------------------------------- /src/assets/image(99).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(99).png -------------------------------------------------------------------------------- /src/es/apostila/extra-avancado/23.-bibliotecas-librarys.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 23. Bibliotecas (Libraries) 3 | --- -------------------------------------------------------------------------------- /src/assets/image(100).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(100).png -------------------------------------------------------------------------------- /src/assets/image(101).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(101).png -------------------------------------------------------------------------------- /src/assets/image(102).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(102).png -------------------------------------------------------------------------------- /src/assets/image(103).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(103).png -------------------------------------------------------------------------------- /src/assets/image(104).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(104).png -------------------------------------------------------------------------------- /src/assets/image(105).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(105).png -------------------------------------------------------------------------------- /src/assets/image(106).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(106).png -------------------------------------------------------------------------------- /src/assets/image(107).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(107).png -------------------------------------------------------------------------------- /src/assets/image(108).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(108).png -------------------------------------------------------------------------------- /src/assets/image(109).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(109).png -------------------------------------------------------------------------------- /src/assets/image(110).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(110).png -------------------------------------------------------------------------------- /src/assets/image(111).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(111).png -------------------------------------------------------------------------------- /src/assets/image(112).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(112).png -------------------------------------------------------------------------------- /src/assets/image(113).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(113).png -------------------------------------------------------------------------------- /src/assets/image(114).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(114).png -------------------------------------------------------------------------------- /src/assets/image(115).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(115).png -------------------------------------------------------------------------------- /src/assets/image(116).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(116).png -------------------------------------------------------------------------------- /src/assets/image(117).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(117).png -------------------------------------------------------------------------------- /src/assets/image(118).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(118).png -------------------------------------------------------------------------------- /src/assets/image(119).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(119).png -------------------------------------------------------------------------------- /src/assets/image(120).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(120).png -------------------------------------------------------------------------------- /src/assets/image(121).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(121).png -------------------------------------------------------------------------------- /src/assets/image(122).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(122).png -------------------------------------------------------------------------------- /src/assets/image(123).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(123).png -------------------------------------------------------------------------------- /src/assets/image(124).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(124).png -------------------------------------------------------------------------------- /src/assets/image(125).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(125).png -------------------------------------------------------------------------------- /src/assets/image(126).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(126).png -------------------------------------------------------------------------------- /src/es/apostila/18.-interagindo-com-outro-contrato.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 18. Interactuando con otro Contrato 3 | --- -------------------------------------------------------------------------------- /src/es/evm-maquina-virtual-ethereum/patterns-and-standards/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Patterns and Standards 3 | --- -------------------------------------------------------------------------------- /src/evm-maquina-virtual-ethereum/patterns-and-standards/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Patterns and Standards 3 | --- -------------------------------------------------------------------------------- /src/assets/image(40)(1).png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/w3b3d3v/gitbook-solidity/HEAD/src/assets/image(40)(1).png -------------------------------------------------------------------------------- /src/es/apostila/extra-avancado/21.-fallback-functions.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 21. Funciones de Respaldo (Fallback Functions) 3 | --- -------------------------------------------------------------------------------- /src/apostila/16.-criando-contratos-a-partir-de-um-contrato..md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 19. Criando contratos à partir de um contrato 3 | --- -------------------------------------------------------------------------------- /src/es/apostila/19.-criando-contratos-a-partir-de-um-contrato..md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 19. Creando contratos a partir de un contrato 3 | --- -------------------------------------------------------------------------------- /src/es/seguranca/vulnerabilidades-conhecidas/funcao-de-re-entrada-reetrancy.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Función de reingreso (Reetrancy) 3 | --- -------------------------------------------------------------------------------- /src/es/seguranca/vulnerabilidades-conhecidas/overflow-e-underflow-aritmetico.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Overflow y Underflow Aritmético 3 | --- -------------------------------------------------------------------------------- /src/seguranca/vulnerabilidades-conhecidas/funcao-de-re-entrada-reetrancy.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Função de re-entrada (Reetrancy) 3 | --- -------------------------------------------------------------------------------- /src/seguranca/vulnerabilidades-conhecidas/overflow-e-underflow-aritmetico.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Overflow e Underflow Aritmético 3 | --- -------------------------------------------------------------------------------- /src/apostila/17.-erros.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 20. Erros 3 | --- 4 | 5 | ## Revert() 6 | 7 | ![](<../assets/image(30).png>) 8 | 9 | ## Require() 10 | 11 | ![](<../assets/image(2).png>) 12 | 13 | ## Assert() 14 | 15 | ![](<../assets/image(68).png>) 16 | -------------------------------------------------------------------------------- /src/.vuepress/styles/palette.styl: -------------------------------------------------------------------------------- 1 | $accentColor = #0AE678 2 | $textColor = #2c3e50 3 | $borderColor = #eaecef 4 | $codeBgColor = #282c34 5 | $arrowBgColor = #ccc 6 | $badgeTipColor = #42b983 7 | $badgeWarningColor = darken(#ffe564, 35%) 8 | $badgeErrorColor = #DA5961 9 | -------------------------------------------------------------------------------- /src/apostila/extra-avancado/20.-assembly.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 22. Assembly 3 | --- 4 | 5 | ## Verificar tipos de endereço 6 | 7 | ![](<../../assets/image(125).png>) 8 | 9 | ## Economizando Gas 10 | 11 | ![](<../../assets/image(66).png>) 12 | 13 | ![](<../../assets/image(53).png>) 14 | 15 | ![](<../../assets/image(1).png>) 16 | 17 | ![](<../../assets/image(13).png>) 18 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/ola-mundo.md: -------------------------------------------------------------------------------- 1 | # Olá Mundo 2 | 3 | `pragma` especifica a versão do compilador do Solidity. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | // a versão do compilador deve ser maior que ou igual a 0.8.3 e menor que 0.9.0 8 | pragma solidity ^0.8.3; 9 | 10 | contract OlaMundo { 11 | string public greet = "Olá Mundo!"; 12 | } 13 | ``` 14 | 15 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/ola-mundo.md: -------------------------------------------------------------------------------- 1 | # Hola Mundo 2 | 3 | `pragma` especifica la versión del compilador de Solidity. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | // la versión del compilador debe ser mayor que o igual a 0.8.3 y menor que 0.9.0 8 | pragma solidity ^0.8.3; 9 | 10 | contract HolaMundo { 11 | string public greet = "Hola Mundo!"; 12 | } 13 | ``` 14 | 15 | -------------------------------------------------------------------------------- /src/es/apostila/20.-erros.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 20. Errores 3 | --- 4 | 5 | ## Revert() 6 | 7 | ```solidity 8 | revert("Aquí explica por qué se revirtió. Mensaje de error.") 9 | ``` 10 | 11 | ## Require() 12 | 13 | ```solidity 14 | require(a != 10, 'Mensaje de error aquí'); 15 | 16 | //Verificar condiciones indeseables (entradas incorrectas por el usuario, por ejemplo.) 17 | ``` 18 | 19 | ## Assert() 20 | 21 | ```solidity 22 | assert(a != 10); 23 | 24 | //Assert sirve para errores que nunca deben suceder. 25 | ``` -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/constantes.md: -------------------------------------------------------------------------------- 1 | # Constantes 2 | 3 | Constantes são variáveis que não podem ser modificadas. 4 | 5 | Seu valor é codificado e o uso de constantes pode economizar no custo de gás. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract Constants { 12 | // convenção de codificação de letras maiúsculas para constantes 13 | address public constant MY_ADDRESS = 0x777788889999AaAAbBbbCcccddDdeeeEfFFfCcCc; 14 | uint public constant MY_UINT = 123; 15 | } 16 | ``` 17 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/ether-e-wei.md: -------------------------------------------------------------------------------- 1 | # Ether e Wei 2 | 3 | Transações são pagas com `ether`. 4 | 5 | Da mesma forma que um dólar equivale a 100 cents, um `ether` equivale a 10^18 `wei`. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract EtherUnits { 12 | uint public oneWei = 1 wei; 13 | // 1 wei é igual a 1 14 | bool public isOneWei = 1 wei == 1; 15 | 16 | uint public oneEther = 1 ether; 17 | // 1 ether é igual a 10^18 wei 18 | bool public isOneEther = 1 ether == 1e18; 19 | } 20 | ``` 21 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/constantes.md: -------------------------------------------------------------------------------- 1 | # Constantes 2 | 3 | Constantes son variables que no pueden ser modificadas. 4 | 5 | Su valor es escrito en el código (hardcoded) y el uso de constantes puede ahorrar costo de gas. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract Constants { 12 | // las constantes se escriben en mayúscula por convención de codificación 13 | address public constant MY_ADDRESS = 0x777788889999AaAAbBbbCcccddDdeeeEfFFfCcCc; 14 | uint public constant MY_UINT = 123; 15 | } 16 | ``` 17 | -------------------------------------------------------------------------------- /src/es/exemplos/README.md: -------------------------------------------------------------------------------- 1 | # Introducción 2 | 3 | Este contenido fue traducido directamente del website [https://solidity-by-example.org/](https://solidity-by-example.org) 4 | 5 | _Solidity By Example_ fue creado por [Smart Contract Engineer](https://www.smartcontract.engineer) 6 | 7 | Comunidad: 8 | 9 | * [Discord](https://discord.gg/bt8FK2wkcW) 10 | * [Telegram](https://t.me/smartcontractprogrammer) 11 | * [YouTube](https://www.youtube.com/channel/UCJWh7F3AFyQ\_x01VKzr9eyA) 12 | 13 | E-mail de contacto: [contact@solidity-by-example.org](https://maito:contact@solidity-by-example.org) 14 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/ether-e-wei.md: -------------------------------------------------------------------------------- 1 | # Ether y Wei 2 | 3 | Las transacciones se pagan con `ether`. 4 | 5 | De la misma forma que un dólar equivale a 100 centavos, un (1) `ether` equivale a 10^18 `wei`. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract EtherUnits { 12 | uint public oneWei = 1 wei; 13 | // 1 wei es igual a 1 14 | bool public isOneWei = 1 wei == 1; 15 | 16 | uint public oneEther = 1 ether; 17 | // 1 ether es igual a 10^18 wei 18 | bool public isOneEther = 1 ether == 1e18; 19 | } 20 | ``` 21 | -------------------------------------------------------------------------------- /src/exemplos/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Introdução 3 | --- 4 | 5 | Este conteúdo foi traduzido diretamente do website [https://solidity-by-example.org/](https://solidity-by-example.org) 6 | 7 | _Solidity By Example_ foi criado por [Smart Contract Engineer](https://www.smartcontract.engineer) 8 | 9 | Comunidade: 10 | 11 | * [Discord](https://discord.gg/bt8FK2wkcW) 12 | * [Telegram](https://t.me/smartcontractprogrammer) 13 | * [YouTube](https://www.youtube.com/channel/UCJWh7F3AFyQ\_x01VKzr9eyA) 14 | 15 | E-mail de contato: [contact@solidity-by-example.org](https://maito:contact@solidity-by-example.org) 16 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/imutaveis.md: -------------------------------------------------------------------------------- 1 | # Imutáveis 2 | 3 | Variáveis imutáveis são como as constantes. Os valores dessas variáveis podem ser definidos dentro do construtor mas não podem ser modificados depois. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract Immutable { 10 | // convenção de codificação de letras maiúsculas para variáveis imutáveis 11 | address public immutable MY_ADDRESS; 12 | uint public immutable MY_UINT; 13 | 14 | constructor(uint _myUint) { 15 | MY_ADDRESS = msg.sender; 16 | MY_UINT = _myUint; 17 | } 18 | } 19 | ``` 20 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/imutaveis.md: -------------------------------------------------------------------------------- 1 | # Inmutables 2 | 3 | Variables inmutables son como las constantes. Los valores de esas variables pueden ser definidos dentro del constructor pero no pueden ser modificados después. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract Immutable { 10 | // las variables inmutables se escriben en mayúscula por convención de codificación 11 | address public immutable MY_ADDRESS; 12 | uint public immutable MY_UINT; 13 | 14 | constructor(uint _myUint) { 15 | MY_ADDRESS = msg.sender; 16 | MY_UINT = _myUint; 17 | } 18 | } 19 | ``` 20 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "gitbook-solidity", 3 | "version": "1.0.0", 4 | "description": "Solidity Docs", 5 | "main": "index.js", 6 | "repository": "https://github.com/w3b3d3v/gitbook-solidity.git", 7 | "author": "WEB3DEV Team", 8 | "license": "MIT", 9 | "devDependencies": { 10 | "@dovyp/vuepress-plugin-clipboard-copy": "^1.0.0-alpha.7", 11 | "@vuepress/plugin-google-analytics": "^1.9.7", 12 | "vuepress": "^1.9.7", 13 | "vuepress-theme-reco": "^1.6.6" 14 | }, 15 | "scripts": { 16 | "dev": "vuepress dev src", 17 | "build": "vuepress build src", 18 | "build:gh_pages": "BASE_PATH=/gitbook-solidity/ vuepress build src" 19 | } 20 | } 21 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/primeira-aplicacao.md: -------------------------------------------------------------------------------- 1 | # Primeira Aplicação 2 | 3 | Aqui está um exemplo simples de contrato no qual você pode obter, incrementar e decrementar um contador. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract Counter { 10 | uint public count; 11 | 12 | // Função para obter a conta atual 13 | function get() public view returns (uint) { 14 | return count; 15 | } 16 | 17 | // Função para incrementar 1 à conta 18 | function inc() public { 19 | count += 1; 20 | } 21 | 22 | // Função para decrementar a conta de 1 23 | function dec() public { 24 | count -= 1; 25 | } 26 | } 27 | ``` 28 | -------------------------------------------------------------------------------- /src/apostila/15.-constructor.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 16. Constructor 3 | --- 4 | ::: tip 5 | Constructors são trechos de códigos que serão executados somente uma vez 6 | quando o contrato está sendo implementado. 7 | ::: 8 | 9 | ## Declarando Constructor 10 | 11 | É muito comum definir variáveis que não serão alteradas, tais como o Supply de um token ou o administrador de um contrato. É muito comum que a inicialização de todas as variáveis seja feita dentro do constructor. 12 | 13 | ![](<../assets/image(40)(1).png>) 14 | 15 | ## Argumentos de Herança 16 | 17 | A sintaxe na imagem abaixo descreve a situação onde é criado um contrato que é extensão de outro e ambos tenham constructors. 18 | 19 | ![](<../assets/image(124).png>) 20 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/primeira-aplicacao.md: -------------------------------------------------------------------------------- 1 | # Primera Aplicación 2 | 3 | Aquí está un ejemplo simple de contrato en el cual puedes obtener, aumentar y disminuir el valor de un contador. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract Counter { 10 | uint public count; 11 | 12 | // Función que obtiene el valor actual del contador 13 | function get() public view returns (uint) { 14 | return count; 15 | } 16 | 17 | // Función que aumenta en 1 el contador 18 | function inc() public { 19 | count += 1; 20 | } 21 | 22 | // Función que disminuye en 1 el contador 23 | function dec() public { 24 | count -= 1; 25 | } 26 | } 27 | ``` 28 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/funcoes-view-e-pure.md: -------------------------------------------------------------------------------- 1 | # Funciones View y Pure 2 | 3 | Funciones Getter pueden ser declaradas`view` o `pure`. 4 | 5 | Función `View` declara que no se cambiará ningún estado. 6 | 7 | Función `Pure` declara que ninguna variable de estado será cambiada o leida. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract ViewAndPure { 14 | uint public x = 1; 15 | 16 | // Promete que no modifica el estado. 17 | function addToX(uint y) public view returns (uint) { 18 | return x + y; 19 | } 20 | 21 | // Promete que no modifica o lee desde un estado. 22 | function add(uint i, uint j) public pure returns (uint) { 23 | return i + j; 24 | } 25 | } 26 | ``` -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/funcoes-view-e-pure.md: -------------------------------------------------------------------------------- 1 | # Funções View e Pure 2 | 3 | Funções Getter podem ser declaradas`view` or `pure`. 4 | 5 | Função `View` declara que nenhum estado será mudado. 6 | 7 | Função `Pure` declara que nenhuma variável de estado será mudada ou lida. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract ViewAndPure { 14 | uint public x = 1; 15 | 16 | // Promete que não haja modificação do estado. 17 | function addToX(uint y) public view returns (uint) { 18 | return x + y; 19 | } 20 | 21 | // Promete não haja modificação ou leitura de um estado. 22 | function add(uint i, uint j) public pure returns (uint) { 23 | return i + j; 24 | } 25 | } 26 | ``` 27 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/eventos.md: -------------------------------------------------------------------------------- 1 | # Eventos 2 | 3 | `Events` permite logar o blockchain do Ethereumn. Alguns casos de uso de eventos são: 4 | 5 | * Monitorar os eventos e atualizar a interface do usuário 6 | * Uma forma econômica de armazenamento 7 | 8 | ```solidity 9 | // SPDX-License-Identifier: MIT 10 | pragma solidity ^0.8.3; 11 | 12 | contract Event { 13 | // Declaração do evento 14 | // Podem ser indexados até 3 parâmetros. 15 | // Parâmetros indexados ajudam a filtrar os logs 16 | event Log(address indexed sender, string message); 17 | event AnotherLog(); 18 | 19 | function test() public { 20 | emit Log(msg.sender, "Hello World!"); 21 | emit Log(msg.sender, "Hello EVM!"); 22 | emit AnotherLog(); 23 | } 24 | } 25 | ``` 26 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/if-else.md: -------------------------------------------------------------------------------- 1 | # If/Else 2 | 3 | Solidity suporta estruturas condicionais `if`, `else if` and `else`. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract IfElse { 10 | function foo(uint x) public pure returns (uint) { 11 | if (x < 10) { 12 | return 0; 13 | } else if (x < 20) { 14 | return 1; 15 | } else { 16 | return 2; 17 | } 18 | } 19 | 20 | function ternary(uint _x) public pure returns (uint) { 21 | // if (_x < 10) { 22 | // retorna 1; 23 | // } 24 | // retorna 2; 25 | 26 | // forma abreviada de escrever a instrução if / else 27 | return _x < 10 ? 1 : 2; 28 | } 29 | } 30 | ``` 31 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/eventos.md: -------------------------------------------------------------------------------- 1 | # Eventos 2 | 3 | `Events` permite registrar (logging) en el blockchain de Ethereum. Algunos casos de uso de eventos son: 4 | 5 | * Escuchar los eventos y actualizar la interfaz de usuario 6 | * Una forma barata de almacenamiento 7 | 8 | ```solidity 9 | // SPDX-License-Identifier: MIT 10 | pragma solidity ^0.8.3; 11 | 12 | contract Event { 13 | // Declaración del evento 14 | // Pueden ser indexados hasta 3 parámetros. 15 | // Parámetros indexados ayudan a filtrar los logs 16 | event Log(address indexed sender, string message); 17 | event AnotherLog(); 18 | 19 | function test() public { 20 | emit Log(msg.sender, "Hello World!"); 21 | emit Log(msg.sender, "Hello EVM!"); 22 | emit AnotherLog(); 23 | } 24 | } 25 | ``` -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/chamando-outro-contrato.md: -------------------------------------------------------------------------------- 1 | # Chamando outro Contrato 2 | 3 | Um contrato pode chamar outros contratos de 2 formas. 4 | 5 | A maneira mais fácil é apenas chamá-lo, como `A.foo(x, y, z)`. 6 | 7 | Outra maneira de chamar outros contratos é usar chamada de nível baixo. 8 | 9 | Esse método não é recomendado. 10 | 11 | ```solidity 12 | // SPDX-License-Identifier: MIT 13 | pragma solidity ^0.8.3; 14 | 15 | contract Callee { 16 | uint public x; 17 | uint public value; 18 | 19 | function setX(uint _x) public returns (uint) { 20 | x = _x; 21 | return x; 22 | } 23 | 24 | function setXandSendEther(uint _x) public payable returns (uint, uint) { 25 | x = _x; 26 | value = msg.value; 27 | 28 | return (x, value); 29 | } 30 | } 31 | ``` 32 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/if-else.md: -------------------------------------------------------------------------------- 1 | # If / Else 2 | 3 | Solidity soporta estructuras condicionales `if`, `else if` y `else`. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract IfElse { 10 | function foo(uint x) public pure returns (uint) { 11 | if (x < 10) { 12 | return 0; 13 | } else if (x < 20) { 14 | return 1; 15 | } else { 16 | return 2; 17 | } 18 | } 19 | 20 | function ternary(uint _x) public pure returns (uint) { 21 | // if (_x < 10) { 22 | // return 1; 23 | // } 24 | // return 2; 25 | 26 | // forma abreviada de escribir la sentencia if / else 27 | // el operador "?" es llamado operador ternario 28 | return _x < 10 ? 1 : 2; 29 | } 30 | } 31 | ``` 32 | -------------------------------------------------------------------------------- /src/es/apostila/extra-avancado/22.-assembly.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 22. Assembly 3 | --- 4 | 5 | ## Verificar los tipos de direcciones. 6 | 7 | ```solidity 8 | assembly { 9 | size := extcodesize(dirección_wallet_o_contrato) 10 | } 11 | 12 | if (size > 0) { 13 | result = "Dirección del Smart Contract"; 14 | } else { 15 | result = "Dirección de la Wallet"; 16 | } 17 | ``` 18 | 19 | ## Ahorrando Gas 20 | 21 | ```solidity 22 | function sumaAssembly(uint x, uint y) public pure returns(uint) { 23 | assembly { 24 | let resultado := add(x,y) 25 | mstore(0x0, resultado) 26 | return(0x0); 27 | } 28 | } 29 | ``` 30 | 31 | ![](<../../../assets/image(53).png>) 32 | 33 | 34 | ```solidity 35 | function sumaAssembly(uint x, uint y) public pure returns(uint) { 36 | return x + y; 37 | } 38 | ``` 39 | 40 | ![](<../../../assets/image(13).png>) -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/lendo-e-escrevendo-para-uma-variavel-de-estado.md: -------------------------------------------------------------------------------- 1 | # Leyendo y escribiendo Variables de Estado 2 | 3 | Para escribir o actualizar una variable de estado necesitas enviar una transacción. 4 | 5 | Por otro lado, puedes leer las variables de estado, gratuitamente, sin ninguna tasa de transacción. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract SimpleStorage { 12 | // Variable de estado que almacena un número 13 | uint public num; 14 | 15 | // Necesitas enviar una transacción para escribir en una variable de estado. 16 | function set(uint _num) public { 17 | num = _num; 18 | } 19 | 20 | // Puedes leer una variable de estado sin enviar una transacción. 21 | function get() public view returns (uint) { 22 | return num; 23 | } 24 | } 25 | ``` 26 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/lendo-e-escrevendo-para-uma-variavel-de-estado.md: -------------------------------------------------------------------------------- 1 | # Lendo e Escrevendo para uma Variável de Estado 2 | 3 | Para escrever ou atualizar uma variável de estado é necessário enviar uma transação. 4 | 5 | Por outro lado, podem-se ler variáveis de estado, gratuitamente, sem nenhuma taxa de transação. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract SimpleStorage { 12 | // Variável de estado para armazenar um número 13 | uint public num; 14 | 15 | // É necessário enviar uma transação para escrever para uma variável de estado. 16 | function set(uint _num) public { 17 | num = _num; 18 | } 19 | 20 | // Você pode ler de uma váriável de estado sem enviar uma transação. 21 | function get() public view returns (uint) { 22 | return num; 23 | } 24 | } 25 | ``` 26 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/for-e-while-loop.md: -------------------------------------------------------------------------------- 1 | # For e While Loop 2 | 3 | Solidity suporta `for`, `while e` `do while` loops. 4 | 5 | Não escreva loops sem limites, já que isso pode levar ao limite do gás, causando falha na transação. 6 | 7 | Pela razão acima, `while` e `do while` loops são raramente usados. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract Loop { 14 | function loop() public { 15 | // for loop 16 | for (uint i = 0; i < 10; i++) { 17 | if (i == 3) { 18 | // Pule para a próxima iteração com continue 19 | continue; 20 | } 21 | if (i == 5) { 22 | // Saia do loop com break 23 | break; 24 | } 25 | } 26 | 27 | // while loop 28 | uint j; 29 | while (j < 10) { 30 | j++; 31 | } 32 | } 33 | } 34 | ``` 35 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/variaveis.md: -------------------------------------------------------------------------------- 1 | # Variables 2 | 3 | Existen 3 tipos de variables en Solidity 4 | 5 | * **local** 6 | * declarada dentro de una función 7 | * no se almacena en el blockchain 8 | * **de estado** 9 | * declarada afuera de una función 10 | * se almacena en el blockchain 11 | * **global** (proporciona información sobre el blockchain) 12 | 13 | ```solidity 14 | // SPDX-License-Identifier: MIT 15 | pragma solidity ^0.8.3; 16 | 17 | contract Variables { 18 | // Variables de estado son almacenadas en el blockchain. 19 | string public text = "Hello"; 20 | uint public num = 123; 21 | 22 | function doSomething() public { 23 | // Variables locales no quedan guardadas en el blockchain. 24 | uint i = 456; 25 | 26 | // Aquí están algunas variables globales 27 | uint timestamp = block.timestamp; // Marca de tiempo del bloque actual 28 | address sender = msg.sender; // Dirección del remitente 29 | } 30 | } 31 | ``` 32 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/for-e-while-loop.md: -------------------------------------------------------------------------------- 1 | # For y While Loop 2 | 3 | Solidity soporta `for`, `while` y `do while` loops. 4 | 5 | No escriba loops sin límites, ya que eso puede llevar al límite de gas, causando que la transacción falle. 6 | 7 | Por la razón mencionada previamente, `while` y `do while` loops son raramente usados. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract Loop { 14 | function loop() public { 15 | // for loop 16 | for (uint i = 0; i < 10; i++) { 17 | if (i == 3) { 18 | // Salta a la siguiente iteración con continue 19 | continue; 20 | } 21 | if (i == 5) { 22 | // Sale del loop con break 23 | break; 24 | } 25 | } 26 | 27 | // while loop 28 | uint j; 29 | while (j < 10) { 30 | j++; 31 | } 32 | } 33 | } 34 | ``` 35 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/variaveis.md: -------------------------------------------------------------------------------- 1 | # Variáveis 2 | 3 | Existem 3 tipos de variáveis no Solidity 4 | 5 | * **local** 6 | * declarada dentro de uma função 7 | * não armazenada no blockchain 8 | * **de estado** 9 | * declarada fora de uma função 10 | * armazenada no blockchain 11 | * **global** (fornece informação sobre o blockchain) 12 | 13 | ```solidity 14 | // SPDX-License-Identifier: MIT 15 | pragma solidity ^0.8.3; 16 | 17 | contract Variables { 18 | // Variáveis de estado são armazenadas no blockchain. 19 | string public text = "Hello"; 20 | uint public num = 123; 21 | 22 | function doSomething() public { 23 | // Variáveis locais não ficam salvas para o blockchain. 24 | uint i = 456; 25 | 26 | // Aqui estão algumas variáveis globais 27 | uint timestamp = block.timestamp; // Registro da hora do 28 | bloco atual 29 | address sender = msg.sender; // endereço do remetente 30 | } 31 | } 32 | ``` 33 | -------------------------------------------------------------------------------- /src/apostila/visibilidade-de-variaveis-external-public-internal-and-private.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 6. Visibilidade de Variáveis (public, internal & private) 3 | --- 4 | ::: tip 5 | Muito semelhantes às funções com exceção de "External" que se aplicam somente a funções. 6 | ::: 7 | 8 | ## Public 9 | 10 | Variável sem nenhuma restrição de visibilidade. 11 | 12 | ![](<../assets/image(36).png>) 13 | 14 | ## Internal 15 | 16 | Acessível para funções dentro do contrato e também para contratos derivados do qual contém essa variável. 17 | 18 | ![](<../assets/image(9).png>) 19 | 20 | ## Private 21 | 22 | Dados guardados nesse tipo de variável estão acessíveis somente para o contrato em qual ela foi escrita. 23 | 24 | ![](<../assets/image(72).png>) 25 | 26 | Observação importante: Blockchains são públicas então não guarde senhas ou coisas importantes dentro de variáveis pois mineradores e pesquisadores com o conhecimento certo conseguem montar Bytecodes e ver dados em variáveis e funções _**privadas**_. 27 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/sombreamento-de-variaveis-de-estado-herdadas.md: -------------------------------------------------------------------------------- 1 | # Sombreamento de Variáveis de Estado Herdadas 2 | 3 | Ao contrário das funções, as variáveis de estado não podem ser substituídas por redeclaração no contrato de classe filho. 4 | 5 | Vamos aprender como substituir corretamente variáveis de estado herdadas. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract A { 12 | string public name = "Contract A"; 13 | 14 | function getName() public view returns (string memory) { 15 | return name; 16 | } 17 | } 18 | 19 | // Sombreamento não é permitido no Solidity 0.6 20 | // Isto não vai compilar 21 | // contrato B é A { 22 | // string public name = "Contract B"; 23 | // } 24 | 25 | contract C is A { 26 | // Esta é a forma correta de substituir variáveis de estado herdadas. 27 | constructor() { 28 | name = "Contract C"; 29 | } 30 | 31 | // C.getName retorna "Contract C" 32 | } 33 | ``` 34 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/sombreamento-de-variaveis-de-estado-herdadas.md: -------------------------------------------------------------------------------- 1 | # Sombreado de Variables de Estado Heredados 2 | 3 | Al contrario de las funciones, las variables de estado no pueden sobreescribirse por redeclaración en el contrato hijo. 4 | 5 | Vamos a aprender como sobreescribir correctamente las variables de estado heredadas. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract A { 12 | string public name = "Contract A"; 13 | 14 | function getName() public view returns (string memory) { 15 | return name; 16 | } 17 | } 18 | 19 | // Sombreado no está permitido en Solidity 0.6 20 | // Esto no compilará 21 | // contract B is A { 22 | // string public name = "Contract B"; 23 | // } 24 | 25 | contract C is A { 26 | // Esta es la forma correcta de sobreescribir las variables de estado heredadas. 27 | constructor() { 28 | name = "Contract C"; 29 | } 30 | 31 | // C.getName devuelve "Contract C" 32 | } 33 | ``` -------------------------------------------------------------------------------- /src/es/apostila/16.-constructor.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 16. Constructor 3 | --- 4 | ::: tip 5 | Los constructores son fragmentos de código que se ejecutarán solo una vez 6 | cuando el contrato esté siendo implementado. 7 | ::: 8 | 9 | ## Declarando un Constructor 10 | 11 | Es muy común definir variables que no serán alteradas, como el Supply de un token o el administrador de un contrato. Es muy común que la inicialización de todas las variables se realice dentro del constructor. 12 | 13 | ```solidity 14 | address admin; 15 | 16 | constructor(uint _a) public { 17 | a = _a: //Inicialización de variables 18 | admin = msg.sender; 19 | } 20 | ``` 21 | 22 | ## Argumentos de Herencia 23 | 24 | La sintaxis del siguiente código describe la situación en la que se crea un contrato que es una extensión de otro y ambos tienen constructores. 25 | 26 | ```solidity 27 | contract ContratoPadre { 28 | constructor (uint a) internal { 29 | //... 30 | } 31 | } 32 | 33 | contract ContratoHijo is ContratoPadre { 34 | constructor (uint _a) ContratePadre(_a) public { 35 | //... 36 | } 37 | } 38 | ``` 39 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/seletor-de-funcao.md: -------------------------------------------------------------------------------- 1 | # Seletor de Função 2 | 3 | Quando uma função é chamada, os 4 primeiros bytes da `calldata` especifica qual função chamar. 4 | 5 | Esses 4 bytes são chamados seletor de função. 6 | 7 | Pegue como exemplo, este código abaixo. Ele usa `call` para executar `transfer` num contrato de endereço `addr`. 8 | 9 | ```solidity 10 | addr.call(abi.encodeWithSignature("transfer(address,uint256)", 0xSomeAddress, 123))solid 11 | ``` 12 | 13 | Os primeiros 4 bytes retornados de `abi.encodeWithSignature(....)` é o seletor de função. 14 | 15 | Talvez você possa salvar uma pequena quantidade de gás se você computar e colocar o seletor da função inline no seu código? 16 | 17 | Aqui está como o seletor de função é computado. 18 | 19 | ```solidity 20 | // SPDX-License-Identifier: MIT 21 | pragma solidity ^0.8.3; 22 | 23 | contract FunctionSelector { 24 | /* 25 | "transfer(address,uint256)" 26 | 0xa9059cbb 27 | "transferFrom(address,address,uint256)" 28 | 0x23b872dd 29 | */ 30 | function getSelector(string calldata _func) external pure returns (bytes4) { 31 | return bytes4(keccak256(bytes(_func))); 32 | } 33 | } 34 | ``` 35 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/seletor-de-funcao.md: -------------------------------------------------------------------------------- 1 | # Selector de función 2 | 3 | Cuando una función es llamada, los primeros 4 bytes del `calldata` especifican a cuál función invocar. 4 | 5 | Estos 4 bytes son llamados selector de función. 6 | 7 | Toma por ejemplo, el código de abajo. Usa `call` para ejecutar `transfer` en un contrato de la dirección `addr`. 8 | 9 | ```solidity 10 | addr.call(abi.encodeWithSignature("transfer(address,uint256)", 0xSomeAddress, 123))solid 11 | ``` 12 | 13 | Los primeros 4 bytes que regresaron de `abi.encodeWithSignature(....)` es la función de selector. 14 | 15 | ¿Puede que quizá salves una pequeña cantidad de gas si pre computado y colocas la función de selector en el código? 16 | 17 | Aquí está cómo la función del selector es computado. 18 | 19 | ```solidity 20 | // SPDX-License-Identifier: MIT 21 | pragma solidity ^0.8.3; 22 | 23 | contract FunctionSelector { 24 | /* 25 | "transfer(address,uint256)" 26 | 0xa9059cbb 27 | "transferFrom(address,address,uint256)" 28 | 0x23b872dd 29 | */ 30 | function getSelector(string calldata _func) external pure returns (bytes4) { 31 | return bytes4(keccak256(bytes(_func))); 32 | } 33 | } 34 | ``` 35 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/delegatecall.md: -------------------------------------------------------------------------------- 1 | # Delegatecall 2 | 3 | `delegatecall` é uma função de baixo nível semelhante a `call`. 4 | 5 | Quando o contrato `A` executa `delegatecall` para contratar `B`, o código de B é executado 6 | 7 | com armazenamento do contrato A, `msg.sender` e `msg.value`. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | // NOTA: Primeiro implemente este contrato 14 | contract B { 15 | // NOTA: o layout de armazenamento deve ser o mesmo do contrato A 16 | uint public num; 17 | address public sender; 18 | uint public value; 19 | 20 | function setVars(uint _num) public payable { 21 | num = _num; 22 | sender = msg.sender; 23 | value = msg.value; 24 | } 25 | } 26 | 27 | contract A { 28 | uint public num; 29 | address public sender; 30 | uint public value; 31 | 32 | function setVars(address _contract, uint _num) public payable { 33 | // O armazenamento de A é definido, B não é modificado. 34 | (bool success, bytes memory data) = _contract.delegatecall( 35 | abi.encodeWithSignature("setVars(uint256)", _num) 36 | ); 37 | } 38 | } 39 | ``` 40 | -------------------------------------------------------------------------------- /src/es/apostila/6.-visibilidade-de-variaveis-external-public-internal-and-private.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 6. Visibilidad de Variables (public, internal & private) 3 | --- 4 | ::: tip 5 | Muy similar a las funciones con la excepción de "External" que solo se aplica 6 | a las funciones. 7 | ::: 8 | 9 | ## Public 10 | 11 | Variable sin restricciones de visibilidad. 12 | 13 | ```solidity 14 | address public cartera = "0xCf48d9ae072758c125804791Cf8c4D390B460c19"; 15 | ``` 16 | 17 | ## Internal 18 | 19 | Accesible para funciones dentro del contrato y también para contratos derivados que contengan esta variable. 20 | 21 | ```solidity 22 | address internal cartera = "0xCf48d9ae072758c125804791Cf8c4D390B460c19"; 23 | ``` 24 | 25 | ## Private 26 | 27 | Los datos almacenados en este tipo de variable son accesibles solo para el contrato en el que se escribieron. 28 | 29 | ```solidity 30 | address private cartera = "0xCf48d9ae072758c125804791Cf8c4D390B460c19"; 31 | ``` 32 | 33 | Nota importante: las cadenas de bloques son públicas, así que no almacene contraseñas ni cosas importantes dentro de las variables, ya que los mineros e investigadores con los conocimientos adecuados pueden ensamblar Bytecodes y ver datos en variables y funciones _**privadas**_. -------------------------------------------------------------------------------- /src/apostila/14.-eventos.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 14. Eventos 3 | --- 4 | ::: tip 5 | Blockchains são sistemas isolados do resto da internet e sistemas 6 | convencionais e eventos são utilizados para "comunicar ao mundo" o que está 7 | acontecendo. 8 | ::: 9 | 10 | ## Declarando o Evento 11 | 12 | Possuem uma estrutura básica e padrão para que outros sistemas possam "falar todos a mesma lingua" e resumem-se à: quando, onde, quem e oque aconteceu. Para isso usamos a palavra chave _**event**_ antes do _**nomeDoEvento**_ e entre parênteses os seus **argumentos obrigatórios**. 13 | 14 | O parâmetro _indexed_ permite que outros sistemas possam aplicar filtros, no exemplo abaixo um sistema que estiver _ouvindo_ esses eventos poderá filtrar por data, endereço de envio e recebimento. 15 | 16 | ![](<../assets/image(120).png>) 17 | 18 | ## Emitindo o Evento 19 | 20 | Após declaramos um evento podemos emiti-lo dentro de qualquer função através do parâmetro _**emit nomeDoEvento()**_ e então passamos os argumentos que são necessários. 21 | 22 | ![](<../assets/image(118).png>) 23 | 24 | ## Exemplo real: Transação 25 | 26 | No exemplo abaixo um evento será emitido contendo _quem enviou_, _para quem enviou_ e _quanto enviou_. 27 | 28 | ![](<../assets/image(57).png>) 29 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/delegatecall.md: -------------------------------------------------------------------------------- 1 | # Delegatecall 2 | 3 | `delegatecall` es una función de bajo nivel, similar a `call`. 4 | 5 | Cuando el contrato `A` ejecuta `delegatecall` para contratar a `B`, el código de `B` es ejecutado 6 | 7 | con el almacenamiento (storage) del contrato A, `msg.sender` y `msg.value`. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | // NOTA: Despliega este contrato en primer lugar 14 | contract B { 15 | // NOTA: el layout del almacenamiento debe ser el mismo como el del contrato A 16 | uint public num; 17 | address public sender; 18 | uint public value; 19 | 20 | function setVars(uint _num) public payable { 21 | num = _num; 22 | sender = msg.sender; 23 | value = msg.value; 24 | } 25 | } 26 | 27 | contract A { 28 | uint public num; 29 | address public sender; 30 | uint public value; 31 | 32 | function setVars(address _contract, uint _num) public payable { 33 | // El almacenamiento de A es establecido, B no se modificó. 34 | (bool success, bytes memory data) = _contract.delegatecall( 35 | abi.encodeWithSignature("setVars(uint256)", _num) 36 | ); 37 | } 38 | } 39 | ``` 40 | -------------------------------------------------------------------------------- /src/apostila/visibilidade-de-funcoes-external-public-internal-and-private.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 5. Visibilidade de Funções (external, public, internal & private) 3 | --- 4 | ::: tip 5 | As funções e/ou variáveis de um contrato podem estar sujeitas a quatro 6 | parâmetros de visibilidade. 7 | ::: 8 | 9 | ## External 10 | 11 | Essa função estará acessível somente de fora do contrato, ele próprio não conseguirá chamá-la. 12 | 13 | ![](<../assets/image(39).png>) 14 | 15 | ## Internal 16 | 17 | Funções com esse parâmetro estão acessíveis somente no próprio contrato que a contêm e contratos que forem "_**filhos**_" desse, ou seja contatos que herdam suas funções e variáveis. Para entender melhor sobre herança veja a sessão [24.-heranca.md](extra-avancado/24.-heranca.md "mention") 18 | 19 | ![](<../assets/image(102).png>) 20 | 21 | ## Public 22 | 23 | Essa função estará acessível de todas as formas possíveis. No próprio contrato, externamente através de um programa ou API, em contratos herdados... 24 | 25 | ![](<../assets/image(38).png>) 26 | 27 | ## Private 28 | 29 | Esse é o modo mais restritivo pois permite acesso somente dentro do próprio contrato. 30 | 31 | ![](<../assets/image(12).png>) 32 | 33 | Observação importante: Blockchains são públicas então todos os dados podem ser acessíveis pelos Bytecodes. 34 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 | # Introdução 3 | 4 | Outubro de 2021 e temos mais de meio TRILHÃO de dólares investidos e aplicados 5 | em Criptomoedas e blockchains que possuem ambiente Ethereum. 6 | 7 | Este é um guia completo para programadores web3 que desejam aprender a linguagem Solidity. Ele foi criado e é mantido pela comunidade [_web3dev_](https://www.web3dev.com.br) 8 | 9 | ### Código Aberto 10 | 11 | Este guia é código aberto e está disponível no Github. Fique a vontade para colaborar, enviar correções ou novos conteúdos. Certamente você será reconhecido pela comunidade. 12 | 13 | Você encontra o código aqui: 14 | 15 | [_Solidity - Github_](https://github.com/w3b3d3v/gitbook-solidity) 16 | 17 | ### Conteúdo 18 | 19 | Você vai encontrar nesta documentação os seguintes conteúdos: 20 | 21 | [Apostila Completa](https://solidity.w3d.community/apostila/) - Uma apostila com um passo a passo para você aprender como desenvolver um smart contract em Solidity. 22 | 23 | [Exemplos](exemplos/linguagem-v0.8.3/) - Exemplos de códigos muito direto ao ponto se você precisa de uma referência rápida da sintaxe da linguagem. 24 | 25 | [\[EVM\] Máquina Virtual Ethereum](broken-reference) - Explicação sobre o funcionamento da EVM que é utilizado na rede Ethereum e também em outras redes como Fantom, Polygon e Binance Smart Chain. 26 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/chamando-outro-contrato.md: -------------------------------------------------------------------------------- 1 | # Llamando a otro Contrato 2 | 3 | El contrato puede llamar o invocar a otros contratos de dos formas. 4 | 5 | La manera más sencilla es solo llamarlo, como `A.foo(x, y, z)`. 6 | 7 | Otra forma de llamar a otros contratos es usando la función de bajo nivel `call`. 8 | 9 | Este método no es el recomendado. 10 | 11 | ```solidity 12 | // SPDX-License-Identifier: MIT 13 | pragma solidity ^0.8.3; 14 | 15 | contract Callee { 16 | uint public x; 17 | uint public value; 18 | 19 | function setX(uint _x) public returns (uint) { 20 | x = _x; 21 | return x; 22 | } 23 | 24 | function setXandSendEther(uint _x) public payable returns (uint, uint) { 25 | x = _x; 26 | value = msg.value; 27 | 28 | return (x, value); 29 | } 30 | } 31 | 32 | contract Caller { 33 | function setX(Callee _callee, uint _x) public { 34 | uint x = _callee.setX(_x); 35 | } 36 | 37 | function setXFromAddress(address _addr, uint _x) public { 38 | Callee callee = Callee(_addr); 39 | callee.setX(_x); 40 | } 41 | 42 | function setXandSendEther(Callee _callee, uint _x) public payable { 43 | (uint x, uint value) = _callee.setXandSendEther{value: msg.value}(_x); 44 | } 45 | } 46 | ``` 47 | -------------------------------------------------------------------------------- /src/exemplos/defi/oraculo-de-preco-da-chainlink.md: -------------------------------------------------------------------------------- 1 | # Oráculo de Preço da Chainlink 2 | 3 | #### ETH / USD Price Oracle 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | // import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol"; 10 | 11 | contract ChainlinkPriceOracle { 12 | AggregatorV3Interface internal priceFeed; 13 | 14 | constructor() { 15 | // ETH / USD 16 | priceFeed = AggregatorV3Interface(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419); 17 | } 18 | 19 | function getLatestPrice() public view returns (int) { 20 | ( 21 | uint80 roundID, 22 | int price, 23 | uint startedAt, 24 | uint timeStamp, 25 | uint80 answeredInRound 26 | ) = priceFeed.latestRoundData(); 27 | // for ETH / USD price is scaled up by 10 ** 8 28 | return price / 1e8; 29 | } 30 | } 31 | 32 | interface AggregatorV3Interface { 33 | function latestRoundData() 34 | external 35 | view 36 | returns ( 37 | uint80 roundId, 38 | int answer, 39 | uint startedAt, 40 | uint updatedAt, 41 | uint80 answeredInRound 42 | ); 43 | } 44 | ``` 45 | -------------------------------------------------------------------------------- /src/es/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Introducción 3 | --- 4 | ::: tip 5 | Es octubre de 2021 y tenemos más de medio TRILLÓN de dólares invertidos y aplicados 6 | en Criptomonedas y Blockchains relacionadas a Ethereum. 7 | ::: 8 | 9 | Esta es una guía completa para programadores web3 que quieran aprender a programar en Solidity. Fue creada y es mantenida por la comunidad [_web3dev_](https://www.web3dev.com.br) 10 | 11 | ### Código Abierto 12 | 13 | Esta guía es de código abierto y está disponible en Github. Siéntete libre de colaborar, enviar correcciones o nuevo contenido. Seguro que tu trabajo será reconocido por la comunidad. 14 | 15 | Puedes encontrar el código aquí: 16 | 17 | [_Solidity - Github_](https://github.com/w3b3d3v/gitbook-solidity) 18 | 19 | ### Contenido 20 | 21 | En esta documentación encontrarás el siguiente contenido: 22 | 23 | [Guía Completa](broken-reference) - Una guía con el paso a paso para que aprendas a desarrollar un contrato inteligente en Solidity. 24 | 25 | [​Ejemplos](exemplos/linguagem-v0.8.3/) - Ejemplos de códigos que van directo al grano, por si necesitas una referencia rápida de la sintaxis del lenguaje. 26 | 27 | [\[EVM\] Máquina Virtual Ethereum](broken-reference) - Explicación del funcionamiento de la EVM que se utiliza en la red Ethereum y también en otras redes como Fantom, Polygon y Binance Smart Chain. 28 | -------------------------------------------------------------------------------- /src/es/exemplos/defi/oraculo-de-preco-da-chainlink.md: -------------------------------------------------------------------------------- 1 | # Oráculo de Precio del Chainlink 2 | 3 | #### Oráculo de Precio para ETH / USD 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | // import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol"; 10 | 11 | contract ChainlinkPriceOracle { 12 | AggregatorV3Interface internal priceFeed; 13 | 14 | constructor() { 15 | // ETH / USD 16 | priceFeed = AggregatorV3Interface(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419); 17 | } 18 | 19 | function getLatestPrice() public view returns (int) { 20 | ( 21 | uint80 roundID, 22 | int price, 23 | uint startedAt, 24 | uint timeStamp, 25 | uint80 answeredInRound 26 | ) = priceFeed.latestRoundData(); 27 | // para el precio de ETH / USD se escala por 10 ** 8 28 | return price / 1e8; 29 | } 30 | } 31 | 32 | interface AggregatorV3Interface { 33 | function latestRoundData() 34 | external 35 | view 36 | returns ( 37 | uint80 roundId, 38 | int answer, 39 | uint startedAt, 40 | uint updatedAt, 41 | uint80 answeredInRound 42 | ); 43 | } 44 | ``` 45 | -------------------------------------------------------------------------------- /src/README.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: Introdução 3 | --- 4 | ::: tip 5 | Outubro de 2021 e temos mais de meio TRILHÃO de dólares investidos e aplicados 6 | em Criptomoedas e blockchains que possuem ambiente Ethereum. 7 | ::: 8 | 9 | Este é um guia completo para programadores web3 que desejam aprender a linguagem Solidity. Ele foi criado e é mantido pela comunidade [_web3dev_](https://www.web3dev.com.br) 10 | 11 | ### Código Aberto 12 | 13 | Este guia é código aberto e está disponível no Github. Fique a vontade para colaborar, enviar correções ou novos conteúdos. Certamente você será reconhecido pela comunidade. 14 | 15 | Você encontra o código aqui: 16 | 17 | [_Solidity - Github_](https://github.com/w3b3d3v/gitbook-solidity) 18 | 19 | ### Conteúdo 20 | 21 | Você vai encontrar nesta documentação os seguintes conteúdos: 22 | 23 | [Apostila Completa](/apostila/estrutura-de-contratos-inteligentes) - Uma apostila com um passo a passo para você aprender como desenvolver um smart contract em Solidity. 24 | 25 | [Exemplos](exemplos/linguagem-v0.8.3/ola-mundo) - Exemplos de códigos muito direto ao ponto se você precisa de uma referência rápida da sintaxe da linguagem. 26 | 27 | [\[EVM\] Máquina Virtual Ethereum](/evm-maquina-virtual-ethereum/) - Explicação sobre o funcionamento da EVM que é utilizado na rede Ethereum e também em outras redes como Fantom, Polygon e Binance Smart Chain. 28 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/fallback.md: -------------------------------------------------------------------------------- 1 | # Fallback 2 | 3 | `fallback` é uma função que não recebe nenhum argumento e não retorna nada. 4 | 5 | Ela é executada quando 6 | 7 | * uma função que não existe é chamada ou quando 8 | * Ether é enviado diretamente para um contrato mas `receive()` não existe ou `msg.data` não está vazio 9 | 10 | `fallback` tem um limite de gás de 2300 quando chamado por `transfer` ou `send`. 11 | 12 | ```solidity 13 | // SPDX-License-Identifier: MIT 14 | pragma solidity ^0.8.3; 15 | 16 | contract Fallback { 17 | event Log(uint gas); 18 | 19 | // Função fallback deve ser declarada como externa. 20 | fallback() external payable { 21 | // send / transfer (encaminha 2300 de gás para esta função fallback) 22 | // call (encaminha todo o gás) 23 | emit Log(gasleft()); 24 | } 25 | 26 | // Função auxiliar para verificar o saldo deste contrato 27 | function getBalance() public view returns (uint) { 28 | return address(this).balance; 29 | } 30 | } 31 | 32 | contract SendToFallback { 33 | function transferToFallback(address payable _to) public payable { 34 | _to.transfer(msg.value); 35 | } 36 | 37 | function callFallback(address payable _to) public payable { 38 | (bool sent, ) = _to.call{value: msg.value}(""); 39 | require(sent, "Failed to send Ether"); 40 | } 41 | } 42 | ``` 43 | -------------------------------------------------------------------------------- /src/apostila/18.-modificadores.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 15. Modificadores 3 | --- 4 | ::: tip 5 | São trechos de códigos que serão executados antes das funções. Uma das 6 | aplicações mais conhecidas é a de controle de acesso para que somente 7 | endereços específicos possam executar uma função. 8 | ::: 9 | 10 | ## Declarando um modifier 11 | 12 | No nosso exemplo vamos criar um modifier que irá verificar se o endereço que está chamando a função é o endereço que está salvo como administrador na variável _admin._ Se a instrução require retornar um true então será executado o código \_; que significa: execute o que vem depois. 13 | 14 | Isso quer dizer que se o código quebrar no require não irá executar a instrução _underline_, logo, não irá executar o código da função que vem depois. 15 | 16 | ![](<../assets/image(94).png>) 17 | 18 | ## Passando parâmetros 19 | 20 | Para que modifiers possam receber parâmetros eles devem ser passados para as funções nas quais estão inseridos e ter seus nomes de variáveis idênticos. 21 | 22 | ![](<../assets/image(81).png>) 23 | 24 | ## Combinando mais de um Modifier 25 | 26 | É possível até mesmo encadear modifiers e passar dados entre eles, deve seguir a mesma nomenclatura para os parâmetros que serão passados. 27 | 28 | ![](<../assets/image(126).png>) 29 | 30 | Modifiers são verificações então para ter mais de uma verificação/condição para que uma função possa ser executada basta inserir mais modifiers. 31 | -------------------------------------------------------------------------------- /src/apostila/modificadores-de-funcoes-view-pure-constant.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 4. Parâmetros de estado (view, pure) 3 | --- 4 | ::: tip 5 | Usando funções podemos guardar novos dados na blockchain, ler dados guardados na blockchain ou modifica-los. Cada tipo de função irá exigir um tipo de chamada diferente e consequentemente um custo diferente. 6 | ::: 7 | 8 | ## Por padrão 9 | 10 | Se nenhuma _palavra-chave_ de definição de estado for passada essa função terá todos os acessos, poderá retornar dados, gravar novos dados ou alterar dados existentes. 11 | 12 | ![](<../assets/image(52).png>) 13 | 14 | Essa função será executada no modo _**transaction**_ pelo minerador então mesmo que somente faça leitura de dados irá custar taxa de mineração. 15 | 16 | ## View 17 | 18 | O parâmetro _**view**_ é usado para funções que não alteram dados nem o estado do contrato na blockchain. Tudo permanece igual somente _**lê**_ os dados. 19 | 20 | ![](<../assets/image(14).png>) 21 | 22 | Essa função é executada pelo minerador no modo _**call**_ o que implica em **não ter custos de transação**. 23 | 24 | ## Pure 25 | 26 | É um dos parâmetros mais restritivos pois não poderá alterar dados ou o estado do contrato nem mesmo ler dados de variáveis. 27 | 28 | ![](<../assets/image(109).png>) 29 | 30 | É bastante usado para realizar cálculos que dependem da entrada de parâmetros na função e também é executada no modo _**call**_ tornando assim sua execução sem custo de gas. 31 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/gas.md: -------------------------------------------------------------------------------- 1 | # Gás 2 | 3 | #### Quanto`ether` você precisa para pagar uma transação? 4 | 5 | Você paga a quantia de `gas spent * gas price` em `ether`, onde 6 | 7 | * `gas` é uma unidade de computação 8 | * `gas spent` é o total de `gas` usado numa transação 9 | * `gas price` é quanto de `ether` você pretende pagar por `gas` 10 | 11 | Transações com maior preço de gas apresentam maior prioridade para serem incluídas em um bloco. 12 | 13 | O gás que não é gasto será reembolsado. 14 | 15 | #### Limite de gás 16 | 17 | Existem 2 limites máximos para a quantidade de gás que você pode gastar 18 | 19 | * `gas limit` (máximo de gás que você pretende usar para sua transação, definido por você) 20 | * `block gas limit` (máximo de gás permitido num bloco, definido pela rede) 21 | 22 | ``` 23 | // SPDX-License-Identifier: MIT 24 | pragma solidity ^0.8.3; 25 | 26 | contract Gas { 27 | uint public i = 0; 28 | 29 | // Usar todo o gás que você envia causa falha na sua transação. 30 | // Mudanças de estado são desfeitas. 31 | // Gás usado não é reembolsado . 32 | function forever() public { 33 | // Aqui rodamos um loop até que todo o gás seja gasto 34 | // e a transação falha 35 | while (true) { 36 | i += 1; 37 | } 38 | } 39 | } 40 | ``` 41 | 42 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/gas.md: -------------------------------------------------------------------------------- 1 | # Gas 2 | 3 | #### Cuánto`ether` se necesita para pagar una transacción? 4 | 5 | Pagas la cantidad de `gas spent * gas price` en `ether`, donde 6 | 7 | * `gas` es una unidad computacional 8 | * `gas spent` es la cantidad total de `gas` usado en una transacción 9 | * `gas price` es cuanto `ether` estás dispuesto a pagar por `gas` 10 | 11 | Transacciones con mayor precio de gas tienen mayor prioridad de ser incluidas en un bloque. 12 | 13 | El gas no gastado será reembolsado. 14 | 15 | #### Límite de gas 16 | 17 | Existen 2 límites máximos para la cantidad de gas que se puede gastar 18 | 19 | * `gas limit` (máximo gas que estás dispuesto a usar en tu transacción, definido por ti) 20 | * `block gas limit` (máximo gas permitido en un bloque, definido por la red) 21 | 22 | ``` 23 | // SPDX-License-Identifier: MIT 24 | pragma solidity ^0.8.3; 25 | 26 | contract Gas { 27 | uint public i = 0; 28 | 29 | // Usar todo el gas que usted envia hace que su transacción falle. 30 | // Cambios de estado son deshechos. 31 | // Gas usado no es reembolsado. 32 | function forever() public { 33 | // Aqui ejecutamos un loop hasta que todo el gas sea gastado 34 | // y la transacción falla 35 | while (true) { 36 | i += 1; 37 | } 38 | } 39 | } 40 | ``` 41 | 42 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/import.md: -------------------------------------------------------------------------------- 1 | # Import 2 | 3 | Você pode importar arquivos locais e externos no Solidity. 4 | 5 | #### Local 6 | 7 | Aqui está nossa estrutura da pasta. 8 | 9 | ```solidity 10 | ├── Import.sol 11 | └── Foo.sol 12 | 13 | ``` 14 | 15 | Foo.sol 16 | 17 | ```solidity 18 | // SPDX-License-Identifier: MIT 19 | pragma solidity ^0.8.3; 20 | 21 | contract Foo { 22 | string public name = "Foo"; 23 | } 24 | ``` 25 | 26 | Import.sol 27 | 28 | ```solidity 29 | // SPDX-License-Identifier: MIT 30 | pragma solidity ^0.8.3; 31 | 32 | // importa Foo.sol do diretório atual 33 | import "./Foo.sol"; 34 | 35 | contract Import { 36 | // Inicializa Foo.sol 37 | Foo public foo = new Foo(); 38 | 39 | // Testa Foo.sol obtendo seu nome. 40 | function getFooName() public view returns (string memory) { 41 | return foo.name(); 42 | } 43 | } 44 | ``` 45 | 46 | #### External 47 | 48 | Você também pode importar de [GitHub](https://github.com) simplesmente copiando o url 49 | 50 | ``` 51 | // https://github.com/owner/repo/blob/branch/path/to/Contract.sol 52 | import "https://github.com/owner/repo/blob/branch/path/to/Contract.sol"; 53 | 54 | // Example import ECDSA.sol from openzeppelin-contract repo, release-v3.3 branch 55 | // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.3/contracts/cryptography/ECDSA.sol 56 | import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.3/contracts/cryptography/ECDSA.sol"; 57 | ``` 58 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/import.md: -------------------------------------------------------------------------------- 1 | # Import 2 | 3 | Puedes importar archivos locales y externos en Solidity. 4 | 5 | #### Local 6 | 7 | Aquí está la estructura de nuestros archivos. 8 | 9 | ```solidity 10 | ├── Import.sol 11 | └── Foo.sol 12 | ``` 13 | 14 | Foo.sol 15 | 16 | ```solidity 17 | // SPDX-License-Identifier: MIT 18 | pragma solidity ^0.8.3; 19 | 20 | contract Foo { 21 | string public name = "Foo"; 22 | } 23 | ``` 24 | 25 | Import.sol 26 | 27 | ```solidity 28 | // SPDX-License-Identifier: MIT 29 | pragma solidity ^0.8.3; 30 | 31 | // importa Foo.sol del directorio actual 32 | import "./Foo.sol"; 33 | 34 | contract Import { 35 | // Inicializa Foo.sol 36 | Foo public foo = new Foo(); 37 | 38 | // Prueba Foo.sol obteniendo su nombre. 39 | function getFooName() public view returns (string memory) { 40 | return foo.name(); 41 | } 42 | } 43 | ``` 44 | 45 | #### External 46 | 47 | También puedes importar desde [GitHub](https://github.com) simplemente copiando la url 48 | 49 | ``` 50 | // https://github.com/owner/repo/blob/branch/path/to/Contract.sol 51 | import "https://github.com/owner/repo/blob/branch/path/to/Contract.sol"; 52 | 53 | // Example import ECDSA.sol from openzeppelin-contract repo, release-v3.3 branch 54 | // https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.3/contracts/cryptography/ECDSA.sol 55 | import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v3.3/contracts/cryptography/ECDSA.sol"; 56 | ``` 57 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/fallback.md: -------------------------------------------------------------------------------- 1 | # Fallback 2 | 3 | `fallback` es una función que no toma ningún argumento y no regresa nada. 4 | 5 | Es ejecutada cuando 6 | 7 | * Una función que no existe es llamada o 8 | * El Ether es enviado directamente al contrato pero `receive()` no existe o `msg.data` no está vacío 9 | 10 | `fallback` tiene un límite de gas de 2300 cuando es llamada por `transfer` o `send`. 11 | 12 | ```solidity 13 | // SPDX-License-Identifier: MIT 14 | pragma solidity ^0.8.3; 15 | 16 | contract Fallback { 17 | event Log(uint gas); 18 | 19 | // La función Fallback tiene que ser declarada como externa. 20 | fallback() external payable { 21 | // send / transfer (reenvía 2300 de gas a esta función fallback) 22 | // call (reenvía todo el gas) 23 | emit Log(gasleft()); 24 | } 25 | 26 | // Receive es una variante del fallback que se desencadena cuando msg.data está vacío 27 | receive() external payable { 28 | emit Log("receive", gasleft()); 29 | } 30 | 31 | // Función auxiliar que obtiene el balance de este contrato 32 | function getBalance() public view returns (uint) { 33 | return address(this).balance; 34 | } 35 | } 36 | 37 | contract SendToFallback { 38 | function transferToFallback(address payable _to) public payable { 39 | _to.transfer(msg.value); 40 | } 41 | 42 | function callFallback(address payable _to) public payable { 43 | (bool sent, ) = _to.call{value: msg.value}(""); 44 | require(sent, "Failed to send Ether"); 45 | } 46 | } 47 | ``` 48 | -------------------------------------------------------------------------------- /src/apostila/estrutura-de-contratos-inteligentes.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 1. Estrutura de Contratos Inteligentes 3 | --- 4 | ::: tip 5 | Smart contract são conjuntos de regras matemática definidas previamente. Essas 6 | regras podem estar condicionadas à contextos, ex: só executar se for dia X do 7 | ano ou só executar à cada 3 dias etc... 8 | ::: 9 | 10 | São realmente infinitas as possibilidades do que se pode fazer com eles mas seu funcionamento se resume em: 11 | 12 | ![basic structure of smart contract](<../assets/image(108).png>) 13 | 14 | ### Definindo a versão da linguagem 15 | 16 | O comando pragma é usado para definir qual será a versão da linguagem solidity que será usada nesse contrato. 17 | 18 | ![](<../assets/image(114).png>) 19 | 20 | repare no parâmetro .8 entre o .0 e .11 ele indica que é a versão principal, isso quer dizer que um compilador executando a versão 0.8.12 também funcionará, assim como 0.8.12 ou 13. 21 | 22 | ### Importação de bibliotecas e código pronto 23 | 24 | ![](<../assets/image(24).png>) 25 | 26 | No mundo do desenvolvimento estamos sempre reaproveitando códigos prontos e já testados e você deve se habituar à isso. Mas fique atento pois cada linguagem tem seu padrão de como importar outros códigos. 27 | 28 | Pra uma explicação mais detalhada sobre como fazer importações e reutilização de contratos veja o a sessão [21.-bibliotecas-librarys.md](extra-avancado/21.-bibliotecas-librarys.md "mention") 29 | 30 | ### Código do contrato 31 | 32 | ![](<../assets/image(47).png>) 33 | 34 | dentro _contract_ é onde ficam todas as regras e condições do contrato. 35 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/hashing-with-keccak256.md: -------------------------------------------------------------------------------- 1 | # Hashing with Keccak256 2 | 3 | `keccak256` computa o hash Keccak-256 de entrada. 4 | 5 | Alguns casos de uso: 6 | 7 | * Criando um único ID determinístico de uma entrada 8 | * Esquema Commit-Reveal 9 | * Assinatura criptografada compacta (assinando o hash ao invés de uma entrada maior) 10 | 11 | ```solidity 12 | // SPDX-License-Identifier: MIT 13 | pragma solidity ^0.8.3; 14 | 15 | contract HashFunction { 16 | function hash( 17 | string memory _text, 18 | uint _num, 19 | address _addr 20 | ) public pure returns (bytes32) { 21 | return keccak256(abi.encodePacked(_text, _num, _addr)); 22 | } 23 | 24 | // Exemplo de colisão hash 25 | // Colisão Hash pode ocorrer quando você passa mais de um tipo de dados dinâmicos 26 | // para abi.encodePacked. Nesse caso, você deve usar abi.encode. 27 | function collision(string memory _text, string memory _anotherText) 28 | public 29 | pure 30 | returns (bytes32) 31 | { 32 | // encodePacked(AAA, BBB) -> AAABBB 33 | // encodePacked(AA, ABBB) -> AAABBB 34 | return keccak256(abi.encodePacked(_text, _anotherText)); 35 | } 36 | } 37 | 38 | contract GuessTheMagicWord { 39 | bytes32 public answer = 40 | 0x60298f78cc0b47170ba79c10aa3851d7648bd96f2f8e46a19dbc777c36fb0c00; 41 | 42 | // Palavra mágica é "Solidity" 43 | function guess(string memory _word) public view returns (bool) { 44 | return keccak256(abi.encodePacked(_word)) == answer; 45 | } 46 | } 47 | ``` 48 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/hashing-with-keccak256.md: -------------------------------------------------------------------------------- 1 | # Hashing with Keccak256 2 | 3 | `keccak256` computa el hash Keccak-256 del input. 4 | 5 | Algunos casos de uso son: 6 | 7 | * Crear un único ID determinístico desde un input 8 | * El esquema Commit-Reveal 9 | * La firma criptográfica compacta (firmando el hash en vez de un input muy largo) 10 | 11 | ```solidity 12 | // SPDX-License-Identifier: MIT 13 | pragma solidity ^0.8.3; 14 | 15 | contract HashFunction { 16 | function hash( 17 | string memory _text, 18 | uint _num, 19 | address _addr 20 | ) public pure returns (bytes32) { 21 | return keccak256(abi.encodePacked(_text, _num, _addr)); 22 | } 23 | 24 | // Ejemplo de la colisión del hash 25 | // La colisión del hash puede ocurrir cuando pasas más de un tipo de dato dinámico 26 | // al abi.encodePacked. En ese caso, en cambio, debes usar abi.encode. 27 | function collision(string memory _text, string memory _anotherText) 28 | public 29 | pure 30 | returns (bytes32) 31 | { 32 | // encodePacked(AAA, BBB) -> AAABBB 33 | // encodePacked(AA, ABBB) -> AAABBB 34 | return keccak256(abi.encodePacked(_text, _anotherText)); 35 | } 36 | } 37 | 38 | contract GuessTheMagicWord { 39 | bytes32 public answer = 40 | 0x60298f78cc0b47170ba79c10aa3851d7648bd96f2f8e46a19dbc777c36fb0c00; 41 | 42 | // La palabra mágica es "Solidity" 43 | function guess(string memory _word) public view returns (bool) { 44 | return keccak256(abi.encodePacked(_word)) == answer; 45 | } 46 | } 47 | ``` 48 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/constructor.md: -------------------------------------------------------------------------------- 1 | # Constructor 2 | 3 | Um`constructor` é uma função opcional que é executada com a criação de um contrato. 4 | 5 | Aqui estão exemplos de como passar argumentos para `constructors`. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | // Contrato base X 12 | contract X { 13 | string public name; 14 | 15 | constructor(string memory _name) { 16 | name = _name; 17 | } 18 | } 19 | 20 | // Contrato base Y 21 | contract Y { 22 | string public text; 23 | 24 | constructor(string memory _text) { 25 | text = _text; 26 | } 27 | } 28 | 29 | // Existem duas formas de inicializar um contrato de classe pai com parâmetros. 30 | 31 | // Passe os parâmetros aqui na lista de herança. 32 | contract B is X("Input to X"), Y("Input to Y") { 33 | 34 | } 35 | 36 | contract C is X, Y { 37 | // Passe os parâmetros aqui no constructor, 38 | // semelhante aos modificadores de função. 39 | constructor(string memory _name, string memory _text) X(_name) Y(_text) {} 40 | } 41 | 42 | // Constructors da classe pai são sempre chamados na ordem de herança 43 | // independentemente da ordem dos contratos de classe pai listados no 44 | // constructor do contrato de classe filho. 45 | 46 | // Ordem dos constructors chamados: 47 | // 1. Y 48 | // 2. X 49 | // 3. D 50 | contract D is X, Y { 51 | constructor() X("X was called") Y("Y was called") {} 52 | } 53 | 54 | // Ordem dos constructors chamados: 55 | // 1. Y 56 | // 2. X 57 | // 3. E 58 | contract E is X, Y { 59 | constructor() Y("Y was called") X("X was called") {} 60 | } 61 | ``` 62 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/constructor.md: -------------------------------------------------------------------------------- 1 | # Constructor 2 | 3 | Un `constructor` es una función opcional que es ejecutada cuando se crea el contrato. 4 | 5 | A continuación ejemplos de como pasar argumentos a los `constructors`. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | // Contrato base X 12 | contract X { 13 | string public name; 14 | 15 | constructor(string memory _name) { 16 | name = _name; 17 | } 18 | } 19 | 20 | // Contrato base Y 21 | contract Y { 22 | string public text; 23 | 24 | constructor(string memory _text) { 25 | text = _text; 26 | } 27 | } 28 | 29 | // Existen dos formas de inicializar un contrato padre con parámetros. 30 | 31 | // Pasa los parámetros aquí en la lista de herencia. 32 | contract B is X("Input to X"), Y("Input to Y") { 33 | 34 | } 35 | 36 | contract C is X, Y { 37 | // Pasa los parámetros aquí en el constructor, 38 | // semejante a los modificadores de función. 39 | constructor(string memory _name, string memory _text) X(_name) Y(_text) {} 40 | } 41 | 42 | // Constructores padres son siempre invocados en el orden de herencia 43 | // independientemente del orden de los contratos padres listados en el 44 | // constructor del contrato hijo. 45 | 46 | // Orden de los constructores invocados: 47 | // 1. Y 48 | // 2. X 49 | // 3. D 50 | contract D is X, Y { 51 | constructor() X("X was called") Y("Y was called") {} 52 | } 53 | 54 | // Orden de los constructores invocados: 55 | // 1. Y 56 | // 2. X 57 | // 3. E 58 | contract E is X, Y { 59 | constructor() Y("Y was called") X("X was called") {} 60 | } 61 | ``` -------------------------------------------------------------------------------- /src/apostila/controladores-de-fluxo-if-for-while.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 9. Controladores de Fluxo (if, for, while) 3 | --- 4 | ::: tip 5 | A parte mais importante de toda programação é a lógica de como um script é 6 | programado e controladores de fluxo são os tijolos dessa construção. 7 | ::: 8 | 9 | ## If & else 10 | 11 | Usado para criar condições que devem ser atendidas para que um determinado trecho de código seja executado. Já o _**else é uma condição**_ que será executado _**caso a primeira não seja**_. 12 | 13 | ![](<../assets/image(17).png>) 14 | 15 | ## Loop for 16 | 17 | Quando precisamos fazer interações por vários itens dentro de um array ou mapping, ou então executar algo por um número definido de vezes podemos usar loops for. 18 | 19 | ![](<../assets/image(61).png>) 20 | 21 | O valor de _**i começa em zero e irá acrescentando 1**_ até chegar no valor armazenado em _**listaDeEnderecos.length**_ que é responsável por retornar o tamanho da lista. De 1 em 1 o loop irá executar o trecho de código para cada endereço guardado na _**listaDeEnderecos.**_ 22 | 23 | ## loop While 24 | 25 | Se precisarmos repetir um trecho de código por um número indefinido de vezes ou até que uma condição seja atingida usamos loops while. 26 | 27 | ![Obs: isso pode gastar muito gás então use com muita atenção.](<../assets/image(29).png>) 28 | 29 | O loop While irá ficar rodando até que as condições pra ele parar sejam alcançadas e essa condição pode ser construída com _**if**_ seguido de um _**break**_ que é o código irá parar. Há outra instrução nesse código que é o _**continue**_, responsável por fazer o loop "pular" para o inicio ao invés de ser executado até o final e só então recomeçar. 30 | -------------------------------------------------------------------------------- /src/es/apostila/14.-eventos.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 14. Eventos 3 | --- 4 | ::: tip 5 | Las blockchains son sistemas aislados del resto de la Internet, en la cual sistemas convencionales y eventos se utilizan para "comunicar al mundo" lo que está sucediendo. 6 | ::: 7 | 8 | ## Declarando el Evento 9 | 10 | Tienen una estructura básica y un estándar para que con otros sistemas puedan "hablar todos el mismo idioma" y se reducen a: cuándo, dónde, quién y qué sucedió. Para esto usamos la palabra clave _**event**_ antes de _**nombreDelEvento**_ y entre paréntesis sus **argumentos obligatorios**. 11 | 12 | El parámetro _indexed_ permite que otros sistemas apliquen filtros. En el siguiente ejemplo, un sistema que está _escuchando_ estos eventos puede filtrar por fecha, dirección de envío y recepción. 13 | 14 | ```solidity 15 | event NuevoTrade( 16 | //Parámetro indexed ayuda a filtrar eventos en el Front-End. 17 | 18 | uint indexed date, 19 | address indexed de_donde, 20 | address indexed para_donde, 21 | uint cantidad 22 | ); 23 | ``` 24 | 25 | ## Emitiendo el Evento 26 | 27 | Después de declarar un evento podemos emitirlo dentro de cualquier función a través del parámetro _**emit nombreDelEvento()**_ y luego pasamos los argumentos que sean necesarios. 28 | 29 | ```solidity 30 | function tradeOcurrió(address de_donde, uint _cantidad) external { 31 | emit NuevoTrade(now, msg.sender, de_donde, _cantidad); 32 | } 33 | ``` 34 | 35 | ## Ejemplo real: Transacción 36 | 37 | En el siguiente ejemplo, un evento será emitido conteniendo _quién envió_, _para quién envió_ y _cuánto envió_. 38 | 39 | ```solidity 40 | event Transfer(address indexed from, address indexed to, uint256 value); 41 | ``` 42 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/pagavel.md: -------------------------------------------------------------------------------- 1 | # Pagável 2 | 3 | Funções e endereços declarados `payable` podem receber `ether` nesse contrato. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract Payable { 10 | // Endereço pagável pode receber Ether 11 | address payable public owner; 12 | 13 | // Constructor pagável pode receber Ether 14 | constructor() payable { 15 | owner = payable(msg.sender); 16 | } 17 | 18 | // Função para depositar Ether neste contrato. 19 | // Chamar essa função junto com algum Ether. 20 | // O saldo desse contrato será automaticamente atualizado. 21 | function deposit() public payable {} 22 | 23 | // Chamar essa função junto com algum Ether. 24 | // A função vai lançar um erro já que ela não é pagável. 25 | function notPayable() public {} 26 | 27 | // Função para retirar todo Ether deste contrato. 28 | function withdraw() public { 29 | // pega a quantidade de Ether armazenado nesse contrato 30 | uint amount = address(this).balance; 31 | 32 | // envia todo Ether para o proprietário 33 | // Proprietário pode receber Ether já que o endereço dele é pagável 34 | (bool success, ) = owner.call{value: amount}(""); 35 | require(success, "Failed to send Ether"); 36 | } 37 | 38 | // Função para transferir Ether deste contrato para o endereço de entrada 39 | function transfer(address payable _to, uint _amount) public { 40 | // Note que "to" está declarada como pagável 41 | (bool success, ) = _to.call{value: _amount}(""); 42 | require(success, "Failed to send Ether"); 43 | } 44 | } 45 | ``` 46 | -------------------------------------------------------------------------------- /src/es/apostila/4.-modificadores-de-funcoes-view-pure-constant.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 4. Parámetros de estado (view, pure) 3 | --- 4 | ::: tip 5 | Usando funciones podemos almacenar, leer o modificar datos en la cadena de bloques. Cada tipo de función requerirá un tipo de llamada diferente y en consecuencia un costo diferente. 6 | ::: 7 | 8 | ## Por Defecto 9 | 10 | Si no se pasa ninguna _palabra-clave_ de definición de estado, esa función tendrá todos los accesos, podrá devolver, escribir, o alterar datos existentes. 11 | 12 | ```solidity 13 | function verEdad() external returns(uint){ 14 | edad = 100; 15 | return edad; 16 | } 17 | ``` 18 | 19 | El minero ejecutará esta función en modo _**transacción**_, por lo que incluso aunque solo lea datos, será cobrada una tarifa de minería. 20 | 21 | ## View 22 | 23 | El parámetro _**view**_ se usa para funciones que no cambian los datos o el estado del contrato en la cadena de bloques. Todo sigue igual y solo _**leerá**_ los datos. 24 | 25 | ```solidity 26 | uint edad = 24; 27 | function verEdad() external view returns(uint){ 28 | return edad; 29 | } 30 | ``` 31 | 32 | Esta función es ejecutada por el minero en modo _**call**_, lo que implica en **no tener costos de transacción**. 33 | 34 | ## Pure 35 | 36 | Es uno de los parámetros más restrictivos ya que no podrá cambiar los datos, el estado del contrato o incluso leer datos de variables. 37 | 38 | ```solidity 39 | function calculaEdad(uint numero) external pure returns(uint){ 40 | return numero + numero; 41 | } 42 | ``` 43 | 44 | Es muy utilizado para realizar cálculos que dependen de la entrada de parámetros en la función y también se ejecuta en modo _**call**_, haciendo así su ejecución sin costo de gas. 45 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/localizacoes-de-dados-armazenamento-memoria-e-calldata.md: -------------------------------------------------------------------------------- 1 | # Localizações de Dados - Armazenamento, Memória e Calldata 2 | 3 | Variáveis são declaradas como `storage`, `memory`ou `calldata` para especificar claramente a localização dos dados. 4 | 5 | * `storage` - é uma variável de estado (armazena no blockchain) 6 | * `memory` - é uma variável que está na memória e existe enquanto uma função está sendo chamada 7 | * `calldata` - localização de dados especiais que contém argumentos de função, somente disponível para funções `external` 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract DataLocations { 14 | uint[] public arr; 15 | mapping(uint => address) map; 16 | struct MyStruct { 17 | uint foo; 18 | } 19 | mapping(uint => MyStruct) myStructs; 20 | 21 | function f() public { 22 | // chama _f com variáveis de estado 23 | _f(arr, map, myStructs[1]); 24 | 25 | // obtém uma struct de um mapping 26 | MyStruct storage myStruct = myStructs[1]; 27 | // cria uma struct na memória 28 | MyStruct memory myMemStruct = MyStruct(0); 29 | } 30 | 31 | function _f( 32 | uint[] storage _arr, 33 | mapping(uint => address) storage _map, 34 | MyStruct storage _myStruct 35 | ) internal { 36 | // opera com variáveis armazenadas 37 | } 38 | 39 | // Você pode retornar variáveis de memória 40 | function g(uint[] memory _arr) public returns (uint[] memory) { 41 | // opera com a matriz de memória 42 | } 43 | 44 | function h(uint[] calldata _arr) external { 45 | // opera com matriz calldata 46 | } 47 | } 48 | ``` 49 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/tipos-de-dados-primarios.md: -------------------------------------------------------------------------------- 1 | # Tipos de Dados Primários 2 | 3 | Aqui são apresentados alguns tipos de dados primários disponíveis no Solidity. 4 | 5 | * `boolean` 6 | * `uint` 7 | * `int` 8 | * `address` 9 | 10 | ```solidity 11 | // SPDX-License-Identifier: MIT 12 | pragma solidity ^0.8.3; 13 | 14 | contract Primitives { 15 | bool public boo = true; 16 | 17 | /* 18 | uint representa um número inteiro sem sinal, significando que 19 | números inteiros não negativos diferentes estão disponíveis 20 | uint8 varia de 0 a 2 ** 8 - 1 21 | uint16 varia de 0 a 2 ** 16 - 1 22 | ... 23 | uint256 varia de 0 a 2 ** 256 - 1 24 | */ 25 | uint8 public u8 = 1; 26 | uint public u256 = 456; 27 | uint public u = 123; // uint é um apelido para uint256 28 | 29 | /* 30 | Números negativos são permitidos para dados do tipo int. 31 | Assim como no uint, intervalos diferentes estão disponíveis de 32 | int8 a int256 33 | 34 | int256 varia de -2 ** 255 a 2 ** 255 - 1 35 | int128 varia de -2 ** 127 a 2 ** 127 - 1 36 | */ 37 | int8 public i8 = -1; 38 | int public i256 = 456; 39 | int public i = -123; // int é o mesmo que int256 40 | 41 | // mínimo e máximo de int 42 | int public minInt = type(int).min; 43 | int public maxInt = type(int).max; 44 | 45 | address public addr = 0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c; 46 | 47 | // Valores padrão 48 | // Variáveis sem sinal possuem um valor padrão 49 | bool public defaultBoo; // false 50 | uint public defaultUint; // 0 51 | int public defaultInt; // 0 52 | address public defaultAddr; // 0x0000000000000000000000000000000000000000 53 | } 54 | ``` 55 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/pagavel.md: -------------------------------------------------------------------------------- 1 | # Pagable 2 | 3 | Las funciones y direcciones declaradas `payable` pueden recibir `ether` en el contrato. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract Payable { 10 | // Una dirección pagable puede recibir Ether 11 | address payable public owner; 12 | 13 | // El constructor pagable puede recibir Ether 14 | constructor() payable { 15 | owner = payable(msg.sender); 16 | } 17 | 18 | // Función que deposita Ether a este contrato. 19 | // Llama esta función junto a algunos Ether. 20 | // El balance de este contrato será automáticamente actualizado. 21 | function deposit() public payable {} 22 | 23 | // Invoca esta función junto a algunos Ether. 24 | // La función dará un error ya que esta función no es pagable. 25 | function notPayable() public {} 26 | 27 | // Función para retirar todos los Ether de este contrato. 28 | function withdraw() public { 29 | // Obtiene la cantidad de Ether almacenado en este contrato 30 | uint amount = address(this).balance; 31 | 32 | // Envía todos los Ether al dueño 33 | // El dueño puede recibir Ether ya que la dirección del dueño es pagable 34 | (bool success, ) = owner.call{value: amount}(""); 35 | require(success, "Failed to send Ether"); 36 | } 37 | 38 | // Función para transferir Ether de este contrato a la dirección indicada en el input 39 | function transfer(address payable _to, uint _amount) public { 40 | // Note que "to" está declarada como pagable 41 | (bool success, ) = _to.call{value: _amount}(""); 42 | require(success, "Failed to send Ether"); 43 | } 44 | } 45 | ``` 46 | -------------------------------------------------------------------------------- /src/es/apostila/5.-visibilidade-de-funcoes-external-public-internal-and-private.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 5. Visibilidad de Funciones (external, public, internal & private) 3 | --- 4 | ::: tip 5 | Las funciones y/o variables de un contrato pueden estar sujetas a cuatro 6 | parámetros de visibilidad. 7 | ::: 8 | 9 | ## External 10 | 11 | Esta función sólo será accesible desde fuera del contrato. Él mismo no podrá llamarla. 12 | 13 | ```solidity 14 | string miNombre = "Juno"; 15 | function cualEsMiNombre() external returns(string) { 16 | return miNombre; 17 | } 18 | ``` 19 | 20 | ## Internal 21 | 22 | Las funciones con este parámetro son accesibles solo en el contrato que las contiene y los que son "_**hijos**_" del mismo, es decir, contratos que heredan sus funciones y variables. Para una mejor comprensión de la herencia, consulte la sección [24.-Herencia.md](extra-avancado/24.-heranca.md "mention") 23 | 24 | ```solidity 25 | string miNombre = "Juno"; 26 | function cualEsMiNombre() internal returns(string) { 27 | return miNombre; 28 | } 29 | ``` 30 | 31 | ## Public 32 | 33 | Esta función será accesible de todas las formas posibles. En el propio contrato, de forma externa a través de un programa o API, en contratos heredados... 34 | 35 | ```solidity 36 | string miNombre = "Juno"; 37 | function cualEsMiNombre() public returns(string) { 38 | return miNombre; 39 | } 40 | ``` 41 | 42 | ## Private 43 | 44 | Este es el modo más restrictivo ya que permite el acceso únicamente dentro del propio contrato. 45 | 46 | ```solidity 47 | function cualEsMiNombre() private returns(string) { 48 | return miNombre; 49 | } 50 | ``` 51 | 52 | Nota importante: Las Blockchains son públicas, por lo que se puede acceder a todos los datos en ellas mediante el uso de Bytecodes. 53 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/mapping.md: -------------------------------------------------------------------------------- 1 | # Mapping 2 | 3 | Mapas são criados com a sintaxe mapping`keyType => valueType)`. 4 | 5 | `keyType` podem ser valores como `uint`, `address` or `bytes`. 6 | 7 | `valueType` pode ser de qualquer tipo incluindo outro mapping ou uma matriz. 8 | 9 | Mappings não são iteráveis. 10 | 11 | ``` 12 | // SPDX-License-Identifier: MIT 13 | pragma solidity ^0.8.3; 14 | 15 | contract Mapping { 16 | // Mapping de address para uint 17 | mapping(address => uint) public myMap; 18 | 19 | function get(address _addr) public view returns (uint) { 20 | // Mapping sempre retorna um valor. 21 | // Se o valor nunca foi definido, vai retornar o valor padrão. 22 | return myMap[_addr]; 23 | } 24 | 25 | function set(address _addr, uint _i) public { 26 | // Atualiza o valor nesse endereço 27 | myMap[_addr] = _i; 28 | } 29 | 30 | function remove(address _addr) public { 31 | // Redefine o valor para o padrão. 32 | delete myMap[_addr]; 33 | } 34 | } 35 | 36 | contract NestedMapping { 37 | // Mapping aninhado (mapping de address para outro mapping) 38 | mapping(address => mapping(uint => bool)) public nested; 39 | 40 | function get(address _addr1, uint _i) public view returns (bool) { 41 | // Você pode obter valores de um mapping aninhado 42 | // mesmo quando ele não tiver sido inicializado. 43 | return nested[_addr1][_i]; 44 | } 45 | 46 | function set( 47 | address _addr1, 48 | uint _i, 49 | bool _boo 50 | ) public { 51 | nested[_addr1][_i] = _boo; 52 | } 53 | 54 | function remove(address _addr1, uint _i) public { 55 | delete nested[_addr1][_i]; 56 | } 57 | } 58 | ``` 59 | -------------------------------------------------------------------------------- /src/apostila/arrays-listas.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 8. Arrays (Listas) 3 | --- 4 | ::: tip 5 | Arrays são listas de um único tipo de dado e as utilidades e aplicações são 6 | praticamente infinitas. 7 | ::: 8 | 9 | ## Criando Arrays 10 | 11 | Usamos os sinais de colchetes como em outras linguagens porém precisamos especificar o tipo desse array primeiro, e depois o seu nome. 12 | 13 | ![](<../assets/image(92).png>) 14 | 15 | lista chamada _**saldos**_ do tipo _**uint**_ (números inteiros positivos). 16 | 17 | ## Adicionando itens à lista 18 | 19 | Para adicionar um registro usamos o comando _push(valor\_a\_ser\_adicionado)_ e para atualizar acessamos o índice (posição da lista) em que esse valor está armazenado. Assim como tudo na computação, listas _começam com índice 0_ então o primeiro valor estará armazenado na posição 0 e o segundo na posição 1 e assim segue. 20 | 21 | ![](<../assets/image(51).png>) 22 | 23 | ## Acessando itens 24 | 25 | Para acessar os dados que estão guardados nessa lista usamos seu nome e a posição do item dentro de colchetes. 26 | 27 | ![](<../assets/image(59).png>) 28 | 29 | ## Deletando itens 30 | 31 | Muito semelhante à outras linguagens para deletar um item é usado a palavra _**delete**_ e a posição da lista que será apagada. 32 | 33 | ![](<../assets/image(8).png>) 34 | 35 | ## Arrays multidimensionais 36 | 37 | Parecido com tabelas ou outras estruturas multidimensionais como tensores, também é possível construir "listas de listas" em solidity. 38 | 39 | ![](<../assets/image(84).png>) 40 | 41 | Nesse caso temos uma lista que contém outras listas de Shitcoins. 42 | 43 | Para acessar um valor guardado em uma lista de listas precisamos encontrá-lo pelos indices da seguinte forma: _**nomedalista\[primeiro\_indice]\[segundo\_indice].**_ 44 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/tipos-de-dados-primarios.md: -------------------------------------------------------------------------------- 1 | # Tipos de Datos Primarios 2 | 3 | Aquí son presentados algunos tipos de datos primarios disponibles en Solidity. 4 | 5 | * `boolean` 6 | * `uint` 7 | * `int` 8 | * `address` 9 | 10 | ```solidity 11 | // SPDX-License-Identifier: MIT 12 | pragma solidity ^0.8.3; 13 | 14 | contract Primitives { 15 | bool public boo = true; 16 | 17 | /* 18 | uint representa un número entero sin signo, es decir números no negativos 19 | diferentes tamaños están disponibles 20 | uint8 varia desde 0 hasta 2 ** 8 - 1 21 | uint16 varia desde 0 hasta 2 ** 16 - 1 22 | ... 23 | uint256 varia desde 0 hasta 2 ** 256 - 1 24 | */ 25 | uint8 public u8 = 1; 26 | uint public u256 = 456; 27 | uint public u = 123; // uint es un alias para uint256 28 | 29 | /* 30 | Números negativos son permitidos para datos del tipo int. 31 | Como en uint, diferentes intervalos están disponibles desde int8 hasta int256 32 | 33 | int256 varia desde -2 ** 255 hasta 2 ** 255 - 1 34 | int128 varia desde -2 ** 127 hasta 2 ** 127 - 1 35 | */ 36 | int8 public i8 = -1; 37 | int public i256 = 456; 38 | int public i = -123; // int es lo mismo que int256 39 | 40 | // mínimo y máximo de int 41 | int public minInt = type(int).min; 42 | int public maxInt = type(int).max; 43 | 44 | address public addr = 0xCA35b7d915458EF540aDe6068dFe2F44E8fa733c; 45 | 46 | // Valores por defecto 47 | // Variables sin una asignación inicial poseen un valor por defecto 48 | bool public defaultBoo; // false 49 | uint public defaultUint; // 0 50 | int public defaultInt; // 0 51 | address public defaultAddr; // 0x0000000000000000000000000000000000000000 52 | } 53 | ``` 54 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/localizacoes-de-dados-armazenamento-memoria-e-calldata.md: -------------------------------------------------------------------------------- 1 | # Localizaciones de Datos - Almacenamiento, Memoria y Calldata 2 | 3 | Variables son declaradas como `storage`, `memory` o `calldata` para especificar explícitamente la localización de los datos. 4 | 5 | * `storage` - es una variable de estado (almacenada en el blockchain) 6 | * `memory` - es una variable que está en memoria y existe mientras una función es invocada 7 | * `calldata` - localización especial de datos que contiene argumentos de función, solamente disponible para funciones `external` 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract DataLocations { 14 | uint[] public arr; 15 | mapping(uint => address) map; 16 | struct MyStruct { 17 | uint foo; 18 | } 19 | mapping(uint => MyStruct) myStructs; 20 | 21 | function f() public { 22 | // invoca _f con variables de estado 23 | _f(arr, map, myStructs[1]); 24 | 25 | // obtiene un struct de un mapping 26 | MyStruct storage myStruct = myStructs[1]; 27 | // crea un struct en memoria 28 | MyStruct memory myMemStruct = MyStruct(0); 29 | } 30 | 31 | function _f( 32 | uint[] storage _arr, 33 | mapping(uint => address) storage _map, 34 | MyStruct storage _myStruct 35 | ) internal { 36 | // realiza operaciones con variables storage 37 | } 38 | 39 | // Puedes devolver variables de memoria 40 | function g(uint[] memory _arr) public returns (uint[] memory) { 41 | // realiza operaciones con el arreglo de memoria 42 | } 43 | 44 | function h(uint[] calldata _arr) external { 45 | // realiza operaciones con el arreglo de calldata 46 | } 47 | } 48 | ``` -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/mapping.md: -------------------------------------------------------------------------------- 1 | # Mapping 2 | 3 | Maps son creados con la sintaxis `mapping(keyType => valueType)`. 4 | 5 | `keyType` puede ser cualquier tipo de valor built-in como `uint`, `address` o `bytes`. 6 | 7 | `valueType` puede ser de cualquier tipo incluyendo otro mapping o un arreglo. 8 | 9 | Mappings no son iterables. 10 | 11 | ``` 12 | // SPDX-License-Identifier: MIT 13 | pragma solidity ^0.8.3; 14 | 15 | contract Mapping { 16 | // Mapping de address del tipo uint 17 | mapping(address => uint) public myMap; 18 | 19 | function get(address _addr) public view returns (uint) { 20 | // Mapping siempre devuelve um valor. 21 | // Si el valor nunca fue definido, devolverá el valor por defecto. 22 | return myMap[_addr]; 23 | } 24 | 25 | function set(address _addr, uint _i) public { 26 | // Actualiza el valor de esa dirección 27 | myMap[_addr] = _i; 28 | } 29 | 30 | function remove(address _addr) public { 31 | // Restaura el valor al valor por defecto. 32 | delete myMap[_addr]; 33 | } 34 | } 35 | 36 | contract NestedMapping { 37 | // Mapping anidado (mapping de address dentro de otro mapping) 38 | mapping(address => mapping(uint => bool)) public nested; 39 | 40 | function get(address _addr1, uint _i) public view returns (bool) { 41 | // Puede obtener los valores de un mapping anidado 42 | // hasta cuando no fue inicializado. 43 | return nested[_addr1][_i]; 44 | } 45 | 46 | function set( 47 | address _addr1, 48 | uint _i, 49 | bool _boo 50 | ) public { 51 | nested[_addr1][_i] = _boo; 52 | } 53 | 54 | function remove(address _addr1, uint _i) public { 55 | delete nested[_addr1][_i]; 56 | } 57 | } 58 | ``` 59 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/call.md: -------------------------------------------------------------------------------- 1 | # Call 2 | 3 | `call` é uma função de baixo nível para interagir com outros contratos. 4 | 5 | Este é o método recomendado para ser usado quando você está somente enviando Ether via chamada da função `fallback`. 6 | 7 | Contudo não é uma forma recomendada para chamar funções existentes. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract Receiver { 14 | event Received(address caller, uint amount, string message); 15 | 16 | fallback() external payable { 17 | emit Received(msg.sender, msg.value, "Fallback was called"); 18 | } 19 | 20 | function foo(string memory _message, uint _x) public payable returns (uint) { 21 | emit Received(msg.sender, msg.value, _message); 22 | 23 | return _x + 1; 24 | } 25 | } 26 | 27 | contract Caller { 28 | event Response(bool success, bytes data); 29 | 30 | // Vamos imaginar que o contrato B não tenha o código fonte para 31 | // contrato A, mas nós sabemos o endereço de A e a função para chamar. 32 | function testCallFoo(address payable _addr) public payable { 33 | // Você pode enviar ether e especificar uma quantidade de gás personalizada 34 | (bool success, bytes memory data) = _addr.call{value: msg.value, gas: 5000}( 35 | abi.encodeWithSignature("foo(string,uint256)", "call foo", 123) 36 | ); 37 | 38 | emit Response(success, data); 39 | } 40 | 41 | // Chamando uma função que não existe aciona a função fallback. 42 | function testCallDoesNotExist(address _addr) public { 43 | (bool success, bytes memory data) = _addr.call( 44 | abi.encodeWithSignature("doesNotExist()") 45 | ); 46 | 47 | emit Response(success, data); 48 | } 49 | } 50 | ``` 51 | -------------------------------------------------------------------------------- /src/exemplos/hacks/manipulacao-do-bloco-timestamp.md: -------------------------------------------------------------------------------- 1 | # Manipulação do Bloco Timestamp 2 | 3 | #### Vulnerabilidade 4 | 5 | `block.timestamp` podem ser manipulados por mineradores com as seguintes limitações 6 | 7 | * não pode ser carimbado com um tempo anterior ao de seu bloco pai 8 | * não pode estar muito longe no futuro 9 | 10 | ```solidity 11 | // SPDX-License-Identifier: MIT 12 | pragma solidity ^0.8.3; 13 | 14 | /* 15 | Roulette é um jogo onde você pode ganhar todo Ether num contrato 16 | se você conseguir submeter uma transação num tempo específico. 17 | Um jogador precisa enviar 10 Ether e vence se o block.timestamp % 15 == 0. 18 | */ 19 | 20 | /* 21 | 1. Implante o Roulette com 10 Ether 22 | 2. Eve roda um poderoso minerador que pode manipular o bloco timestamp. 23 | 3. Eve configura o block.timestamp para um número no futuro que é divisível por 24 | 15 e encontra o bloco hash alvo. 25 | 4. O bloco de Eve é incluído na chain com sucesso, Eve ganha o jogo 26 | Roulette. 27 | */ 28 | 29 | contract Roulette { 30 | uint public pastBlockTime; 31 | 32 | constructor() payable {} 33 | 34 | function spin() external payable { 35 | require(msg.value == 10 ether); // must send 10 ether to play 36 | require(block.timestamp != pastBlockTime); // only 1 transaction per block 37 | 38 | pastBlockTime = block.timestamp; 39 | 40 | if (block.timestamp % 15 == 0) { 41 | (bool sent, ) = msg.sender.call{value: address(this).balance}(""); 42 | require(sent, "Failed to send Ether"); 43 | } 44 | } 45 | } 46 | ``` 47 | 48 | #### Técnicas preventivas 49 | 50 | * Não use `block.timestamp` para uma fonte de entropia e número aleatório 51 | -------------------------------------------------------------------------------- /src/es/exemplos/hacks/manipulacao-do-bloco-timestamp.md: -------------------------------------------------------------------------------- 1 | # Manipulação do Bloco Timestamp 2 | 3 | #### Vulnerabilidade 4 | 5 | `block.timestamp` podem ser manipulados por mineradores com as seguintes limitações 6 | 7 | * não pode ser carimbado com um tempo anterior ao de seu bloco pai 8 | * não pode estar muito longe no futuro 9 | 10 | ```solidity 11 | // SPDX-License-Identifier: MIT 12 | pragma solidity ^0.8.3; 13 | 14 | /* 15 | Roulette é um jogo onde você pode ganhar todo Ether num contrato 16 | se você conseguir submeter uma transação num tempo específico. 17 | Um jogador precisa enviar 10 Ether e vence se o block.timestamp % 15 == 0. 18 | */ 19 | 20 | /* 21 | 1. Implante o Roulette com 10 Ether 22 | 2. Eve roda um poderoso minerador que pode manipular o bloco timestamp. 23 | 3. Eve configura o block.timestamp para um número no futuro que é divisível por 24 | 15 e encontra o bloco hash alvo. 25 | 4. O bloco de Eve é incluído na chain com sucesso, Eve ganha o jogo 26 | Roulette. 27 | */ 28 | 29 | contract Roulette { 30 | uint public pastBlockTime; 31 | 32 | constructor() payable {} 33 | 34 | function spin() external payable { 35 | require(msg.value == 10 ether); // must send 10 ether to play 36 | require(block.timestamp != pastBlockTime); // only 1 transaction per block 37 | 38 | pastBlockTime = block.timestamp; 39 | 40 | if (block.timestamp % 15 == 0) { 41 | (bool sent, ) = msg.sender.call{value: address(this).balance}(""); 42 | require(sent, "Failed to send Ether"); 43 | } 44 | } 45 | } 46 | ``` 47 | 48 | #### Técnicas preventivas 49 | 50 | * Não use `block.timestamp` para uma fonte de entropia e número aleatório 51 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/call.md: -------------------------------------------------------------------------------- 1 | # Call 2 | 3 | `call` es una función de bajo nivel para interactuar con otros contratos. 4 | 5 | Este es el método recomendado a usar cuando solo estás enviado Ether a través de la llamada de la función `fallback`. 6 | 7 | Ahora bien, esta no es la manera recomendada de llamar a las funciones existentes. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract Receiver { 14 | event Received(address caller, uint amount, string message); 15 | 16 | fallback() external payable { 17 | emit Received(msg.sender, msg.value, "Fallback was called"); 18 | } 19 | 20 | function foo(string memory _message, uint _x) public payable returns (uint) { 21 | emit Received(msg.sender, msg.value, _message); 22 | 23 | return _x + 1; 24 | } 25 | } 26 | 27 | contract Caller { 28 | event Response(bool success, bytes data); 29 | 30 | // Imaginemos que el contrato invocado Caller no tiene código fuente para 31 | // cl contrato Receiver, pero si sabemos la dirección del contrato Receiver y la función para llamar. 32 | function testCallFoo(address payable _addr) public payable { 33 | // Puedes enviar Ether y personalizar la cantidad de gas 34 | (bool success, bytes memory data) = _addr.call{value: msg.value, gas: 5000}( 35 | abi.encodeWithSignature("foo(string,uint256)", "call foo", 123) 36 | ); 37 | 38 | emit Response(success, data); 39 | } 40 | 41 | // Invocar a una función que no existe desencadena la función fallback. 42 | function testCallDoesNotExist(address _addr) public { 43 | (bool success, bytes memory data) = _addr.call( 44 | abi.encodeWithSignature("doesNotExist()") 45 | ); 46 | 47 | emit Response(success, data); 48 | } 49 | } 50 | ``` 51 | -------------------------------------------------------------------------------- /src/apostila/13.-memory-vs-storage.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 13. Memory vs Storage 3 | --- 4 | ::: tip 5 | Há certas formas de manipular os dados dentro das blockchains e cada uma é 6 | feita de formas diferentes pelo minerador que vai executar o contrato, isso 7 | implica em diferentes custos de gás. 8 | ::: 9 | 10 | ## Storage 11 | 12 | Dados que irão persistir na blockchain e serão armazenados por tempo indefinido (ou definido) dentro dos registros distribuídos entre todos os nós da rede. 13 | 14 | Toda variável definida fora de funções será armazenada dessa forma por padrão. Variáveis dentro de funções precisam do parâmetro _storage_ para que sejam gravadas na blockchain. 15 | 16 | ![](<../assets/image(48).png>) 17 | 18 | ## Memory & Calldata 19 | 20 | Esse tipo de armazenamento será temporário e somente durante tempo de execução, ou seja esse dado só irá existir enquanto a função ou instrução estiver sendo executada, dados guardados em variáveis do tipo memory ou calldata não serão armazenados. Há uma diferença relevante entre as duas operações e abaixo veremos quando usar uma ou outra. 21 | 22 | ### memory: pode ser alterado 23 | 24 | Quando passamos parâmetros para uma função e utilizamos memory como indicador de tipo de armazenamento nós temos permissão para alterar esse dado dentro da função caso seja do nosso interesse. 25 | 26 | ![](<../assets/image(96).png>) 27 | 28 | ### calldata: não pode ser alterado 29 | 30 | Já quando utilizamos calldata não temos permissão para alterar o dado que foi passado para a função. 31 | 32 | ![](<../assets/image(6).png>) 33 | 34 | ## Custos: Storage vs Memory vs Calldata 35 | 36 | _Storage_ é o mais caro pois guarda os dados dentro da blockchain, seguido de _memory_ que é bem mais barato pois não armazena nada mas utiliza mais OPCODES que _calldata_ que acaba por ser o mais barato de todos os tipos de armazenamento. 37 | 38 | -------------------------------------------------------------------------------- /src/es/exemplos/hacks/ignorar-a-verificacao-do-tamanho-do-contrato.md: -------------------------------------------------------------------------------- 1 | # Ignorar a Verificação do Tamanho do Contrato 2 | 3 | #### Vulnerabilidade 4 | 5 | Se o endereço for um contrato, o tamanho do código armazenado no endereço será maior que 0 certo? 6 | 7 | Vamos ver como podemos criar um contrato com tamanho de código retornado `extcodesize` igual a 0. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract Target { 14 | function isContract(address account) public view returns (bool) { 15 | // Esse método tem como base o extcodesize, que retorna 0 para contratos 16 | // em construção, desde que o código seja somente armazenado no 17 | // final da execução do constructor. 18 | uint size; 19 | assembly { 20 | size := extcodesize(account) 21 | } 22 | return size > 0; 23 | } 24 | 25 | bool public pwned = false; 26 | 27 | function protected() external { 28 | require(!isContract(msg.sender), "no contract allowed"); 29 | pwned = true; 30 | } 31 | } 32 | 33 | contract FailedAttack { 34 | // Tentativa de chamar Target.protected falhará, 35 | // Chamadas de bloco alvo do contrato 36 | function pwn(address _target) external { 37 | // Isso vai falhar 38 | Target(_target).protected(); 39 | } 40 | } 41 | 42 | contract Hack { 43 | bool public isContract; 44 | address public addr; 45 | 46 | // Quando o contrato está sendo criado, o tamanho do código (extcodesize) é 0. 47 | // Isso vai ignorar a verificação do isContract() 48 | constructor(address _target) { 49 | isContract = Target(_target).isContract(address(this)); 50 | addr = address(this); 51 | // Isso vai funcionar 52 | Target(_target).protected(); 53 | } 54 | } 55 | ``` 56 | -------------------------------------------------------------------------------- /src/exemplos/hacks/ignorar-a-verificacao-do-tamanho-do-contrato.md: -------------------------------------------------------------------------------- 1 | # Ignorar a Verificação do Tamanho do Contrato 2 | 3 | #### Vulnerabilidade 4 | 5 | Se o endereço for um contrato, o tamanho do código armazenado no endereço será maior que 0 certo? 6 | 7 | Vamos ver como podemos criar um contrato com tamanho de código retornado `extcodesize` igual a 0. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | contract Target { 14 | function isContract(address account) public view returns (bool) { 15 | // Esse método tem como base o extcodesize, que retorna 0 para contratos 16 | // em construção, desde que o código seja somente armazenado no 17 | // final da execução do constructor. 18 | uint size; 19 | assembly { 20 | size := extcodesize(account) 21 | } 22 | return size > 0; 23 | } 24 | 25 | bool public pwned = false; 26 | 27 | function protected() external { 28 | require(!isContract(msg.sender), "no contract allowed"); 29 | pwned = true; 30 | } 31 | } 32 | 33 | contract FailedAttack { 34 | // Tentativa de chamar Target.protected falhará, 35 | // Chamadas de bloco alvo do contrato 36 | function pwn(address _target) external { 37 | // Isso vai falhar 38 | Target(_target).protected(); 39 | } 40 | } 41 | 42 | contract Hack { 43 | bool public isContract; 44 | address public addr; 45 | 46 | // Quando o contrato está sendo criado, o tamanho do código (extcodesize) é 0. 47 | // Isso vai ignorar a verificação do isContract() 48 | constructor(address _target) { 49 | isContract = Target(_target).isContract(address(this)); 50 | addr = address(this); 51 | // Isso vai funcionar 52 | Target(_target).protected(); 53 | } 54 | } 55 | ``` 56 | -------------------------------------------------------------------------------- /src/apostila/12.-enums.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 12. Enums 3 | --- 4 | ::: tip 5 | Servem para categorização de variáveis. Ao invés de gerenciarmos categorias de 6 | variáveis através de mappings usamos Enums por serem mais baratos. Veja alguns 7 | exemplos abaixo. 8 | ::: 9 | 10 | ## Declarando Enum 11 | 12 | Quando declaramos um Enum estamos criando um _tipo de dado_, assim como string é o _tipo_ de dado para **textos**, uint é o _tipo_ de dado para **inteiros** e _bool_ é o tipo **verdadeiro** ou **falso**. 13 | 14 | Para criar _**tipo-categoria**_ (Enums) declaramos primeiro seu nome e dentro de chaves os seus valores, como no exemplo abaixo. 15 | 16 | ![](<../assets/image(25).png>) 17 | 18 | ## Instanciando e Utilizando 19 | 20 | Como todas as outras variáveis nós primeiros passamos o tipo e depois o nome. No exemplo anterior criamos o tipo **STATE** (_uppercase_) e agora iremos instancia-lo dentro da variável **state(_**lowercase**_). 21 | 22 | Em seguida, suponhamos que temos usuários cadastrados no sistema e um usuário será "marcado" como Ativo, para isso criamos uma função chamada setToAtivo que irá alterar a variável state para STATE.ATIVO 23 | 24 | ![](<../assets/image(45).png>) 25 | 26 | Outro exemplo para alterar o estado de um usuário, criamos uma condição para somente mudar um usuário para INATIVO caso ele já esteja marcado como ATIVO. 27 | 28 | ![](<../assets/image(49).png>) 29 | 30 | ## Argumento em Funções 31 | 32 | Enums podem ser passados como argumentos para funções e assim como qualquer outro tipo de variável primeiros passamos como parâmetro o seu tipo e depois a variável que conterá o Enum. 33 | 34 | ![](<../assets/image(93).png>) 35 | 36 | ## Dentro de Structs 37 | 38 | A essa altura você deve ter entendido que um Enum é um tipo de dado como outro qualquer então você pode utiliza-lo até mesmo dentro de Structs, Mappings ou ainda dentro de Arrays. 39 | 40 | ![](<../assets/image(7).png>) 41 | -------------------------------------------------------------------------------- /src/es/apostila/1.-estrutura-de-contratos-inteligentes.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 1. Estructura de los Contratos Inteligentes 3 | --- 4 | ::: tip 5 | Los contratos inteligentes son conjuntos predefinidos de reglas matemáticas. Estas reglas pueden estar condicionadas a ciertos contextos, por ejemplo: sólo ejecutar si es X día del año, o solo ejecutar cada 3 días, etc… 6 | ::: 7 | 8 | Son realmente infinitas las posibilidades de lo que puedes hacer con ellos, pero su funcionamiento se resume en: 9 | 10 | ![estructura básica del contrato inteligente](<../../assets/image(108).png>) 11 | 12 | ### Definiendo la versión del lenguaje. 13 | 14 | El comando pragma es utilizado para definir cuál será la versión de solidity a ser implementada en el contrato. 15 | 16 | ```solidity 17 | pragma solidity 0.8.11; //Define la versión del lenguaje 18 | ``` 19 | 20 | Observe el parámetro .8, entre .0 y .11. Este indica la versión principal, significando que un compilador que ejecute la versión 0.8.12 también funcionará, así como 0.8.12 o .13. 21 | 22 | ### Importación de bibliotecas y reutilización de código. 23 | 24 | ```solidity 25 | import 'código_escrito_por_otros_devs.sol'; 26 | ``` 27 | 28 | En el mundo del desarrollo estamos siempre reutilizando código listo e implementado, y deberías acostumbrarte a ello. Pero ten en cuenta que cada lenguaje tiene su propio estándar de cómo importar el código. 29 | 30 | Para una explicación más detallada sobre cómo importar y reutilizar contratos, consulte la sección [23. Bibliotecas (Libraries).](extra-avancado/23.-bibliotecas-librarys.md "mention") 31 | 32 | ### Código del contrato. 33 | 34 | ```solidity 35 | contract MiContrato{ 36 | 37 | address mi_cartera = 0xCf48d9ae072758c125804791Cf8c4D390B460c19; 38 | 39 | function transferencia() external {} 40 | modifier únicamenteAdministrador() {} 41 | ... 42 | } 43 | ``` 44 | 45 | Dentro del _contrato_ se encuentran todas las reglas y condiciones del mismo. 46 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/contrato-que-cria-outros-contratos.md: -------------------------------------------------------------------------------- 1 | # Contrato que cria outros Contratos 2 | 3 | Contratos podem ser criados por outros contratos usando a palavra-chave `new`. A partir da versão 0.8.0, a palavra-chave `new` suporta o recurso `create2` por meio da especificação de opções `salt`. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract Car { 10 | address public owner; 11 | string public model; 12 | address public carAddr; 13 | 14 | constructor(address _owner, string memory _model) payable { 15 | owner = _owner; 16 | model = _model; 17 | carAddr = address(this); 18 | } 19 | } 20 | 21 | contract CarFactory { 22 | Car[] public cars; 23 | 24 | function create(address _owner, string memory _model) public { 25 | Car car = new Car(_owner, _model); 26 | cars.push(car); 27 | } 28 | 29 | function createAndSendEther(address _owner, string memory _model) public payable { 30 | Car car = (new Car){value: msg.value}(_owner, _model); 31 | cars.push(car); 32 | } 33 | 34 | function create2(address _owner, string memory _model, bytes32 _salt) public { 35 | Car car = (new Car){salt: _salt}(_owner, _model); 36 | cars.push(car); 37 | } 38 | 39 | function create2AndSendEther(address _owner, string memory _model, bytes32 _salt) public payable { 40 | Car car = (new Car){value: msg.value, salt: _salt}(_owner, _model); 41 | cars.push(car); 42 | } 43 | 44 | function getCar(uint _index) 45 | public 46 | view 47 | returns ( 48 | address owner, 49 | string memory model, 50 | address carAddr, 51 | uint balance 52 | ) 53 | { 54 | Car car = cars[_index]; 55 | 56 | return (car.owner(), car.model(), car.carAddr(), address(car).balance); 57 | } 58 | } 59 | ``` 60 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/contrato-que-cria-outros-contratos.md: -------------------------------------------------------------------------------- 1 | # Contratos que crean otros Contratos 2 | 3 | Los contratos pueden ser creados por otros contratos usando la palabra reservada `new`. Desde la versión 0.8.0, la palabra `new` soporta la función `create2` especificando la característica `salt`. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | contract Car { 10 | address public owner; 11 | string public model; 12 | address public carAddr; 13 | 14 | constructor(address _owner, string memory _model) payable { 15 | owner = _owner; 16 | model = _model; 17 | carAddr = address(this); 18 | } 19 | } 20 | 21 | contract CarFactory { 22 | Car[] public cars; 23 | 24 | function create(address _owner, string memory _model) public { 25 | Car car = new Car(_owner, _model); 26 | cars.push(car); 27 | } 28 | 29 | function createAndSendEther(address _owner, string memory _model) public payable { 30 | Car car = (new Car){value: msg.value}(_owner, _model); 31 | cars.push(car); 32 | } 33 | 34 | function create2(address _owner, string memory _model, bytes32 _salt) public { 35 | Car car = (new Car){salt: _salt}(_owner, _model); 36 | cars.push(car); 37 | } 38 | 39 | function create2AndSendEther(address _owner, string memory _model, bytes32 _salt) public payable { 40 | Car car = (new Car){value: msg.value, salt: _salt}(_owner, _model); 41 | cars.push(car); 42 | } 43 | 44 | function getCar(uint _index) 45 | public 46 | view 47 | returns ( 48 | address owner, 49 | string memory model, 50 | address carAddr, 51 | uint balance 52 | ) 53 | { 54 | Car car = cars[_index]; 55 | 56 | return (car.owner(), car.model(), car.carAddr(), address(car).balance); 57 | } 58 | } 59 | ``` 60 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/enum.md: -------------------------------------------------------------------------------- 1 | # Enum 2 | 3 | Solidity suporta enumeráveis e eles são úteis para escolha do modelo e mantêm o controle do estado. 4 | 5 | Enums podem ser declarados fora do contrato. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract Enum { 12 | // Enum representando status de envio 13 | enum Status { 14 | Pending, 15 | Shipped, 16 | Accepted, 17 | Rejected, 18 | Canceled 19 | } 20 | 21 | // Valor padrão é o primeiro elemento listado na 22 | // definição do tipo, nesse caso "Pendente" 23 | Status public status; 24 | 25 | // Retorna uint 26 | // Pendente - 0 27 | // Enviado - 1 28 | // Aceito - 2 29 | // Recusado - 3 30 | // Cancelado - 4 31 | function get() public view returns (Status) { 32 | return status; 33 | } 34 | 35 | // Atualiza status passando uint para input 36 | function set(Status _status) public { 37 | status = _status; 38 | } 39 | 40 | // Você pode atualizar para um enum específico como este 41 | function cancel() public { 42 | status = Status.Canceled; 43 | } 44 | 45 | // delete reinicia o enum para seu primeiro valor, 0 46 | function reset() public { 47 | delete status; 48 | } 49 | } 50 | ``` 51 | 52 | #### Declarando e Importando Enum 53 | 54 | Arquivo no qual o enum é declarado 55 | 56 | ```solidity 57 | // SPDX-License-Identifier: MIT 58 | pragma solidity ^0.8.3; 59 | // É salvo como 'EnumDeclaration.sol' 60 | 61 | enum Status { 62 | Pending, 63 | Shipped, 64 | Accepted, 65 | Rejected, 66 | Canceled 67 | } 68 | ``` 69 | 70 | Arquivo que importa o enum acima 71 | 72 | ```solidity 73 | // SPDX-License-Identifier: MIT 74 | pragma solidity ^0.8.3; 75 | 76 | import "./EnumDeclaration.sol"; 77 | 78 | contract Enum { 79 | Status public status; 80 | } 81 | ``` 82 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/chamando-contratos-de-classe-pai.md: -------------------------------------------------------------------------------- 1 | # Chamando Contratos de Classe Pai 2 | 3 | Contratos de classe pai podem ser chamados diretamente ou usando a palavra-chave `super`. 4 | 5 | Usando a palavra-chave `super`, todos os contratos de classe pai imediatos serão chamados. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | /* Árvore de herança 12 | A 13 | / \ 14 | B C 15 | \ / 16 | D 17 | */ 18 | 19 | contract A { 20 | // Isto é chamado um evento. Você pode emitir eventos de sua função 21 | // e eles serão logados no log da transação. 22 | // No nosso caso, isso será útil para traçar chamadas de função. 23 | event Log(string message); 24 | 25 | function foo() public virtual { 26 | emit Log("A.foo called"); 27 | } 28 | 29 | function bar() public virtual { 30 | emit Log("A.bar called"); 31 | } 32 | } 33 | 34 | contract B is A { 35 | function foo() public virtual override { 36 | emit Log("B.foo called"); 37 | A.foo(); 38 | } 39 | 40 | function bar() public virtual override { 41 | emit Log("B.bar called"); 42 | super.bar(); 43 | } 44 | } 45 | 46 | contract C is A { 47 | function foo() public virtual override { 48 | emit Log("C.foo called"); 49 | A.foo(); 50 | } 51 | 52 | function bar() public virtual override { 53 | emit Log("C.bar called"); 54 | super.bar(); 55 | } 56 | } 57 | 58 | contract D is B, C { 59 | // Tente: 60 | // - Chame D.foo e verifique os logs da transação. 61 | // Embora D herde A, B e C, ele só chamou C e depois A. 62 | // - Chame D.bar e verifique os logs da transação 63 | // D chamou C, depois B, e finalmente A. 64 | // Embora super foi chamado 2 vezes (por B e C) ele só chamou A uma vez. 65 | 66 | function foo() public override(B, C) { 67 | super.foo(); 68 | } 69 | 70 | function bar() public override(B, C) { 71 | super.bar(); 72 | } 73 | } 74 | ``` 75 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/enum.md: -------------------------------------------------------------------------------- 1 | # Enum 2 | 3 | Solidity soporta enumerables, estos son útiles para modelos con opciones y mantiene un seguimiento del estado. 4 | 5 | Enums pueden ser declarados afuera del contrato. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract Enum { 12 | // Enum representando el status de envío 13 | enum Status { 14 | Pending, 15 | Shipped, 16 | Accepted, 17 | Rejected, 18 | Canceled 19 | } 20 | 21 | // El valor por defecto es el primer elemento listado en 22 | // la definición del tipo, en este caso "Pending" 23 | Status public status; 24 | 25 | // Devuelve uint 26 | // Pending - 0 27 | // Shipped - 1 28 | // Accepted - 2 29 | // Rejected - 3 30 | // Canceled - 4 31 | function get() public view returns (Status) { 32 | return status; 33 | } 34 | 35 | // Actualiza el status pasando uint como entrada 36 | function set(Status _status) public { 37 | status = _status; 38 | } 39 | 40 | // Puede actualizar a un enum específico así 41 | function cancel() public { 42 | status = Status.Canceled; 43 | } 44 | 45 | // delete reinicia el enum a su primer valor, 0 46 | function reset() public { 47 | delete status; 48 | } 49 | } 50 | ``` 51 | 52 | #### Declarando e Importando Enum 53 | 54 | Archivo donde el enum está declarado 55 | 56 | ```solidity 57 | // SPDX-License-Identifier: MIT 58 | pragma solidity ^0.8.3; 59 | // Está guardado como 'EnumDeclaration.sol' 60 | 61 | enum Status { 62 | Pending, 63 | Shipped, 64 | Accepted, 65 | Rejected, 66 | Canceled 67 | } 68 | ``` 69 | 70 | Archivo que importa el enum de arriba 71 | 72 | ```solidity 73 | // SPDX-License-Identifier: MIT 74 | pragma solidity ^0.8.3; 75 | 76 | import "./EnumDeclaration.sol"; 77 | 78 | contract Enum { 79 | Status public status; 80 | } 81 | ``` 82 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/interface.md: -------------------------------------------------------------------------------- 1 | # Interface 2 | 3 | Você pode interagir com outros contratos declarando uma `Interface`. 4 | 5 | Interface 6 | 7 | * não pode ter nenhuma função implementada 8 | * pode herdar de outras interfaces 9 | * todas as funções declaradas devem ser externas 10 | * não pode declarar um constructor 11 | * não pode declarar variáveis de estado 12 | 13 | ```solidity 14 | // SPDX-License-Identifier: MIT 15 | pragma solidity ^0.8.3; 16 | 17 | contract Counter { 18 | uint public count; 19 | 20 | function increment() external { 21 | count += 1; 22 | } 23 | } 24 | 25 | interface ICounter { 26 | function count() external view returns (uint); 27 | 28 | function increment() external; 29 | } 30 | 31 | contract MyContract { 32 | function incrementCounter(address _counter) external { 33 | ICounter(_counter).increment(); 34 | } 35 | 36 | function getCount(address _counter) external view returns (uint) { 37 | return ICounter(_counter).count(); 38 | } 39 | } 40 | 41 | // Exemplo de Uniswap 42 | interface UniswapV2Factory { 43 | function getPair(address tokenA, address tokenB) 44 | external 45 | view 46 | returns (address pair); 47 | } 48 | 49 | interface UniswapV2Pair { 50 | function getReserves() 51 | external 52 | view 53 | returns ( 54 | uint112 reserve0, 55 | uint112 reserve1, 56 | uint32 blockTimestampLast 57 | ); 58 | } 59 | 60 | contract UniswapExample { 61 | address private factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f; 62 | address private dai = 0x6B175474E89094C44Da98b954EedeAC495271d0F; 63 | address private weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; 64 | 65 | function getTokenReserves() external view returns (uint, uint) { 66 | address pair = UniswapV2Factory(factory).getPair(dai, weth); 67 | (uint reserve0, uint reserve1, ) = UniswapV2Pair(pair).getReserves(); 68 | return (reserve0, reserve1); 69 | } 70 | } 71 | ``` 72 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/interface.md: -------------------------------------------------------------------------------- 1 | # Interfaz 2 | 3 | Puedes interactuar con otros contratos declarando la `Interface`. 4 | 5 | Interfaz 6 | 7 | * No puede tener ninguna función implementada 8 | * Puede heredar de otras interfaces 9 | * Todas las funciones declaradas deben ser externas 10 | * No puede declarar un constructor 11 | * No puede declarar variables de estado 12 | 13 | ```solidity 14 | // SPDX-License-Identifier: MIT 15 | pragma solidity ^0.8.3; 16 | 17 | contract Counter { 18 | uint public count; 19 | 20 | function increment() external { 21 | count += 1; 22 | } 23 | } 24 | 25 | interface ICounter { 26 | function count() external view returns (uint); 27 | 28 | function increment() external; 29 | } 30 | 31 | contract MyContract { 32 | function incrementCounter(address _counter) external { 33 | ICounter(_counter).increment(); 34 | } 35 | 36 | function getCount(address _counter) external view returns (uint) { 37 | return ICounter(_counter).count(); 38 | } 39 | } 40 | 41 | // Ejemplo de Uniswap 42 | interface UniswapV2Factory { 43 | function getPair(address tokenA, address tokenB) 44 | external 45 | view 46 | returns (address pair); 47 | } 48 | 49 | interface UniswapV2Pair { 50 | function getReserves() 51 | external 52 | view 53 | returns ( 54 | uint112 reserve0, 55 | uint112 reserve1, 56 | uint32 blockTimestampLast 57 | ); 58 | } 59 | 60 | contract UniswapExample { 61 | address private factory = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f; 62 | address private dai = 0x6B175474E89094C44Da98b954EedeAC495271d0F; 63 | address private weth = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2; 64 | 65 | function getTokenReserves() external view returns (uint, uint) { 66 | address pair = UniswapV2Factory(factory).getPair(dai, weth); 67 | (uint reserve0, uint reserve1, ) = UniswapV2Pair(pair).getReserves(); 68 | return (reserve0, reserve1); 69 | } 70 | } 71 | ``` 72 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/chamando-contratos-de-classe-pai.md: -------------------------------------------------------------------------------- 1 | # Invocando Contratos padres 2 | 3 | Contratos padres pueden ser invocados directamente o usando la palabra reservada `super`. 4 | 5 | Usando la palabra reservada `super`, todos los contratos padres inmediatos serán invocados. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | /* Árbol de herencia 12 | A 13 | / \ 14 | B C 15 | \ / 16 | D 17 | */ 18 | 19 | contract A { 20 | // Esto es llamado un evento. Tu puedes emitir eventos desde tu función 21 | // y ellos son registrados en el log de transacción. 22 | // En nuestro caso, esto será útil para rastrear llamadas de función. 23 | event Log(string message); 24 | 25 | function foo() public virtual { 26 | emit Log("A.foo called"); 27 | } 28 | 29 | function bar() public virtual { 30 | emit Log("A.bar called"); 31 | } 32 | } 33 | 34 | contract B is A { 35 | function foo() public virtual override { 36 | emit Log("B.foo called"); 37 | A.foo(); 38 | } 39 | 40 | function bar() public virtual override { 41 | emit Log("B.bar called"); 42 | super.bar(); 43 | } 44 | } 45 | 46 | contract C is A { 47 | function foo() public virtual override { 48 | emit Log("C.foo called"); 49 | A.foo(); 50 | } 51 | 52 | function bar() public virtual override { 53 | emit Log("C.bar called"); 54 | super.bar(); 55 | } 56 | } 57 | 58 | contract D is B, C { 59 | // Intenta: 60 | // - Llama a D.foo y revisa los logs de la transacción. 61 | // Si bien D hereda A, B y C, solo se llamó a C y después A. 62 | // - Llama a D.bar y revisa los logs de la transacción 63 | // D llamó a C, después B, y finalmente A. 64 | // Sin embargo super fue invocado 2 veces (por B e C) y solo llamó a A una vez. 65 | 66 | function foo() public override(B, C) { 67 | super.foo(); 68 | } 69 | 70 | function bar() public override(B, C) { 71 | super.bar(); 72 | } 73 | } 74 | ``` 75 | -------------------------------------------------------------------------------- /src/apostila/15.-funcoes-pagaveis-function-payable.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 17. Funções e Endereços pagáveis (payable) 3 | --- 4 | ::: tip 5 | Para que um contrato possa receber Ether ou o Token nativo da Blockchain EVM 6 | que estiver sendo executado ele precisa ter funções payable e para enviar é 7 | necessário utilizar endereços do tipo payable. 8 | ::: 9 | 10 | ## Funções pagáveis 11 | 12 | Somente funções que NÃO sejam do tipo _**view**_ podem receber Ether. 13 | 14 | ### Enviando Ether para o contrato 15 | 16 | O parâmetro payable serve para que o contrato possa receber e manipular saldos. Lembrando que estamos falando Ether ou token nativo como BNB, MATIC entre outros e não de Tokens no formato ERC-20. 17 | 18 | ![](<../assets/image(97).png>) 19 | 20 | ### Consultando saldo do contrato 21 | 22 | Para saber qual o saldo do contrato em que está sendo executado a função utiliza-se a instrução built-in _address(this).balance_; 23 | 24 | ![](<../assets/image(83).png>) 25 | 26 | ### Payable como Parâmetro 27 | 28 | Anteriormente você viu que para contrato possa RECEBER Ether é preciso o parâmetro payable esteja presente no cabeçalho da função. 29 | 30 | Para que o contrato possa ENVIAR ele precisa lidar com endereços do tipo payable. No exemplo abaixo inserimos esse parâmetro como instrução adicional ao endereço que será passado para função. 31 | 32 | ![](<../assets/image(79).png>) 33 | 34 | ## Endereços pagáveis 35 | 36 | No exemplo abaixo será transferido 1 ether que sairá do saldo do contrato para o endereço passado como parâmetro _**quemrecebe** _ para a função. 37 | 38 | ![](<../assets/image(73).png>) 39 | 40 | Já nesse caso, será uma transferência que irá para quem está chamando (msg.sender) a função do _**saque**_ do contrato. 41 | 42 | ![](<../assets/image(40).png>) 43 | 44 | Há duas formas de fazer transferências: usando a função _**send()**_ ou a função _**transfer()**_ e a diferença entre elas é que a função send() irá retornar true ou false e a função _transfer()_ não retorna nada caso a transferência tenha acontecido e irá reverter toda a transação caso tenha falhado. 45 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/modificador-de-funcao.md: -------------------------------------------------------------------------------- 1 | # Modificador de função 2 | 3 | Modificadores são códigos que podem ser rodados antes e / ou depois de chamar uma função. 4 | 5 | Modificadores podem ser usados para: 6 | 7 | * Restrição de acesso 8 | * Validação de entradas 9 | * Proteção contra hack de reentrada 10 | 11 | ```solidity 12 | // SPDX-License-Identifier: MIT 13 | pragma solidity ^0.8.3; 14 | 15 | contract FunctionModifier { 16 | // Vamos utilizar essas variáveis para demonstrar como usar 17 | // modificadores. 18 | address public owner; 19 | uint public x = 10; 20 | bool public locked; 21 | 22 | constructor() { 23 | // Define o remetente da transação como dono do contrato. 24 | owner = msg.sender; 25 | } 26 | 27 | // Modificador para checar se quem chama é o proprietário 28 | // do contrato. 29 | modifier onlyOwner() { 30 | require(msg.sender == owner, "Not owner"); 31 | // Underscore é um caractere especial somente usado dentro 32 | // de um modificador de função que diz ao Solidity para 33 | // executar o resto do código. 34 | _; 35 | } 36 | 37 | // Modificadores podem receber input. Esse modificador checa se 38 | // o endereço passado não é endereço zero. 39 | modifier validAddress(address _addr) { 40 | require(_addr != address(0), "Not valid address"); 41 | _; 42 | } 43 | 44 | function changeOwner(address _newOwner) public onlyOwner validAddress(_newOwner) { 45 | owner = _newOwner; 46 | } 47 | 48 | // Modificadores podem ser chamados antes e / ou depois de uma função. 49 | // Esse modificador impede que uma função seja chamada enquanto 50 | // esteja sendo executada. 51 | modifier noReentrancy() { 52 | require(!locked, "No reentrancy"); 53 | 54 | locked = true; 55 | _; 56 | locked = false; 57 | } 58 | 59 | function decrement(uint i) public noReentrancy { 60 | x -= i; 61 | 62 | if (i > 1) { 63 | decrement(i - 1); 64 | } 65 | } 66 | } 67 | ``` 68 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/modificador-de-funcao.md: -------------------------------------------------------------------------------- 1 | # Modificador de función 2 | 3 | Modificadores son códigos que pueden ser ejecutados antes y / o después de invocar una función. 4 | 5 | Los modificadores pueden ser usados para: 6 | 7 | * Restricción de acceso 8 | * Validación de entradas 9 | * Protección contra hack de reentrada (reentrancy hack) 10 | 11 | ```solidity 12 | // SPDX-License-Identifier: MIT 13 | pragma solidity ^0.8.3; 14 | 15 | contract FunctionModifier { 16 | // Usaremos estas variables para demostrar como usar los 17 | // modificadores. 18 | address public owner; 19 | uint public x = 10; 20 | bool public locked; 21 | 22 | constructor() { 23 | // Establece al emisor de la transacción como dueño del contrato. 24 | owner = msg.sender; 25 | } 26 | 27 | // Modificador que verifica que quien llama es el dueño 28 | // del contrato. 29 | modifier onlyOwner() { 30 | require(msg.sender == owner, "Not owner"); 31 | // Underscore es un carácter especial usado solamente dentro 32 | // de un modificador de función que le dice a Solidity que 33 | // ejecute el resto del código. 34 | _; 35 | } 36 | 37 | // Modificadores pueden recibir entradas. Este modificador verifica si 38 | // la dirección recibida no es la dirección cero. 39 | modifier validAddress(address _addr) { 40 | require(_addr != address(0), "Not valid address"); 41 | _; 42 | } 43 | 44 | function changeOwner(address _newOwner) public onlyOwner validAddress(_newOwner) { 45 | owner = _newOwner; 46 | } 47 | 48 | // Modificadores pueden ser invocados antes y / o después de uma función. 49 | // Este modificador previene que una función sea invocada mientras 50 | // esté siendo ejecutada. 51 | modifier noReentrancy() { 52 | require(!locked, "No reentrancy"); 53 | 54 | locked = true; 55 | _; 56 | locked = false; 57 | } 58 | 59 | function decrement(uint i) public noReentrancy { 60 | x -= i; 61 | 62 | if (i > 1) { 63 | decrement(i - 1); 64 | } 65 | } 66 | } 67 | ``` -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/funcao.md: -------------------------------------------------------------------------------- 1 | # Função 2 | 3 | Existem diversas formas de retornar saídas de uma função. 4 | 5 | Funções públicas não podem aceitar certos tipos de dados como entradas e saídas 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract Function { 12 | // Funções podem retornar valores múltiplos. 13 | function returnMany() 14 | public 15 | pure 16 | returns ( 17 | uint, 18 | bool, 19 | uint 20 | ) 21 | { 22 | return (1, true, 2); 23 | } 24 | 25 | // Valores retornados podem ser nomeados. 26 | function named() 27 | public 28 | pure 29 | returns ( 30 | uint x, 31 | bool b, 32 | uint y 33 | ) 34 | { 35 | return (1, true, 2); 36 | } 37 | 38 | // Valores retornados podem ser atribuídos a seus nomes. 39 | // Nesse caso a afirmação retornada pode ser omitida. 40 | function assigned() 41 | public 42 | pure 43 | returns ( 44 | uint x, 45 | bool b, 46 | uint y 47 | ) 48 | { 49 | x = 1; 50 | b = true; 51 | y = 2; 52 | } 53 | 54 | // Usa atribuição de desestruturação quando chama uma outra 55 | // função que retorna múltiplos valores. 56 | function destructingAssigments() 57 | public 58 | pure 59 | returns ( 60 | uint, 61 | bool, 62 | uint, 63 | uint, 64 | uint 65 | ) 66 | { 67 | (uint i, bool b, uint j) = returnMany(); 68 | 69 | // Valores podem ser deixados de fora. 70 | (uint x, , uint y) = (4, 5, 6); 71 | 72 | return (i, b, j, x, y); 73 | } 74 | 75 | // Não pode usar mapa nem para entrada nem para saída 76 | 77 | // Pode usar matriz para entrada 78 | function arrayInput(uint[] memory _arr) public {} 79 | 80 | // Pode usar matriz para saída 81 | uint[] public arr; 82 | 83 | function arrayOutput() public view returns (uint[] memory) { 84 | return arr; 85 | } 86 | } 87 | ``` 88 | -------------------------------------------------------------------------------- /src/es/exemplos/hacks/fonte-de-aleatoriedade.md: -------------------------------------------------------------------------------- 1 | # Fonte de Aleatoriedade 2 | 3 | #### Vulnerabilidade 4 | 5 | `blockhash` e `block.timestamp` não são fontes confiáveis de ateatoriedade. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | /* 12 | NOTA: não pode usar blockhash no Remix, então use ganache-cli 13 | 14 | npm i -g ganache-cli 15 | ganache-cli 16 | No remix troque o ambiente para o provedor Web3 17 | */ 18 | 19 | /* 20 | GuessTheRandomNumber é um jogo onde você ganha 1 Ether se você advinhar 21 | um número pseudo aleatório gerado de um bloco de hash e timestamp. 22 | 23 | À primeira vista, parece impossível advinhar o número correto. 24 | Mas vamos ver como é fácil ganhar. 25 | 26 | 1. Alice implanta GuessTheRandomNumber com 1 Ether 27 | 2. Eve implementa Attack 28 | 3. Eve chama Attack.attack() e ganha 1 Ether 29 | 30 | O que aconteceu? 31 | Attack computou a resposta correta simplesmente copiando o código que computa 32 | o número aleatório 33 | */ 34 | 35 | contract GuessTheRandomNumber { 36 | constructor() payable {} 37 | 38 | function guess(uint _guess) public { 39 | uint answer = uint( 40 | keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp)) 41 | ); 42 | 43 | if (_guess == answer) { 44 | (bool sent, ) = msg.sender.call{value: 1 ether}(""); 45 | require(sent, "Failed to send Ether"); 46 | } 47 | } 48 | } 49 | 50 | contract Attack { 51 | receive() external payable {} 52 | 53 | function attack(GuessTheRandomNumber guessTheRandomNumber) public { 54 | uint answer = uint( 55 | keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp)) 56 | ); 57 | 58 | guessTheRandomNumber.guess(answer); 59 | } 60 | 61 | // Função Helper para checar o balanço 62 | function getBalance() public view returns (uint) { 63 | return address(this).balance; 64 | } 65 | } 66 | ``` 67 | 68 | #### Técnicas preventivas 69 | 70 | * Não use `blockhash` e `block.timestamp` como fonte de aleatoriedade 71 | -------------------------------------------------------------------------------- /src/exemplos/aplicacoes/leilao-holandes.md: -------------------------------------------------------------------------------- 1 | # Leilão Holandês 2 | 3 | Leilão holandês de NFT. 4 | 5 | #### Auction 6 | 7 | 1. O vendedor de NFT implementa este contrato estabelecendo um preço inicial para o NFT. 8 | 2. O leilão dura 7 dias. 9 | 3. O preço do NFT cai com o tempo 10 | 4. Os participantes podem comprar depositando uma quantidade de ETH maior que valor corrente computado pelo contrato inteligente. 11 | 5. O leilão termina quando alguém compra o NFT. 12 | 13 | ```solidity 14 | // SPDX-License-Identifier: MIT 15 | pragma solidity ^0.8.3; 16 | 17 | interface IERC721 { 18 | function transferFrom( 19 | address _from, 20 | address _to, 21 | uint _nftId 22 | ) external; 23 | } 24 | 25 | contract DutchAuction { 26 | event Buy(address winner, uint amount); 27 | 28 | IERC721 public immutable nft; 29 | uint public immutable nftId; 30 | 31 | address payable public seller; 32 | uint public startingPrice; 33 | uint public startAt; 34 | uint public expiresAt; 35 | uint public priceDeductionRate; 36 | address public winner; 37 | 38 | constructor( 39 | uint _startingPrice, 40 | uint _priceDeductionRate, 41 | address _nft, 42 | uint _nftId 43 | ) { 44 | seller = payable(msg.sender); 45 | startingPrice = _startingPrice; 46 | startAt = block.timestamp; 47 | expiresAt = block.timestamp + 7 days; 48 | priceDeductionRate = _priceDeductionRate; 49 | 50 | nft = IERC721(_nft); 51 | nftId = _nftId; 52 | } 53 | 54 | function buy() external payable { 55 | require(block.timestamp < expiresAt, "auction expired"); 56 | require(winner == address(0), "auction finished"); 57 | 58 | uint timeElapsed = block.timestamp - startAt; 59 | uint deduction = priceDeductionRate * timeElapsed; 60 | uint price = startingPrice - deduction; 61 | 62 | require(msg.value >= price, "ETH < price"); 63 | 64 | winner = msg.sender; 65 | nft.transferFrom(seller, msg.sender, nftId); 66 | seller.transfer(msg.value); 67 | 68 | emit Buy(msg.sender, msg.value); 69 | } 70 | } 71 | ``` 72 | -------------------------------------------------------------------------------- /src/exemplos/hacks/fonte-de-aleatoriedade.md: -------------------------------------------------------------------------------- 1 | # Fonte de Aleatoriedade 2 | 3 | #### Vulnerabilidade 4 | 5 | `blockhash` e `block.timestamp` não são fontes confiáveis de ateatoriedade. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | /* 12 | NOTA: não pode usar blockhash no Remix, então use ganache-cli 13 | 14 | npm i -g ganache-cli 15 | ganache-cli 16 | No remix troque o ambiente para o provedor Web3 17 | */ 18 | 19 | /* 20 | GuessTheRandomNumber é um jogo onde você ganha 1 Ether se você advinhar 21 | um número pseudo aleatório gerado de um bloco de hash e timestamp. 22 | 23 | À primeira vista, parece impossível advinhar o número correto. 24 | Mas vamos ver como é fácil ganhar. 25 | 26 | 1. Alice implanta GuessTheRandomNumber com 1 Ether 27 | 2. Eve implementa Attack 28 | 3. Eve chama Attack.attack() e ganha 1 Ether 29 | 30 | O que aconteceu? 31 | Attack computou a resposta correta simplesmente copiando o código que computa 32 | o número aleatório 33 | */ 34 | 35 | contract GuessTheRandomNumber { 36 | constructor() payable {} 37 | 38 | function guess(uint _guess) public { 39 | uint answer = uint( 40 | keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp)) 41 | ); 42 | 43 | if (_guess == answer) { 44 | (bool sent, ) = msg.sender.call{value: 1 ether}(""); 45 | require(sent, "Failed to send Ether"); 46 | } 47 | } 48 | } 49 | 50 | contract Attack { 51 | receive() external payable {} 52 | 53 | function attack(GuessTheRandomNumber guessTheRandomNumber) public { 54 | uint answer = uint( 55 | keccak256(abi.encodePacked(blockhash(block.number - 1), block.timestamp)) 56 | ); 57 | 58 | guessTheRandomNumber.guess(answer); 59 | } 60 | 61 | // Função Helper para checar o balanço 62 | function getBalance() public view returns (uint) { 63 | return address(this).balance; 64 | } 65 | } 66 | ``` 67 | 68 | #### Técnicas preventivas 69 | 70 | * Não use `blockhash` e `block.timestamp` como fonte de aleatoriedade 71 | -------------------------------------------------------------------------------- /src/es/exemplos/aplicacoes/leilao-holandes.md: -------------------------------------------------------------------------------- 1 | # Leilão Holandês 2 | 3 | Leilão holandês de NFT. 4 | 5 | #### Auction 6 | 7 | 1. O vendedor de NFT implementa este contrato estabelecendo um preço inicial para o NFT. 8 | 2. O leilão dura 7 dias. 9 | 3. O preço do NFT cai com o tempo 10 | 4. Os participantes podem comprar depositando uma quantidade de ETH maior que valor corrente computado pelo contrato inteligente. 11 | 5. O leilão termina quando alguém compra o NFT. 12 | 13 | ```solidity 14 | // SPDX-License-Identifier: MIT 15 | pragma solidity ^0.8.3; 16 | 17 | interface IERC721 { 18 | function transferFrom( 19 | address _from, 20 | address _to, 21 | uint _nftId 22 | ) external; 23 | } 24 | 25 | contract DutchAuction { 26 | event Buy(address winner, uint amount); 27 | 28 | IERC721 public immutable nft; 29 | uint public immutable nftId; 30 | 31 | address payable public seller; 32 | uint public startingPrice; 33 | uint public startAt; 34 | uint public expiresAt; 35 | uint public priceDeductionRate; 36 | address public winner; 37 | 38 | constructor( 39 | uint _startingPrice, 40 | uint _priceDeductionRate, 41 | address _nft, 42 | uint _nftId 43 | ) { 44 | seller = payable(msg.sender); 45 | startingPrice = _startingPrice; 46 | startAt = block.timestamp; 47 | expiresAt = block.timestamp + 7 days; 48 | priceDeductionRate = _priceDeductionRate; 49 | 50 | nft = IERC721(_nft); 51 | nftId = _nftId; 52 | } 53 | 54 | function buy() external payable { 55 | require(block.timestamp < expiresAt, "auction expired"); 56 | require(winner == address(0), "auction finished"); 57 | 58 | uint timeElapsed = block.timestamp - startAt; 59 | uint deduction = priceDeductionRate * timeElapsed; 60 | uint price = startingPrice - deduction; 61 | 62 | require(msg.value >= price, "ETH < price"); 63 | 64 | winner = msg.sender; 65 | nft.transferFrom(seller, msg.sender, nftId); 66 | seller.transfer(msg.value); 67 | 68 | emit Buy(msg.sender, msg.value); 69 | } 70 | } 71 | ``` 72 | -------------------------------------------------------------------------------- /src/es/apostila/9.-controladores-de-fluxo-if-for-while.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 9. Controladores de Flujo (if, for, while) 3 | --- 4 | ::: tip 5 | La parte más importante de toda la programación es la lógica de cómo script es programado, y los controladores de flujo son los componentes básicos de esta construcción. 6 | ::: 7 | 8 | ## If & else 9 | 10 | Se utiliza para crear condiciones que deben cumplirse para que se ejecute una determinada pieza de código. El _**else es una condición**_ que se ejecutará _**si la primera no es true**_. 11 | 12 | ```solidity 13 | if (block.number > 10000) { 14 | return true; 15 | } else { 16 | return false; 17 | } 18 | ``` 19 | 20 | ## Loop for 21 | 22 | Cuando necesitamos iterar varios elementos dentro de una matriz o mapeo, o ejecutar algo un número determinado de veces, podemos usar bucles for. 23 | 24 | ```solidity 25 | address payable [] listaDeDirecciones; 26 | 27 | function enviaParaTodos() external payable { 28 | for (uint i = 0; i < listaDeDirecciones.length; i++) { 29 | listaDeDirecciones[i].transfer(1 ether); 30 | } 31 | } 32 | ``` 33 | 34 | El valor de _**i empieza en cero**_ e irá _**sumando 1**_ hasta llegar al valor almacenado en _**listaDeDirecciones.length**_ que se encarga de devolver la longitud de la lista. De 1 a 1, el ciclo ejecutará el fragmento de código para cada dirección almacenada en _**listaDeDirecciones.**_ 35 | 36 | ## loop While 37 | 38 | Si necesitamos repetir un fragmento de código un número indefinido de veces o hasta que se cumpla una condición, usamos bucles while. 39 | 40 | ```solidity 41 | bool puedeContinuar = true; 42 | while(puedeContinuar) { 43 | //... 44 | if() { 45 | puedeContinuar = false; 46 | or 47 | break; 48 | or 49 | continue; //Saltará a la próxima iteración. 50 | } 51 | } 52 | ``` 53 | Observación: Esto puede gastar mucho gás, entonces úselo con precaución. 54 | 55 | El bucle while seguirá ejecutándose hasta que se cumplan las condiciones para que se detenga y esta condición se puede construir con _**if**_ seguido de _**break**_, que es el código que detendrá todo. Hay otra instrucción en este código que es _**continue**_, responsable de hacer que el ciclo "salte" al principio en lugar de ejecutarse hasta el final y comenzar nuevamente. 56 | -------------------------------------------------------------------------------- /src/es/apostila/15.-modificadores.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 15. Modificadores 3 | --- 4 | ::: tip 5 | Son fragmentos de código que se ejecutarán antes que las funciones. Una de las aplicaciones más populares es la control de acceso para que sólo direcciones específicas puedan ejecutar una función. 6 | ::: 7 | 8 | ## Declarando un modificador 9 | 10 | En nuestro ejemplo, vamos a crear un modificador que verificará si la dirección que está llamando a la función es la dirección que está guardada como administrador en la variable _admin._ Si la instrucción _require_ devuelve un _True_, entonces se ejecutará el código \_; que significa: ejecutar lo que viene después. 11 | 12 | Esto significa que si el código se detiene en _require_, no ejecutará la declaración _underline_, por lo tanto, no ejecutará el código de la función que viene después. 13 | 14 | ```solidity 15 | function saqueEth() external onlyAdmin { 16 | //... 17 | } 18 | 19 | modifier onlyAdmin() { 20 | require(msg.sender == admin); 21 | _; //Llamará a la función en la que esté contenido. 22 | } 23 | ``` 24 | 25 | ## Pasando parámetros 26 | 27 | Para que los modificadores reciban parámetros, deben pasarse a las funciones en las que están insertados y tener nombres de variables idénticos. 28 | 29 | ```solidity 30 | //El valor de _a recibido por la función será encaminado para el modificador 31 | function foo(uint _a) external miModificador(_a) { 32 | //... 33 | } 34 | 35 | modifier miModificador(uint a) { 36 | require(a == 10, "Mensaje de error"); 37 | _; //Placeholder qie representa la función. 38 | } 39 | ``` 40 | 41 | ## Combinando más de un Modifier 42 | 43 | Incluso es posible encadenar modificadores y pasar datos entre ellos, debiendo seguir la misma nomenclatura para los parámetros que se van a pasar. 44 | 45 | ```solidity 46 | function bar(uint _a) external modificador1(_a) modificador2(_a){ 47 | //... 48 | } 49 | 50 | modifier modificador1(uint a) { 51 | require(a == 10); 52 | _; //Llamará al modificador 2. 53 | } 54 | 55 | modifier modificador2(uint a) { 56 | require(a == 10); 57 | _; 58 | } 59 | ``` 60 | 61 | Los modificadores son verificaciones, por lo que para tener más de una verificación/condición para que una función pueda ejecutarse, simplemente inserte más modificadores. 62 | -------------------------------------------------------------------------------- /src/es/exemplos/hacks/escondendo-codigos-maliciosos-com-contrato-externo.md: -------------------------------------------------------------------------------- 1 | # Escondendo Códigos Maliciosos com Contrato Externo 2 | 3 | #### Vulnerabilidade 4 | 5 | Em Solidity, qualquer endereço pode ser passado a um contrato, mesmo que o contrato nesse endereço não seja o contrato real que foi passado. 6 | 7 | Isso pode ser explorado para esconder um código malicioso. Vejamos como. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | /* 14 | Digamos que Alice pode ver o código de Foo e Bar mas não o de Mal. 15 | É óbvio para Alice que Foo.callBar() executa o código dentro do Bar.log(). 16 | Contudo, Eve implementa Foo com o endereço do Mal, de forma que chamando Foo.callBar() 17 | será executado na verdade o código em Mal. 18 | */ 19 | 20 | /* 21 | 1. Eve implanta Mal 22 | 2. Eve implementa Foo com o endereço de Mal 23 | 3. Alice chama Foo.callBar() após ler o código e julgar que ele seja 24 | seguro para ser chamado. 25 | 4. Apesar de Alice esperar que Bar.log() seja executado, Mal.log() foi executado. 26 | */ 27 | 28 | contract Foo { 29 | Bar bar; 30 | 31 | constructor(address _bar) { 32 | bar = Bar(_bar); 33 | } 34 | 35 | function callBar() public { 36 | bar.log(); 37 | } 38 | } 39 | 40 | contract Bar { 41 | event Log(string message); 42 | 43 | function log() public { 44 | emit Log("Bar was called"); 45 | } 46 | } 47 | 48 | // Esse código está escondido num arquivo separado 49 | contract Mal { 50 | event Log(string message); 51 | 52 | // function () external { 53 | // emit Log("Mal was called"); 54 | // } 55 | 56 | // Na verdade nós podemos executar o mesmo exploit mesmo que essa função 57 | // não exista, usando o fallback 58 | function log() public { 59 | emit Log("Mal was called"); 60 | } 61 | } 62 | ``` 63 | 64 | #### Técnicas preventivas 65 | 66 | * Inicialize um novo contrato dentro do constructor 67 | * Torne o endereço do contrato externo `public` de forma que o código do contrato externo possa ser revisado 68 | 69 | ```solidity 70 | Bar public bar; 71 | 72 | constructor() public { 73 | bar = new Bar(); 74 | } 75 | ``` 76 | -------------------------------------------------------------------------------- /src/exemplos/hacks/escondendo-codigos-maliciosos-com-contrato-externo.md: -------------------------------------------------------------------------------- 1 | # Escondendo Códigos Maliciosos com Contrato Externo 2 | 3 | #### Vulnerabilidade 4 | 5 | Em Solidity, qualquer endereço pode ser passado a um contrato, mesmo que o contrato nesse endereço não seja o contrato real que foi passado. 6 | 7 | Isso pode ser explorado para esconder um código malicioso. Vejamos como. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | /* 14 | Digamos que Alice pode ver o código de Foo e Bar mas não o de Mal. 15 | É óbvio para Alice que Foo.callBar() executa o código dentro do Bar.log(). 16 | Contudo, Eve implementa Foo com o endereço do Mal, de forma que chamando Foo.callBar() 17 | será executado na verdade o código em Mal. 18 | */ 19 | 20 | /* 21 | 1. Eve implanta Mal 22 | 2. Eve implementa Foo com o endereço de Mal 23 | 3. Alice chama Foo.callBar() após ler o código e julgar que ele seja 24 | seguro para ser chamado. 25 | 4. Apesar de Alice esperar que Bar.log() seja executado, Mal.log() foi executado. 26 | */ 27 | 28 | contract Foo { 29 | Bar bar; 30 | 31 | constructor(address _bar) { 32 | bar = Bar(_bar); 33 | } 34 | 35 | function callBar() public { 36 | bar.log(); 37 | } 38 | } 39 | 40 | contract Bar { 41 | event Log(string message); 42 | 43 | function log() public { 44 | emit Log("Bar was called"); 45 | } 46 | } 47 | 48 | // Esse código está escondido num arquivo separado 49 | contract Mal { 50 | event Log(string message); 51 | 52 | // function () external { 53 | // emit Log("Mal was called"); 54 | // } 55 | 56 | // Na verdade nós podemos executar o mesmo exploit mesmo que essa função 57 | // não exista, usando o fallback 58 | function log() public { 59 | emit Log("Mal was called"); 60 | } 61 | } 62 | ``` 63 | 64 | #### Técnicas preventivas 65 | 66 | * Inicialize um novo contrato dentro do constructor 67 | * Torne o endereço do contrato externo `public` de forma que o código do contrato externo possa ser revisado 68 | 69 | ```solidity 70 | Bar public bar; 71 | 72 | constructor() public { 73 | bar = new Bar(); 74 | } 75 | ``` 76 | -------------------------------------------------------------------------------- /src/es/exemplos/hacks/front-running.md: -------------------------------------------------------------------------------- 1 | # Front Running 2 | 3 | #### Vulnerabilidade 4 | 5 | Transações levam algum tempo antes de serem mineradas. Um invasor pode observar o pool de transações e enviar uma transação, inclui-la num bloco antes da transação original. Esse mecanismo pode ser usado para reordenar as transações em benefício dos invasores. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | /* 12 | Alice cria um jogo de advinhação. 13 | Você ganha 10 ether se você encontrar o string correto que bata com o hash alvo 14 | Vejamos como esse contrato é vulnerável para front running. 15 | */ 16 | 17 | /* 18 | 1. Alice implanta FindThisHash com 10 Ether. 19 | 2. Bob encontra o string correto que bate com o hash alvo. ("Ethereum") 20 | 3. Bob chama solve("Ethereum") com o preço de gás estabelecido em 15 gwei. 21 | 4. Eve está observando o pool das transações para submeter uma resposta. 22 | 5. Eve vê a resposta de Bob e chama solve("Ethereum") com um preço de gás mais 23 | alto do que o de Bob (100 gwei). 24 | 6. A transação de Eve foi minerada antes da transação de Bob. 25 | Eve ganha a recompensa de 10 ether. 26 | 27 | O que aconteceu? 28 | Transações levam algum tempo antes de serem mineradas. 29 | Transações que ainda não foram mineradas são colocadas no pool de transações. 30 | Transações com preço de gás mais alto são tipicamente mineradas primeiro. 31 | Um invasor obtém a resposta de pool de transações, envia uma transação com um 32 | preço de gás mais alto, de forma que sua transação será incluída num bloco 33 | antes do original. 34 | */ 35 | 36 | contract FindThisHash { 37 | bytes32 public constant hash = 38 | 0x564ccaf7594d66b1eaaea24fe01f0585bf52ee70852af4eac0cc4b04711cd0e2; 39 | 40 | constructor() payable {} 41 | 42 | function solve(string memory solution) public { 43 | require(hash == keccak256(abi.encodePacked(solution)), "Incorrect answer"); 44 | 45 | (bool sent, ) = msg.sender.call{value: 10 ether}(""); 46 | require(sent, "Failed to send Ether"); 47 | } 48 | } 49 | ``` 50 | 51 | #### Técnicas preventivas 52 | 53 | * use esquema de commit-reveal 54 | * use envio de submarino 55 | -------------------------------------------------------------------------------- /src/exemplos/hacks/front-running.md: -------------------------------------------------------------------------------- 1 | # Front Running 2 | 3 | #### Vulnerabilidade 4 | 5 | Transações levam algum tempo antes de serem mineradas. Um invasor pode observar o pool de transações e enviar uma transação, inclui-la num bloco antes da transação original. Esse mecanismo pode ser usado para reordenar as transações em benefício dos invasores. 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | /* 12 | Alice cria um jogo de advinhação. 13 | Você ganha 10 ether se você encontrar o string correto que bata com o hash alvo 14 | Vejamos como esse contrato é vulnerável para front running. 15 | */ 16 | 17 | /* 18 | 1. Alice implanta FindThisHash com 10 Ether. 19 | 2. Bob encontra o string correto que bate com o hash alvo. ("Ethereum") 20 | 3. Bob chama solve("Ethereum") com o preço de gás estabelecido em 15 gwei. 21 | 4. Eve está observando o pool das transações para submeter uma resposta. 22 | 5. Eve vê a resposta de Bob e chama solve("Ethereum") com um preço de gás mais 23 | alto do que o de Bob (100 gwei). 24 | 6. A transação de Eve foi minerada antes da transação de Bob. 25 | Eve ganha a recompensa de 10 ether. 26 | 27 | O que aconteceu? 28 | Transações levam algum tempo antes de serem mineradas. 29 | Transações que ainda não foram mineradas são colocadas no pool de transações. 30 | Transações com preço de gás mais alto são tipicamente mineradas primeiro. 31 | Um invasor obtém a resposta de pool de transações, envia uma transação com um 32 | preço de gás mais alto, de forma que sua transação será incluída num bloco 33 | antes do original. 34 | */ 35 | 36 | contract FindThisHash { 37 | bytes32 public constant hash = 38 | 0x564ccaf7594d66b1eaaea24fe01f0585bf52ee70852af4eac0cc4b04711cd0e2; 39 | 40 | constructor() payable {} 41 | 42 | function solve(string memory solution) public { 43 | require(hash == keccak256(abi.encodePacked(solution)), "Incorrect answer"); 44 | 45 | (bool sent, ) = msg.sender.call{value: 10 ether}(""); 46 | require(sent, "Failed to send Ether"); 47 | } 48 | } 49 | ``` 50 | 51 | #### Técnicas preventivas 52 | 53 | * use esquema de commit-reveal 54 | * use envio de submarino 55 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/biblioteca.md: -------------------------------------------------------------------------------- 1 | # Biblioteca 2 | 3 | Bibliotecas são semelhantes a contratos, mas você não pode declarar nenhuma variável de estado e não pode enviar ether. 4 | 5 | Uma biblioteca é incorporada a um contrato se todas as funções da biblioteca são internas. 6 | 7 | Caso contrário, a biblioteca deve ser implementada e então vinculada antes do contrato ser implantado. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | library SafeMath { 14 | function add(uint x, uint y) internal pure returns (uint) { 15 | uint z = x + y; 16 | require(z >= x, "uint overflow"); 17 | 18 | return z; 19 | } 20 | } 21 | 22 | library Math { 23 | function sqrt(uint y) internal pure returns (uint z) { 24 | if (y > 3) { 25 | z = y; 26 | uint x = y / 2 + 1; 27 | while (x < z) { 28 | z = x; 29 | x = (y / x + x) / 2; 30 | } 31 | } else if (y != 0) { 32 | z = 1; 33 | } 34 | // else z = 0 (default value) 35 | } 36 | } 37 | 38 | contract TestSafeMath { 39 | using SafeMath for uint; 40 | 41 | uint public MAX_UINT = 2**256 - 1; 42 | 43 | function testAdd(uint x, uint y) public pure returns (uint) { 44 | return x.add(y); 45 | } 46 | 47 | function testSquareRoot(uint x) public pure returns (uint) { 48 | return Math.sqrt(x); 49 | } 50 | } 51 | 52 | // Função Array para apagar o elemento no index e reorganizar a matriz 53 | // de forma que não haja espaços entre os elementos. 54 | library Array { 55 | function remove(uint[] storage arr, uint index) public { 56 | // Move o último elemento para o lugar onde será apagado 57 | require(arr.length > 0, "Can't remove from empty array"); 58 | arr[index] = arr[arr.length - 1]; 59 | arr.pop(); 60 | } 61 | } 62 | 63 | contract TestArray { 64 | using Array for uint[]; 65 | 66 | uint[] public arr; 67 | 68 | function testArrayRemove() public { 69 | for (uint i = 0; i < 3; i++) { 70 | arr.push(i); 71 | } 72 | 73 | arr.remove(1); 74 | 75 | assert(arr.length == 2); 76 | assert(arr[0] == 0); 77 | assert(arr[1] == 2); 78 | } 79 | } 80 | ``` 81 | -------------------------------------------------------------------------------- /src/es/apostila/8.-arrays-listas.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 8. Arrays (Listas) 3 | --- 4 | ::: tip 5 | Arrays son listas de un solo tipo de datos y los usos y aplicaciones son prácticamente infinitos. 6 | ::: 7 | 8 | ## Creando Arrays 9 | 10 | Usamos corchetes como en otros lenguajes de programación, pero primero debemos especificar el tipo de este array y luego su nombre. 11 | 12 | ```solidity 13 | uint[] saldos; 14 | ``` 15 | 16 | Lista llamada _**saldos**_ del tipo _**uint**_ (números enteros positivos). 17 | 18 | ## Agregando Elementos a la lista 19 | 20 | Para agregar un registro usamos el comando _push(valor\_a\_ser\_agregado)_ y para actualizar accedemos al índice (posición de la lista) donde se almacena este valor. Como todo en informática, las listas _comienzan con el índice 0_ por lo que el primer valor se almacenará en la posición 0 y el segundo en la posición 1 y así sucesivamente. 21 | 22 | ```solidity 23 | saldos.push(10); 24 | saldos.push(20); 25 | 26 | return saldos[0]; //Retornará 10 porque es la primera posición en la lista. 27 | saldos[1] = 200; //Actualizará el valor de 20 para 200 en la posición 2 de la lista. 28 | ``` 29 | 30 | ## Accediendo Elementos 31 | 32 | Para acceder a los datos que se almacenan en esta lista usamos su nombre y la posición del elemento entre corchetes. 33 | 34 | ```solidity 35 | return saldos[0]; 36 | ``` 37 | 38 | ## Eliminando Elementos 39 | 40 | Muy similar a otros lenguajes, para borrar un elemento se usa la palabra _**delete**_ y la posición de la lista en la cuál será borrado. 41 | 42 | ```solidity 43 | delete saldos[0]; 44 | ``` 45 | 46 | ## Arrays Multidimensionales 47 | 48 | Similar a tablas u otras estructuras multidimensionales como tensores, también es posible construir "listas de listas" en solidity. 49 | 50 | ```solidity 51 | //Lista de listas de shitcoins 52 | 53 | string[][] lista_de_shitcoins; 54 | 55 | lista_de_shitcoins.push(['Face', 'Ucka']) 56 | lista_de_shitcoins.push(['JunoCoin', 'Yotta', 'Woz') 57 | 58 | lista_de_shitcoins[0][0] == 'Face'; 59 | lista_de_shitcoins[1][2] == 'Woz'; 60 | ``` 61 | 62 | En este caso tenemos una lista que contiene otras listas de shitcoins. 63 | 64 | Para acceder a un valor almacenado en una lista de listas, necesitamos encontrarlo por los índices de la siguiente manera: _**nombreDeLaLista\[primer\_índice]\[segundo\_índice].**_ 65 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/biblioteca.md: -------------------------------------------------------------------------------- 1 | # Librería 2 | 3 | Las librerías son similares a los contratos, pero no puedes declarar ninguna variable de estado y tampoco no puedes enviar ether. 4 | 5 | Una librería está integrada al contrato si todas las funciones de la librería son internas. 6 | 7 | De otra forma, la librería debe ser desplegada y luego enlazada antes de que el contrato sea desplegada. 8 | 9 | ```solidity 10 | // SPDX-License-Identifier: MIT 11 | pragma solidity ^0.8.3; 12 | 13 | library SafeMath { 14 | function add(uint x, uint y) internal pure returns (uint) { 15 | uint z = x + y; 16 | require(z >= x, "uint overflow"); 17 | 18 | return z; 19 | } 20 | } 21 | 22 | library Math { 23 | function sqrt(uint y) internal pure returns (uint z) { 24 | if (y > 3) { 25 | z = y; 26 | uint x = y / 2 + 1; 27 | while (x < z) { 28 | z = x; 29 | x = (y / x + x) / 2; 30 | } 31 | } else if (y != 0) { 32 | z = 1; 33 | } 34 | // else z = 0 (default value) 35 | } 36 | } 37 | 38 | contract TestSafeMath { 39 | using SafeMath for uint; 40 | 41 | uint public MAX_UINT = 2**256 - 1; 42 | 43 | function testAdd(uint x, uint y) public pure returns (uint) { 44 | return x.add(y); 45 | } 46 | 47 | function testSquareRoot(uint x) public pure returns (uint) { 48 | return Math.sqrt(x); 49 | } 50 | } 51 | 52 | // La función Array borra elementos en el índice y reorganiza el array 53 | // así no hay huecos entre los elementos. 54 | library Array { 55 | function remove(uint[] storage arr, uint index) public { 56 | // Mueve el último elemento hacia el lugar que se va a borrar 57 | require(arr.length > 0, "Can't remove from empty array"); 58 | arr[index] = arr[arr.length - 1]; 59 | arr.pop(); 60 | } 61 | } 62 | 63 | contract TestArray { 64 | using Array for uint[]; 65 | 66 | uint[] public arr; 67 | 68 | function testArrayRemove() public { 69 | for (uint i = 0; i < 3; i++) { 70 | arr.push(i); 71 | } 72 | 73 | arr.remove(1); 74 | 75 | assert(arr.length == 2); 76 | assert(arr[0] == 0); 77 | assert(arr[1] == 2); 78 | } 79 | } 80 | ``` 81 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/try-catch.md: -------------------------------------------------------------------------------- 1 | # Try Catch 2 | 3 | `try / catch` só pode captar erros de chamadas de função externa e criação de contrato. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | // Contrato externo usado para exemplos de try / catch 10 | contract Foo { 11 | address public owner; 12 | 13 | constructor(address _owner) { 14 | require(_owner != address(0), "invalid address"); 15 | assert(_owner != 0x0000000000000000000000000000000000000001); 16 | owner = _owner; 17 | } 18 | 19 | function myFunc(uint x) public pure returns (string memory) { 20 | require(x != 0, "require failed"); 21 | return "my func was called"; 22 | } 23 | } 24 | 25 | contract Bar { 26 | event Log(string message); 27 | event LogBytes(bytes data); 28 | 29 | Foo public foo; 30 | 31 | constructor() { 32 | // Este contrato Foo é usado como exemplo de try catch com chamada externa 33 | foo = new Foo(msg.sender); 34 | } 35 | 36 | // Exemplo de try / catch com chamada externa 37 | // tryCatchExternalCall(0) => Log("external call failed") 38 | // tryCatchExternalCall(1) => Log("my func was called") 39 | function tryCatchExternalCall(uint _i) public { 40 | try foo.myFunc(_i) returns (string memory result) { 41 | emit Log(result); 42 | } catch { 43 | emit Log("external call failed"); 44 | } 45 | } 46 | 47 | // Exemplo de try / catch com criação de contrato 48 | // tryCatchNewContract(0x0000000000000000000000000000000000000000) => Log("invalid address") 49 | // tryCatchNewContract(0x0000000000000000000000000000000000000001) => LogBytes("") 50 | // tryCatchNewContract(0x0000000000000000000000000000000000000002) => Log("Foo created") 51 | function tryCatchNewContract(address _owner) public { 52 | try new Foo(_owner) returns (Foo foo) { 53 | // você pode usar a variável foo aqui 54 | emit Log("Foo created"); 55 | } catch Error(string memory reason) { 56 | // pega a falha revert() e require() 57 | emit Log(reason); 58 | } catch (bytes memory reason) { 59 | // pega a falha assert() 60 | emit LogBytes(reason); 61 | } 62 | } 63 | } 64 | ``` 65 | -------------------------------------------------------------------------------- /src/es/apostila/13.-memory-vs-storage.md: -------------------------------------------------------------------------------- 1 | --- 2 | title: 13. Memory vs Storage 3 | --- 4 | ::: tip 5 | Hay ciertas formas de manipular los datos dentro de las blockchains y cada una de ellas se realiza de diferentes maneras por parte del minero que ejecutará el contrato, esto implica diferentes costos de gas. 6 | ::: 7 | 8 | ## Storage 9 | 10 | Datos que persistirán en la Blockchain y se almacenarán por tiempo indefinido (o definido) dentro de los registros distribuidos entre todos los nodos de la red. 11 | 12 | Toda variable definida fuera de las funciones se almacenará de esta manera por defecto. Las variables dentro de las funciones necesitan del parámetro _storage_ para poder escritas en la blockchain. 13 | 14 | ```solidity 15 | contract miContrato { 16 | uint a; 17 | string x; 18 | 19 | function ejemploFunc() { 20 | string storage ejemplo; 21 | } 22 | } 23 | ``` 24 | 25 | ## Memory & Calldata 26 | 27 | Este tipo de almacenamiento será temporal solo durante el tiempo de ejecución, es decir, estos datos solo existirán mientras se esté ejecutando la función o instrucción. No se almacenarán datos almacenados en variables de tipo memory o calldata. Hay una diferencia relevante entre ambas operaciones y a continuación veremos cuándo utilizar una u otra. 28 | 29 | ### memory: Puede ser alterada 30 | 31 | Cuando pasamos parámetros a una función y usamos la memoria como indicador del tipo de almacenamiento, podemos cambiar estos datos dentro de la función si así lo deseamos. 32 | 33 | ```solidity 34 | function memoryTest(string memory _ejemploTexto) public returns (string memory) { 35 | _ejemploTexto = "Dato Alterado"; 36 | return _ejemploTexto; 37 | } 38 | ``` 39 | 40 | ### calldata: No puede ser alterada 41 | 42 | Cuando usamos calldata, no tenemos permisos para cambiar los datos que se pasaron a la función. 43 | 44 | ```solidity 45 | function calldataTest(string calldata _datoEjemplo) external returns (string memory) { 46 | // No podemos alterarlo, pero sí retornarlo. 47 | return _datoEjemplo; 48 | } 49 | ``` 50 | 51 | ## Costos: Storage vs Memory vs Calldata 52 | 53 | _Storage_ es el más caro ya que almacena los datos dentro de la Blockchain, seguido de _memory_ que es mucho más económico ya que no almacena nada pero usa más OPCODES que _calldata_, que resulta ser el más barato de todos los tipos de almacenamiento. 54 | 55 | -------------------------------------------------------------------------------- /src/exemplos/linguagem-v0.8.3/heranca.md: -------------------------------------------------------------------------------- 1 | # Herança 2 | 3 | Solidity suporta herança múltipla. Contratos podem herdar outro contrato usando a palavra-chave `is`. 4 | 5 | Função que será substituída por um contrato da classe filho deve ser declarada como `virtual`. 6 | 7 | Função que vai substituir uma função da classe pai deve usar a palavra-chave `override`. 8 | 9 | A ordem da herança é importante. 10 | 11 | Você deve listar contratos da classe pai na ordem do "mais básico" para o "mais derivado". 12 | 13 | ```solidity 14 | // SPDX-License-Identifier: MIT 15 | pragma solidity ^0.8.3; 16 | 17 | /* Gráfico de herança 18 | A 19 | / \ 20 | B C 21 | / \ / 22 | F D,E 23 | 24 | */ 25 | 26 | contract A { 27 | function foo() public pure virtual returns (string memory) { 28 | return "A"; 29 | } 30 | } 31 | 32 | // Contratos herdam outros contratos usando a palavra-chave 'is'. 33 | contract B is A { 34 | // Substitui A.foo() 35 | function foo() public pure virtual override returns (string memory) { 36 | return "B"; 37 | } 38 | } 39 | 40 | contract C is A { 41 | // Substitui A.foo() 42 | function foo() public pure virtual override returns (string memory) { 43 | return "C"; 44 | } 45 | } 46 | 47 | // Contratos podem herdar de múltiplos contratos de classe pai. 48 | // Quando uma função é chamada que é definida múltiplas vezes em 49 | // contratos diferentes, contratos da classe pai são procurados da 50 | // direita para a esquerda, e por busca de profundidade. 51 | 52 | contract D is B, C { 53 | // D.foo() retorna "C" 54 | // já que C é o contrato de classe pai mais da direita com função foo() 55 | function foo() public pure override(B, C) returns (string memory) { 56 | return super.foo(); 57 | } 58 | } 59 | 60 | contract E is C, B { 61 | // E.foo() retorna "B" 62 | // já que B é o contrato de classe pai mais da direita com função foo() 63 | function foo() public pure override(C, B) returns (string memory) { 64 | return super.foo(); 65 | } 66 | } 67 | 68 | // Herança deve ser ordenada do "mais básico" para o "mais derivado". 69 | // Trocar a ordem de A e B cria um erro de compilação. 70 | contract F is A, B { 71 | function foo() public pure override(A, B) returns (string memory) { 72 | return super.foo(); 73 | } 74 | } 75 | ``` 76 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/try-catch.md: -------------------------------------------------------------------------------- 1 | # Try Catch 2 | 3 | `try / catch` solo puede detectar errores de las llamadas de función externa y de la creación de contrato. 4 | 5 | ```solidity 6 | // SPDX-License-Identifier: MIT 7 | pragma solidity ^0.8.3; 8 | 9 | // Contrato externo usado para ejemplos de try / catch 10 | contract Foo { 11 | address public owner; 12 | 13 | constructor(address _owner) { 14 | require(_owner != address(0), "invalid address"); 15 | assert(_owner != 0x0000000000000000000000000000000000000001); 16 | owner = _owner; 17 | } 18 | 19 | function myFunc(uint x) public pure returns (string memory) { 20 | require(x != 0, "require failed"); 21 | return "my func was called"; 22 | } 23 | } 24 | 25 | contract Bar { 26 | event Log(string message); 27 | event LogBytes(bytes data); 28 | 29 | Foo public foo; 30 | 31 | constructor() { 32 | // Este contrato Foo es usado como ejemplo de try catch como llamada externa 33 | foo = new Foo(msg.sender); 34 | } 35 | 36 | // Ejemplo de try / catch con llamada externa 37 | // tryCatchExternalCall(0) => Log("external call failed") 38 | // tryCatchExternalCall(1) => Log("my func was called") 39 | function tryCatchExternalCall(uint _i) public { 40 | try foo.myFunc(_i) returns (string memory result) { 41 | emit Log(result); 42 | } catch { 43 | emit Log("external call failed"); 44 | } 45 | } 46 | 47 | // Ejemplo de try / catch con la creación de contrato 48 | // tryCatchNewContract(0x0000000000000000000000000000000000000000) => Log("invalid address") 49 | // tryCatchNewContract(0x0000000000000000000000000000000000000001) => LogBytes("") 50 | // tryCatchNewContract(0x0000000000000000000000000000000000000002) => Log("Foo created") 51 | function tryCatchNewContract(address _owner) public { 52 | try new Foo(_owner) returns (Foo foo) { 53 | // Puedes usar la variable foo aquí 54 | emit Log("Foo created"); 55 | } catch Error(string memory reason) { 56 | // catch falla en el revert() y require() 57 | emit Log(reason); 58 | } catch (bytes memory reason) { 59 | // catch falla assert() 60 | emit LogBytes(reason); 61 | } 62 | } 63 | } 64 | ``` 65 | -------------------------------------------------------------------------------- /src/exemplos/aplicacoes/implante-qualquer-contrato.md: -------------------------------------------------------------------------------- 1 | # Implante qualquer Contrato 2 | 3 | Implante qualquer contrato chamando `Proxy.deploy(bytes memory _code)` 4 | 5 | Por este exemplo, você pode obter bytecodes do contrato chamando `Helper.getBytecode1` e `Helper.getBytecode2` 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract Proxy { 12 | event Deploy(address); 13 | 14 | fallback() external payable {} 15 | 16 | function deploy(bytes memory _code) external payable returns (address addr) { 17 | assembly { 18 | // create(v, p, n) 19 | // v = quantidade de ETH a ser enviado 20 | // p = ponteiro na memória para iniciar o código 21 | // n = tamanho do código 22 | addr := create(callvalue(), add(_code, 0x20), mload(_code)) 23 | } 24 | // retorna endereço 0 em erro 25 | require(addr != address(0), "deploy failed"); 26 | 27 | emit Deploy(addr); 28 | } 29 | 30 | function execute(address _target, bytes memory _data) external payable { 31 | (bool success, ) = _target.call{value: msg.value}(_data); 32 | require(success, "failed"); 33 | } 34 | } 35 | 36 | contract TestContract1 { 37 | address public owner = msg.sender; 38 | 39 | function setOwner(address _owner) public { 40 | require(msg.sender == owner, "not owner"); 41 | owner = _owner; 42 | } 43 | } 44 | 45 | contract TestContract2 { 46 | address public owner = msg.sender; 47 | uint public value = msg.value; 48 | uint public x; 49 | uint public y; 50 | 51 | constructor(uint _x, uint _y) payable { 52 | x = _x; 53 | y = _y; 54 | } 55 | } 56 | 57 | contract Helper { 58 | function getBytecode1() external pure returns (bytes memory) { 59 | bytes memory bytecode = type(TestContract1).creationCode; 60 | return bytecode; 61 | } 62 | 63 | function getBytecode2(uint _x, uint _y) external pure returns (bytes memory) { 64 | bytes memory bytecode = type(TestContract2).creationCode; 65 | return abi.encodePacked(bytecode, abi.encode(_x, _y)); 66 | } 67 | 68 | function getCalldata(address _owner) external pure returns (bytes memory) { 69 | return abi.encodeWithSignature("setOwner(address)", _owner); 70 | } 71 | } 72 | ``` 73 | -------------------------------------------------------------------------------- /src/es/exemplos/aplicacoes/implante-qualquer-contrato.md: -------------------------------------------------------------------------------- 1 | # Implante qualquer Contrato 2 | 3 | Implante qualquer contrato chamando `Proxy.deploy(bytes memory _code)` 4 | 5 | Por este exemplo, você pode obter bytecodes do contrato chamando `Helper.getBytecode1` e `Helper.getBytecode2` 6 | 7 | ```solidity 8 | // SPDX-License-Identifier: MIT 9 | pragma solidity ^0.8.3; 10 | 11 | contract Proxy { 12 | event Deploy(address); 13 | 14 | fallback() external payable {} 15 | 16 | function deploy(bytes memory _code) external payable returns (address addr) { 17 | assembly { 18 | // create(v, p, n) 19 | // v = quantidade de ETH a ser enviado 20 | // p = ponteiro na memória para iniciar o código 21 | // n = tamanho do código 22 | addr := create(callvalue(), add(_code, 0x20), mload(_code)) 23 | } 24 | // retorna endereço 0 em erro 25 | require(addr != address(0), "deploy failed"); 26 | 27 | emit Deploy(addr); 28 | } 29 | 30 | function execute(address _target, bytes memory _data) external payable { 31 | (bool success, ) = _target.call{value: msg.value}(_data); 32 | require(success, "failed"); 33 | } 34 | } 35 | 36 | contract TestContract1 { 37 | address public owner = msg.sender; 38 | 39 | function setOwner(address _owner) public { 40 | require(msg.sender == owner, "not owner"); 41 | owner = _owner; 42 | } 43 | } 44 | 45 | contract TestContract2 { 46 | address public owner = msg.sender; 47 | uint public value = msg.value; 48 | uint public x; 49 | uint public y; 50 | 51 | constructor(uint _x, uint _y) payable { 52 | x = _x; 53 | y = _y; 54 | } 55 | } 56 | 57 | contract Helper { 58 | function getBytecode1() external pure returns (bytes memory) { 59 | bytes memory bytecode = type(TestContract1).creationCode; 60 | return bytecode; 61 | } 62 | 63 | function getBytecode2(uint _x, uint _y) external pure returns (bytes memory) { 64 | bytes memory bytecode = type(TestContract2).creationCode; 65 | return abi.encodePacked(bytecode, abi.encode(_x, _y)); 66 | } 67 | 68 | function getCalldata(address _owner) external pure returns (bytes memory) { 69 | return abi.encodeWithSignature("setOwner(address)", _owner); 70 | } 71 | } 72 | ``` 73 | -------------------------------------------------------------------------------- /src/es/exemplos/linguagem-v0.8.3/heranca.md: -------------------------------------------------------------------------------- 1 | # Herencia 2 | 3 | Solidity soporta herencia múltiple. Los contratos pueden heredar de otro contrato usando la palabra reservada `is`. 4 | 5 | Función que será sobreescrita por un contrato hijo debe ser declarada como `virtual`. 6 | 7 | Función que va a sobreescribir una función padre debe usar la palabra reservada `override`. 8 | 9 | El orden de herencia es importante. 10 | 11 | Debes listar los contratos padres en el orden desde lo "más básico" hacia lo "más derivado". 12 | 13 | ```solidity 14 | // SPDX-License-Identifier: MIT 15 | pragma solidity ^0.8.3; 16 | 17 | /* Gráfico de herencia 18 | A 19 | / \ 20 | B C 21 | / \ / 22 | F D,E 23 | 24 | */ 25 | 26 | contract A { 27 | function foo() public pure virtual returns (string memory) { 28 | return "A"; 29 | } 30 | } 31 | 32 | // Contratos heredan de otro contrato usando la palabra reservada `is`. 33 | contract B is A { 34 | // Sobreescribe A.foo() 35 | function foo() public pure virtual override returns (string memory) { 36 | return "B"; 37 | } 38 | } 39 | 40 | contract C is A { 41 | // Sobreescribe A.foo() 42 | function foo() public pure virtual override returns (string memory) { 43 | return "C"; 44 | } 45 | } 46 | 47 | // Contratos pueden heredar de múltiples contratos padre. 48 | // Cuando una función es invocada y está definida múltiples veces en 49 | // contratos diferentes, los contratos padres son buscados desde 50 | // derecha hacia la izquierda, y por profundidad en primer lugar. 51 | 52 | contract D is B, C { 53 | // D.foo() devuelve "C" 54 | // ya que C es el contrato padre más a la derecha con la función foo() 55 | function foo() public pure override(B, C) returns (string memory) { 56 | return super.foo(); 57 | } 58 | } 59 | 60 | contract E is C, B { 61 | // E.foo() devuelve "B" 62 | // ya que B es el contrato padre más a la derecha con la función foo() 63 | function foo() public pure override(C, B) returns (string memory) { 64 | return super.foo(); 65 | } 66 | } 67 | 68 | // Herencia debe ser ordenada de los "más básico" hacia lo "más derivado". 69 | // Intercambiar el orden de A y B arrojará un error de compilación. 70 | contract F is A, B { 71 | function foo() public pure override(A, B) returns (string memory) { 72 | return super.foo(); 73 | } 74 | } 75 | ``` --------------------------------------------------------------------------------