🇧🇷
Ethereum Developer Pack - PT
  • Ethereum Developer Pack - PT
  • Módulo 1
    • Introdução a Smart Contracts
      • Fundamentos de Blockchain
        • Histórico
        • Bitcoin
        • O que é Blockchain
        • Conceitos-chave em Blockchain
        • Como funciona a Blockchain
        • Tipos de Blockchain
        • Modelos de Consenso
      • A nova Internet
        • Web 3
        • Elementos Fundamentais
        • Impacto do Ethereum em Diversos Setores
      • Wallets
        • Componentes de uma wallet
        • Tipos de Wallet
        • Códigos Mnemônicos
      • Ethereum 101
        • Smart Contracts
        • Contas
          • Tipos de contas
          • Conteúdo das contas
        • Transações
          • Componentes
          • Ciclo de vida
        • Gás
        • Solidity
        • EVM
          • A máquina de estados
          • Opcodes
          • Como funciona a EVM
          • Clientes de execução
          • DApps
      • Blockchain Explorer
        • Funções de um blockchain explorer
        • Beneficios de utilizar um blockchain explorer
      • Remix
        • Características do Remix
        • Workspaces ou espaços de trabalho
        • Carregar e compilar um contrato
        • Implantar na máquina virtual do Remix (Remix VM)
        • Interagindo com funções
        • Deployar em uma rede pública
      • Crie seu primeiro Smart Contract
  • Módulo 2
    • Fundamentos de Solidity
      • Hello World
      • Tipos de Dados
      • Funções
      • Variáveis
        • Exercício 1
      • Operadores
        • Ejercicio 2
      • Constructor
        • Exercício 3
      • Convenções de nomenclatura
      • Tipos de armazenamento para variáveis
      • Estruturas de Controle
        • Exercício 4
      • Modificadores
      • Eventos
        • Exercício 5
      • Tipos de Referencia
        • Arrays
          • Exercício 6
        • Mappings
          • Exercício 7
        • Structs
          • Exercício 8
      • Address Payable
      • Como os contratos e funções recebem Ether.
      • Transferências de Ether
      • Conceitos Avançados
        • Codificação de ABI
        • Hashing
        • This
        • Herança
        • Abstract
        • Interface
        • Chamada entre contratos
        • EVM
        • ABI
        • Bytecode
        • Opcodes
  • Módulo 3
    • ERCs, Bibliotecas e Padrões de Desenvolvimento
      • Boas Práticas de Desenvolvimento
      • Padrões de Desenvolvimento
      • EIP & ERC
      • ERC-20
      • ERC-721
      • Open Zeppelin
      • Crie um Token ERC-20
      • Almacenamiento Descentralizado: IPFS
      • Crea un Token ERC-721
      • DeFi
  • Módulo 4
    • Kit de ferramentas para desenvolvimento na Ethereum
      • Requisitos para o módulo 4
        • Terminal
        • Git e Github
        • Node.js e npm
        • Visual Studio Code para Solidity
      • Toolkit
        • JSON-RPC
        • Ethers.js
          • Exercício
        • Hardhat
          • Implantação de um contrato no Hardhat
          • Implantação de um contrato em uma rede pública
        • Scaffold-ETH
          • Características do Scaffold-ETHCaracterísticas
          • Como instalar o Scaffold-ETH
  • Módulo 5
    • Segurança, Testes e Auditorias
      • Testes
        • Importância de realizar testes
        • Métodos para testar contratos inteligentes
          • Testes automatizados
          • Testes manuais
        • Conceitos importantes em testes
        • Ferramentas para testes
        • Testes com Hardhat
        • Recursos adicionais
      • Segurança
        • Uma mentalidade diferente de design
        • Principais vulnerabilidades em contratos inteligentes
          • Reentrancy attack (ataque de reentrada)
          • Replay attack (ataque de repetición)
          • Price Oracle Manipulation (Manipulación de Oráculos de Precios)
          • Missing Access Control (Pérdida de Control de Acceso)
          • Reward Manipulation (Manipulación de Recompensas)
          • Failure to Initialize (Falla al Inicializar)
          • Front-running
          • Invariant Breaks (Quebra de Invariantes)
          • Mishandling of ETH (Má gestão de ETH)
          • Denial of Service (DoS - Negação de Serviço)
          • Integer overflow and underflow (Overflow e Underflow de inteiros)
          • Phishing y Typosquatting
        • Recursos adicionais
      • Auditoria de smart contracts
        • Processo de Auditoria
        • Ferramentas
        • Como se preparar para uma auditoria
        • O teste Rekt
        • Desafios
        • Recursos adicionais
  • Contribuye
    • Kipu Explorer
Powered by GitBook
On this page
  • Características dos Mappings
  • Declaração
  • Exemplo Básico
  • Uso Comum de Mappings em Contratos Inteligentes
  • Considerações de Segurança
  1. Módulo 2
  2. Fundamentos de Solidity
  3. Tipos de Referencia

Mappings

Os mappings em Solidity são uma estrutura de dados do tipo "key-value" (chave-valor) que fornece uma forma eficiente e flexível de armazenar e acessar dados dentro de contratos inteligentes. São comparáveis a dicionários ou mapas em outras linguagens de programação, onde cada chave única está associada a um valor. Os mappings são particularmente úteis no desenvolvimento de aplicações descentralizadas (DApps) para gerenciar conjuntos de dados como saldos de contas, relações entre entidades e outros tipos de dados estruturados.

Características dos Mappings

  • Chaves Únicas: Cada chave em um mapping deve ser única e é utilizada para acessar um valor específico. As chaves podem ser de qualquer tipo primitivo como address, uint, bytes, etc. Tipos de dados complexos como arrays ou structs não são permitidos como chaves.

  • Valores Dinâmicos: Os valores armazenados em um mapping podem ser de qualquer tipo, incluindo tipos primitivos, arrays, structs e até outros mappings.

  • Inicialização por Padrão: Os mappings não possuem um tamanho fixo e não é possível obter seu comprimento. Todos os valores possíveis estão virtualmente presentes e são inicializados por padrão com o valor padrão de seu tipo (por exemplo, 0 para uint, false para bool, etc.).

  • Privacidade: Não é possível iterar sobre os mappings nem obter uma lista de suas chaves diretamente em Solidity. Cada acesso a um valor deve ser feito através de uma chave conhecida.

Declaração

Um mapping é declarado especificando o tipo das chaves e o tipo dos valores. A sintaxe geral é:

mapping(tipoChave => tipoValor) public nomeMapping;

Exemplo Básico

pragma solidity ^0.8.0;

contract MyContract {

// Declaração de um mapping que associa endereços a saldos

mapping(address => uint) public balances;

// Atualiza o saldo do endereço que solicita a atualização

function updateBalance(uint newBalance) public {
    balances[msg.sender] = newBalance;
}

// Lê o saldo de um endereço

function getBalance(address user) public view returns (uint) {
    return balances[user];
}
}

No exemplo acima, criamos um mapping denominado balances formado por pares onde a chave é um address e o valor é um inteiro sem sinal.

Para atualizar o saldo de um endereço específico utilizamos a expressão.

Uso Comum de Mappings em Contratos Inteligentes

  • Saldos de Tokens: Para manter um registro dos saldos de criptomoedas ou tokens ERC-20 de cada endereço.

  • Permissões e Funções: Para gerenciar permissões ou funções específicas atribuídas a diferentes endereços.

  • Relações entre Entidades: Para mapear relações um-para-um ou um-para-muitos entre diferentes entidades, como usuários e seus ativos ou tarefas.

Considerações de Segurança

Ao trabalhar com mappings, é crucial gerenciar corretamente o acesso e as atualizações aos dados para prevenir vulnerabilidades de segurança. Por exemplo, ao atualizar um valor em um mapping, certifique-se de que apenas entidades autorizadas possam realizar essa atualização, utilizando modificadores de acesso ou verificações de permissões apropriadas.

PreviousExercício 6NextExercício 7

Last updated 5 months ago