## ****[**@DiegoFornalha no Twitter**](https://www.instagram.com/diegofornalha)



Ecosistema Flow: um olhar profundo em equipes e produtos vibrantes

Seguindo nossa primeira Assembleia da Flow, onde apresentamos nossas prioridades futuras e revisamos o crescimento de desenvolvedores, marcos tecnológicos e melhorias no protocolo principal do último ano, queremos fornecer uma visão mais profunda das equipes e produtos vibrantes que compõem o ecossistema da Flow.

**Principais conclusões**

Crescimento de desenvolvedores:
2022 foi um grande ano para construtores da Flow. Nos últimos 12 meses, vimos 2,5 vezes mais novos desenvolvedores implantando contratos na testnet e a Biblioteca de Clientes Flow foi baixada 630 mil vezes (2x em comparação com o ano anterior). Desde novembro de 2020, o número de desenvolvedores entrando no ecossistema da Flow aumentou em média 31% mês a mês. Temos mais de 11.000 desenvolvedores (medidos pelo número cumulativo de contas de testnet) construindo mais de 2.600 contratos inteligentes vivos na Flow hoje.

**Crescimento de rede:**
Juntos, esses construtores têm impulsionado um aumento de ~700x no total de transações e um aumento de ~600x em contas na Flow desde novembro de 2020, para mais de 300 milhões de transações totais e 17,5 milhões de contas totais hoje.

**Impacto:**
Flow é o parceiro confiável para IP de empresas estabelecidas entrando no espaço web3, incluindo Ticketmaster, Mattel, Billboard, Dr. Seuss, CNN, Zigazoo e muitos outros a seguir.

Flow está se tornando a blockchain de escolha para principais startups centradas em consumidores e nativas digitais, incluindo a plataforma de avatares Genies, que alcançou o status de unicórnio em abril de 2022, a empresa de brinquedos digitais Cryptoys, que se associou à Mattel para transformar personagens lendários em avatares jogáveis que podem ser vendidos como NFTs, e o desenvolvedor de jogos Joyride, que construiu dois dos maiores dapps em web3, com mais de 17 milhões de transações totais e mais de 1 milhão de usuários únicos.

Plataformas sociais importantes como Instagram e Twitter agora oferecem suporte a Flow. Em 2022, Flow lançou um piloto com o Twitter para explorar um novo formato de tweet chamado NFT Tweet Tiles, com imagens maiores ao lado de detalhes como o título e o criador e um botão CTA visível



Artigo completo original em inglês: https://flow.com/post/state-of-the-flow-ecosystem


Crescimento significativo de desenvolvedores na plataforma, com um aumento de 2,5 vezes no número de novos desenvolvedores implantando contratos na testnet e uma taxa de crescimento mensal de 31% desde novembro de 2020. Além disso, o impacto da Flow como parceira confiável para empresas estabelecidas e startups digitais em sua entrada no espaço web3, e como a Flow está se tornando a blockchain de escolha para plataformas sociais populares como Instagram e Twitter.

O diagrama abaixo descreve os componentes de um dapp típico construído na blockchain Flow. Embora muitos dapps sejam estruturados de maneira diferente, essa arquitetura apresenta conceitos fundamentais que serão discutidos ao longo deste guia.

![](/images/image.png)

**Cliente Dapp**
O cliente dapp é a interface através da qual os usuários interagem com seu dapp. Aplicativos da Web e móveis são exemplos comuns de clientes dapp.

**Contrato Inteligente**
Um contrato inteligente é uma coleção de código, implantado em um local permanente na blockchain, que define a lógica central de um dapp.

**Conta de usuário**
Uma conta de usuário é um registro na blockchain que armazena os ativos digitais pertencentes a um único usuário.

**Transação**
Uma transação é um pedaço de código submetido ao blockchain que altera o estado de uma ou mais contas de usuário e contratos inteligentes. Todas as transações são originadas de pelo menos uma conta de usuário. Na maioria dos casos, uma transação passa dados entre uma conta de usuário e um contrato inteligente.

**consulta de estado**
Uma consulta de estado é uma solicitação feita ao blockchain que retorna informações sobre o estado dos contratos inteligentes do seu dapp.

**Carteira do usuário**
Uma carteira de usuário é um software ou hardware que controla o acesso à conta de um usuário na blockchain. O aplicativo cliente normalmente se conecta à carteira do usuário para enviar transações para a blockchain. Em muitos casos, o dapp transmite fisicamente a transação para o blockchain em nome do usuário. No entanto, é importante observar que a carteira tem a palavra final sobre o que é assinado ou não e, portanto, tem controle sobre todas as transações que interagem com a conta do usuário.

**Biblioteca de cliente Flow(FCL)**
A Flow Client Library é uma estrutura que fornece uma interface padrão para conectar aplicativos clientes e carteiras de usuários.


A anatomia de um Flow Dapp

Protocolo de staking líquido (STFLOW) da Increment

## A Increment desenvolveu e lançou o primeiro protocolo de estacas líquidas não custodiante (LSP) líder no Flow.

Permitindo que os usuários ganhem recompensas de estacas e aproveitem a liquidez desbloqueada para participar do ecossistema DeFi do Flow ao mesmo tempo, acreditamos que o LSP cria grandes novas oportunidades para a rede Flow, operadores de nós, estadores e detentores de tokens em geral.

O LSP ajuda a descentralizar a rede, facilita o processo de estacas e diversifica os riscos, libera capital desbloqueado e cria mais oportunidades de rendimento e composição.

Apenas um exemplo aqui: atualmente existem cerca de 719.000.000 tokens $flow bloqueados em estacas. Se conseguíssemos tornar 10% dessas tokens estacadas líquidas, teríamos cerca de 121 milhões de dólares em TVL para participar do ecossistema DeFi do Flow.

**Recursos
Por enquanto, os usuários podem:**

💧 Estacar $flow com o LSP para obter $stFlow. O usuário pode segurar, transferir ou usar $stFlow dentro do ecossistema DeFi do Flow.

📈 O preço do token $stFlow (em relação ao token $flow) aumenta com o tempo: as recompensas de estacas são automaticamente reestacadas (e, portanto, compostas) no início de cada época.

💱 Resgatar as estacas de $flow e as recompensas geradas usando $stFlow, ou simplesmente trocar $stFlow de volta para $flow em AMM/DEX, sem esperar o período de desvinculação de 7 a 14 dias.

📥 Migração - um recurso especificamente construído para delegadores existentes. Então, se você já delegou para um nó, não precisa desestacar do nó, mas pode "migrar" a posição estacada para o LSP e receber $stFlow imediatamente em 1 transação. Confira nossa orientação ao usuário aqui para obter mais informações e certas restrições.

👨‍🌾 Dentro das próximas 24 horas, abriremos uma fazenda de LP para o par de troca \`**$flow <> $stFlow**\` para incentivar os LP, criando uma piscina de liquidez profunda para usuários que precisam de liquidez de desestacas instantânea. $stFlow também será habilitado como garantias no mercado de dinheiro em breve.

Inspirado no artigo original em inglês: [`https://medium.com/coinmonks/introducing-increment-liquid-staking-2cc04e7eae9d`](https://medium.com/coinmonks/introducing-increment-liquid-staking-2cc04e7eae9d)



A Increment lançou um protocolo de estacas líquidas no Flow que permite aos usuários participar do ecossistema DeFi enquanto recebem recompensas de estacas. O protocolo ajuda a descentralizar a rede e aumenta a liquidez, permitindo que os usuários resgatam suas estacas e recompensas geradas de forma rápida e fácil.

Por que investir em flow agora pode ser a decisão certa

#### O mercado de criptomoedas pode ser altamente volátil, mas isso não significa que investir em tecnologias de blockchain, como a flow blockchain, seja uma decisão errada. Pelo contrário, há muitas razões pelas quais investir em flow agora pode ser a decisão certa. Aqui estão cinco dessas razões:

*   **Potencial de crescimento de longo prazo:** A tecnologia blockchain está ainda em sua infância, mas tem o potencial de revolucionar vários setores e impulsionar um crescimento significativo a longo prazo. A flow blockchain, em particular, tem uma tecnologia inovadora que o diferencia de outras plataformas de blockchain e o torna um forte candidato a liderar essa revolução.



*   **Oportunidades de negócios**: Além de ser uma plataforma de blockchain promissora em si mesma, a flow blockchain também pode oferecer oportunidades de negócios para aqueles que se especializam em sua tecnologia. Isso pode incluir o desenvolvimento de aplicações descentralizadas (DApps) ou serviços de consultoria para empresas interessadas em implementar a tecnologia de blockchain.



*   **Adoção antecipada:** Aqueles que investem e aprendem sobre a flow blockchain agora podem ser considerados "early adopters" e podem se beneficiar da adoção antecipada da tecnologia. Isso significa que eles poderão ser os primeiros a se beneficiar das vantagens da tecnologia e poderão até mesmo ajudar a moldar o futuro da mesma.



*   **Impacto positivo**: Por fim, a flow blockchain pode ter um impacto positivo na sociedade e no mundo em geral. A tecnologia de blockchain pode ser usada para resolver problemas complexos e desafiar a forma como as coisas são feitas atualmente. Ao investir e aprender sobre a flow blockchain, você pode fazer a sua parte para ajudar a moldar um futuro melhor.

**Em resumo**, investir em flow blockchain agora pode ser a decisão certa devido ao seu potencial de crescimento de longo prazo, oportunidades de negócios, adoção antecipada, resiliência e impacto positivo. Não deixe que as flutuações do mercado o impeçam de avançar e investir no futuro promissor da tecnologia de blockchain. É importante lembrar que, como em qualquer investimento, é preciso fazer a sua própria pesquisa e entender os riscos envolvidos antes de tomar qualquer decisão. Mas se você acredita no potencial da flow blockchain e está disposto a assumir alguns riscos, investir agora pode ser uma ótima oportunidade.

Inspirado no conteúdo original em inglês: https://twitter.com/Frlabs33/status/1610267433796882432

O flow blockchain é uma plataforma de tecnologia de blockchain promissora que pode oferecer muitos benefícios para aqueles que investem nela, incluindo o potencial de crescimento a longo prazo, oportunidades de negócios, adoção antecipada, resiliência e impacto positivo. No entanto, é importante lembrar de fazer a sua própria pesquisa e entender os riscos envolvidos antes de investir.

## Quer fazer parte da revolução descentralizada como desenvolvedor Web3? 

Siga este guia para obter dicas sobre como começar e ter uma carreira bem-sucedida neste campo emocionante e em crescimento.

Primeiro, é importante familiarizar-se com os fundamentos do desenvolvimento web. Isso inclui aprender HTML, CSS e JavaScript, bem como frameworks como o React.

Em seguida, você vai querer aprender sobre a web descentralizada, também conhecida como Web3. Isso inclui entender a tecnologia de blockchain e como ela funciona, bem como se familiarizar com protocolos como o Flow Blockchain.

Para se tornar um desenvolvedor Web3, também é importante ter um bom entendimento de contratos inteligentes e da linguagem de programação Cadence, usada para escrevê-los. Você pode aprender através de recursos online ou trabalhando em projetos e contribuindo para a comunidade de código aberto.

Conforme você continuar aprendendo e ganhando experiência, pode ser interessante especializar-se em um aspecto particular do desenvolvimento Web3, como front-end ou back-end, ou se concentrar em um uso específico, como finanças descentralizadas (DeFi) ou tokens não fungíveis (NFTs).

Por fim, fique de olho nas últimas tendências e avanços no espaço Web3 e continue aprendendo e ficando atualizado sobre as últimas ferramentas e tecnologias. Isso o ajudará a ficar relevante e em demanda como desenvolvedor Web3.

Inspirado no conteúdo original em inglês: https://twitter.com/Frlabs33/status/1609902138729144320



O Web3 é a próxima geração da web, descentralizada e baseada em blockchain. Para se tornar um desenvolvedor Web3 de sucesso, é importante dominar os fundamentos do desenvolvimento web, entender a tecnologia de blockchain e os protocolos Web3, ter uma boa compreensão de contratos inteligentes e Cadence, poder especializar-se em um aspecto particular do desenvolvimento Web3 ou em um uso específico, e ficar atualizado sobre as últimas tendências e tecnologias. Mantendo-se atualizado e especializado, você poderá aproveitar ao máximo as oportunidades neste campo em rápido crescimento.

5 passos para se tornar um dev Web3

Flow é um da tecnologia blockchain projetada do início ao fim com o objetivo de ser integrado em jogos e aplicativos, tornando-se uma rede blockchain de alta velocidade e uma arquitetura modular extremamente flexível para o desenvolvimento.

Os devs da Flow criaram um sistema no qual várias funções podem coexistir, funções que são desempenhadas por seus nós, cada uma com um objetivo muito específico. Isso permite que você divida suas tarefas recebidas (as transações que você envia) de maneiras exclusivas, tornando-as mais fáceis de atender.

Então, por exemplo, se uma transação interage com um contrato inteligente avançada (ex: uma interação com um DApp), a referida transação é dividida em duas partes: a primeira, onde estão os metadados da transação (quem envia, endereços, entre outros).

E, a segunda, a interação com o contato inteligente como tal, que deve ser invocado (a partir de seu endereço), executado e oferecer uma resposta ao nosso usuário (que é visível no blockchain). Além disso, todo esse processo deve ser verificado, obedecer às regras de consenso e, finalmente, ser incluído no blockchain. Se estivéssemos no Ethereum, essas tarefas são realizadas de forma linear (lenta e cara).

Mas no Flow, a primeira e a segunda partes vão para um tipo de nó (chamado de nó de execução), enquanto as tarefas de consenso, verificação e armazenamento são atribuídas a tipos de nós específicos para cada tarefa. Como cada um desses pontos requer trabalho computacional específico (alguns requerem mais potência do que outros), a divisão do trabalho torna o fornecimento de grandes volumes de informações mais fácil e rápido de fazer no final. A Flow criou uma rede blockchain de operação heterogênea (com nós atribuídos para diferentes funções), com paralelismo e escalabilidade que cresce com o número de nós na rede.

Você quer uma explicação mais simples do que esta? Veja da seguinte forma, não é a mesma coisa ter um restaurante em que você ocupa todos os cargos (de chef, garçom, caixa), do que ter uma equipe que o apoia em cada tarefa e, principalmente, se o seu restaurante tem uma grande procura e afluência de comensais. O primeiro seria o sistema atual de muitos blockchains, enquanto o segundo seria Flow.

Explorando como o Flow funciona em profundidade
Agora que sabemos como o Flow funciona em geral, é bom saber como ele o faz acontecer. Em primeiro lugar, Flow é um projeto com uma arquitetura multifuncional pensada na divisibilidade de atribuições e tarefas. Isso é essencial, porque a arquitetura de rede Flow, embora complexa, é muito menos problemática do que as outras opções que encontramos nesse mercado. Com isso dito, vamos primeiro explorar como seus nós são divididos e quais são suas funções.



Flow é uma blockchain projetada para ser usada em jogos e aplicativos, especialmente para NFTs. Ele foi criado com o objetivo de resolver o problema de escalabilidade das blockchains existentes e foi construído para suportar ecossistemas de aplicativos e jogos de alto desempenho sem comprometer a descentralização. A Flow permite que seus nós desempenhem funções específicas, dividindo as tarefas e tornando-as mais fáceis de serem cumpridas. A arquitetura de rede Flow é mais simples e menos problemática do que outras opções no mercado.

Como a rede blockchain flow funciona?

Blockchain eu expliquei no link acima. Como a ethereum, A flow também permite que você crie aplicações descentralizas (dApps).

Surgiu no dia 15 de agosto de 2019 a Flow é uma blockchain que oferece suporte para criação (dApps), principalmente games em blockchain e NFTs. Seu token nativo é o FLOW.

Foi criada com o objetivo de solucionar o problema de escalabilidade (capacidade de suportar aumento de transações) das blockchains existentes.

A Flow foi construída desde o início para suportar ecossistemas de aplicativos e jogos de alto desempenho sem comprometer a descentralização. O Bitcoin e o Ethereum mostraram como as criptomoedas podem tornar o mundo das finanças mais aberto e transparente; a Flow fará o mesmo para os consumidores de entretenimento e cultura.

Após o sucesso desta primeira venda de tokens, em setembro de 2019.

O trabalho foi recompensado em maio de 2020, e finalmente foi anunciado o lançamento de sua versão beta.

O trabalho continuou e em 6 de agosto de 2020, outra venda de tokens privados foi realizada.

Essa segunda rodada de financiamento tem sido usada para acelerar o desenvolvimento do sistema, que naquele momento ainda estava em beta.

Mesmo sua camada principal ainda em desenvolvimento, não foi limitante para possibilidade de lançar aplicativos descentralizados poderosos em sua rede.

Na verdade, hoje é possível enviar e receber criptomoedas, criar DApps, tokens fungíveis e tokens não fungíveis (NFT), bem como mercados. Isso catapultou o preço do token FLOW de impressionantes US $0,1 (no momento da venda inicial) para mais de $30 nos primeiros meses de 2021.


A Flow é uma blockchain projetada para suportar a criação de aplicativos descentralizados, especialmente jogos e tokens não fungíveis. Ela foi criada com o objetivo de solucionar o problema de escalabilidade das blockchains existentes e oferece suporte para ecossistemas de aplicativos e jogos de alto desempenho sem comprometer a descentralização. Seu token nativo é o FLOW e, apesar de ainda estar em desenvolvimento, a Flow já permite a criação de aplicativos descentralizados poderosos, como enviar e receber criptomoedas, criar tokens fungíveis e NFTs, e mercados. O preço do token FLOW aumentou significativamente desde o seu lançamento.

O que é Flow Blockchain?



![https://miro.medium.com/max/700/1\*pccxbH9FmN9zxWG5dyvuLA.png](https://miro.medium.com/max/700/1\*pccxbH9FmN9zxWG5dyvuLA.png)

# **O que são opcionais?**

Opcionais são uma forma de lidar com variáveis que podem ou não ter um valor. Eles permitem que gerencie situações de erro e outras circunstâncias de forma mais elegante, tornando explícito o estado vazio ou não disponível de uma variável.

Para declarar basta adicionar um símbolo de interrogação `` após a declaração da variável.

Por exemplo:

```
nome var: String?
```

Isso diz que o valor de `` pode ser do tipo ``, ou pode ser ``, ou seja, não ter um valor.

`` tecnicamente já é um valor. Porém é um valor usado para representar o valor nulo ou valor ausente de uma variável.

Isso Mesmo, `` é usado para representar a ausência de um valor. Ele pode ser usado de maneira semelhante ao valor null.

Por exemplo, imagine que você tem uma variável chamada `` que pode ou não conter um valor. Se você declarar nome como opcionais, poderá atribuir a ela um valor normalmente, como nome = "Diego", mas também poderá atribuir o valor `` indicando que ela **ainda** não tem um valor ou que *não está disponível*.

Isso é útil porque permite que o programador faça uma distinção de forma fácil.

Isso pode ajudar a evitar erros no código e a tornar o código mais legível. Com os opcionais fica mais fácil de lidar com ``.

Você declara opcionais usando o `?` após a declaração variável regular.

## **Por que eu gostaria de dizer que algo é `nil`?**

Os opcionais permite a capacidade de lidar com casos de erro e situações semelhantes.

O objetivo principal é tornar explícito o **estado indisponível** / **vazio** / nada de uma variável, e ainda mais, torná-lo explícito quando algo nunca pode ser indisponível / **vazio**.

Nos idiomas que permitem que qualquer variável seja nula, geralmente não está claro se a variável pode ser nula no local específico do código, o que leva a dois problemas:

*   O caso nulo não é tratado pelo programador e, em seguida, há um valor nulo, causando uma referência nula, ou seja, falha;
*   Ou o caso nulo é considerado pelo programador e eles adicionam verificações defensivas para lidar com o suposto caso nulo, embora nunca ocorra, causando sobrecarga desnecessária.

Aqui está um exemplo:

Digamos que estamos usando o campo que eu defini acima em um contrato, mas não como opcional:

```
contrato de pub NameHolder {
    nome do pub var: String
}
```

Se o valor ainda não foi definido, mas alguém deseja lê-lo, como comunicamos que ele não foi definido? Poderíamos simplesmente retornar uma sequência vazia, mas isso é efetivamente o mesmo que retornar qualquer sequência não vazia, portanto, o leitor pode não saber que uma sequência vazia significa que ainda não foi definida e cometer um erro ao supor que está tudo bem.

Se tornarmos o campo opcional:

```
contrato de pub NameHolder {
    nome do pub var: String?
}
```

Então fica muito claro para o leitor. Se eles tentarem ler `name` e eles recebem `nil` de volta, eles podem lidar facilmente com o erro e fazer o que precisarem nesse caso.

Em Cadence, é necessário inicializar os campos em tipos compostos, para que esse problema exato não ocorra com muita frequência, mas você verá casos semelhantes que são um pouco mais complexos.

Por exemplo, os valores em dicionários são todos opcionais. Você pode inicializar um dicionário para ficar vazio assim:

```
let lastNameDictionary: { String: String } = { "Josh": "Hannan" }
```

Porém, como existe um número infinito possível de pares de valores-chave, se você tentar acessar qualquer um deles, ele retornará um opcional, mesmo que o valor exista para a chave que você fornece!

```
let lastNameDictionary: { String: String } = { "Josh": "Hannan" }// Ambos causam um erro:
// Inválido: tipos incompatíveis. esperado `String`, conseguiu `String?
deixe existirNome: String = lastNameDictionary [ "Josh" ]
let newName: String = lastNameDictionary [ "Kayla" ]
```

## **Como eu lido com opcionais?**

Se deixados por conta própria, os opcionais podem ser um punhado!

![https://miro.medium.com/max/700/1\*nSwqKtEWqWv5wAjEk6Lh3A.jpeg](https://miro.medium.com/max/700/1\*nSwqKtEWqWv5wAjEk6Lh3A.jpeg)

Como tiramos você de lá??? Acho que temos que desembrulhar a caixa!

Valores de variáveis opcionais ainda são considerados agrupados no opcional. “ Embrulhado ” é um termo que significa que ainda não sabemos se o valor é ou não `nil` ou não. Se você tentar executar uma operação normal que normalmente pode executar com o tipo que está usando, ela falhará no verificador de tipo Cadence:

```
let x: Int? = 2// Inválido: não é possível aplicar operação binária + aos tipos: `Int?`, `Int`
y = x + 2
```

Embora ambos os argumentos especifiquem alguma forma de `Int` , `x`ainda está encerrado, então o programa não sabe se é `nil` ou não. Não nos permitirá executar uma operação matemática com ele, porque você não pode adicionar `nil` e um número! Isso explodiria o universo!!!!

Você precisa desembrulhar o valor do opcional primeiro e executar a operação.

Isso também se aplica a tipos compostos. Se você possui um tipo composto opcional, é necessário desembrulhar o opcional antes de poder chamar qualquer um de seus métodos ou acessar qualquer um de seus campos.

Aqui está um exemplo simples:

```
contrato de pub HelloWorld {
    recurso de pub OpcionalOlá {
        pub fun hello ( ): Corda {
            retornar "olá"
        }
    }    access ( self ) let helloResource: @OptionalHello?    init ( ) {
        self.helloResource < - crie OpcionalOlá ( )
    }    // Função pública que retorna nossa saudação amigável!
    pub fun hello ( ): Corda {
        retorne self.helloResource.hello ( )
    }
}
```

Portanto, se você vir um erro como este:

```
valor do tipo `HelloWorld.OptionalHello?`não tem membro `olá`. membro desconhecido
```

Procure o `?` no final do nome do tipo. O objeto geralmente ainda é opcional e precisa ser desembrulhado antes de chamar o `hello` método. ( melhores mensagens de erro também estão chegando no futuro ) 😃

# **Opcionais de desembrulho**

Existem várias maneiras diferentes de desembrulhar opcionais, e todos eles têm comportamento diferente e são usados para diferentes casos de uso.

## **Operador de coalescência nula**

O [operador de coalescência nula](https://docs.onflow.org/cadence/language/values-and-types/#nil-coalescing-operator) `??` retorna o valor dentro de um opcional se ele contiver um valor ou retorna um valor alternativo especificado se o opcional não tiver valor, ou seja, o valor opcional é `nil`.

Se o lado esquerdo não estiver nulo, o lado direito não será avaliado.

[Consulte os documentos da Cadence para obter mais informações](https://docs.onflow.org/cadence/language/values-and-types#nil-coalescing-operator) sobre o operador de coalescência nula.

Você provavelmente verá isso muito usado ao pedir referências a recursos e recursos. É possível colocar qualquer código no lado direito do `??` portanto, se um empréstimo falhar, ele retornará um opcional que seja `nil` , mas em muitos casos, se um empréstimo falhar, a transação deverá falhar. O operador de coalescência nula nos permite entrar em pânico e imprimir uma mensagem de erro para que o estado seja revertido e o chamador saiba exatamente o que deu errado.

Por exemplo, quando emprestamos uma referência à conta `FlowToken` receptor, geralmente usamos isso:

```
// Obtenha uma referência ao Receptor do destinatário
deixe receiverCap = obter conta ( para ) .getCapability ( / public / flowTokenReceiver )

deixe o receiverRef = receiverCap.borrow < & { FungibleToken.Receiver } > ( )
    ?? panic ( "Não foi possível emprestar referência ao receptor" )
```

Se `borrow` obtém sucesso, retorna uma referência válida. Se falhar, ele retornará `nil` . Portanto, o tipo do valor de retorno é `&{FungibleToken.Receiver}?` e precisamos desembrulhá-lo antes que possamos usá-lo.

## **Invadir Força**

Outra maneira mais sucinta de desembrulhar um valor opcional é usar o operador de desbaste de força (`!` ). O desembrulho de força obterá o valor do opcional, se existir, ou entrará em pânico e abortará se não existir.

![https://miro.medium.com/max/700/1\*QL8nrzSr7sn8M53dkgtT8Q.png](https://miro.medium.com/max/700/1\*QL8nrzSr7sn8M53dkgtT8Q.png)

Este opcional não deseja ser desembrulhado

```
deixe um: Int? = 3
let b: Int = a!   // Terá sucesso e retornará 3let c: Int? = nada
let d: Int = c!   // Entrará em pânico e abortará em tempo de execução
```

[Consulte os documentos da Cadence para obter mais informações e exemplos de força-desembrulho.](https://docs.onflow.org/cadence/language/values-and-types/#force-unwrap-)

Se um force-unwrap falhar, ele imprimirá apenas uma mensagem de erro genérica sobre falha ao tentar forçar o desembrulho. Por esse motivo, você deve ter muito cuidado com o local de uso do force-unwrap, porque se falhar, será muito mais difícil determinar de onde vem o erro.

Você deve usar apenas o operador de desbloqueio de força em locais onde tenha certeza absoluta de que o valor não será `nil` . Por exemplo, se você já verificou que não está em uma condição prévia, sabe que quando forçar a quebra, estará seguro.

## **Encadernação opcional**

Outra maneira poderosa de desembrulhar e manipular opcionais é através de encadernação opcional, um método que permite incluir o desembrulho em um condicional que executa diferentes blocos de código, dependendo de como o desembrulho ocorreu.

O bloqueio opcional é uma variante do if-statement que executa condicionalmente um corpo de código se um opcional for `nil` ou não.

[Veja os documentos de cadência para exemplos de encadernação opcional](https://docs.onflow.org/cadence/language/control-flow/#optional-binding)

A ligação opcional é uma maneira completa de lidar com diferentes casos de opcionais, pois oferece a maior flexibilidade com o comportamento do seu programa.

Se `nil` é um valor potencial esperado para um opcional em seu programa e você tem muitas operações que precisa executar nesse caso, então a ligação opcional é o caminho a seguir.

## **Encadeamento opcional**

Por último, mas não menos importante, temos um encadeamento opcional. Às vezes, existem tipos compostos opcionais, porque são armazenados em um dicionário ou retornados como opcionais de uma função que os recupera. Se você deseja chamar uma função em um tipo composto opcional, pode usar o encadeamento opcional para chamar “ opcionalmente ” essa função. Se o objeto que você está chamando é `nil` , ele simplesmente não executa nenhuma função e segue em frente e retorna `nil` .

[Consulte os documentos da Cadence para obter mais informações e exemplos.](https://docs.onflow.org/cadence/language/composite-types#accessing-fields-and-functions-of-composite-types-using-optional-chaining)

# **Conclusão**

Os opcionais são uma característica importante de muitos idiomas e aprender a usá-los adequadamente é importante para escrever código limpo e seguro, para que você entenda bem!

Espero que este post tenha sido informativo e útil!

![https://miro.medium.com/max/700/1\*Bt7h4pwGTISjTwHrzTjypw.png](https://miro.medium.com/max/700/1\*Bt7h4pwGTISjTwHrzTjypw.png)

Inspirado no Artigo Original em inglês: https://joshuahannan.medium.com/optionals-in-cadence-not-optional-fb39bb4b0081


Opcionais em Cadence? Não opcionais!

Tomando seus primeiros passos com Cadence

A Flow também significa DIVERTIMENTO!

Olá! Meu nome é Diego Fornalha sou engenheiro de contratos inteligente e Embaixador na Flow. Estou no espaço blockchain desde o início de 2017, passei alguns anos trabalhando em projetos Ethereum e comecei a trabalhar como advocate na Flow em junho de 2018. Escrevo contratos e documentação de Cadence e ajudo nos esforços da comunidade.

A cadence é uma linguagem fascinante, e quero fazer tudo o que puder para iniciar mais conversas sobre o assunto.

## **O que é flow?**

[O Flow é uma nova blockchain](https://www.onflow.org/primer) construído para a próxima geração de aplicativos, jogos e ativos digitais que os alimentam. A arquitetura exclusiva do Flow permite escalar sem fragmento, enquanto ainda fornece a mesma descentralização e segurança que todos esperam de uma blockchain.

![https://miro.medium.com/max/500/1\*FUuphC1mmWrVXGUxa7dVww.gif](https://miro.medium.com/max/500/1\*FUuphC1mmWrVXGUxa7dVww.gif)

Está tudo bem, você pode levar o seu tempo aqui. Eu assisti esse presente repetir por cerca de 10 minutos na primeira vez que o vi.

# **Por onde começar?**

Recentemente, houve muito interesse em Flow. Talvez todos tenham tomado resoluções de Ano Novo ’ para aprender sobre o Flow? Talvez Flow tenha sido mencionado em um Elon Musk Tweet ™? Talvez haja um [Jogo NFT construído no Flow](https://www.nbatopshot.com/) isso é impressionante em popularidade e impulsiona desenvolvedores que desejam criar ferramentas para isso e outras experiências semelhantes? Impossível dizer com certeza. 😜

De qualquer maneira, há muitas pessoas novas na comunidade Flow e muitas pessoas que querem aprender sobre Cadence. Nem sempre é claro por onde começar e para onde ir depois que você aprendeu o básico.

Primeiro, se você é completamente novo no blockchain, Eu recomendo que você encontre um guia ou curso on-line que apresente os princípios básicos da tecnologia de contabilidade distribuída ( fora do escopo deste post ) antes de continuar sua jornada de Cadência.

Eu também recomendo ler o **Primário de Flow** construir um entendimento básico da arquitetura da blockchain Flow.

\*\*\*\*[Flow Primer: a blockchain para mundos abertos Flow, a blockchain para mundos abertos O Flow é uma blockchain rápida, descentralizada e amigável ao desenvolvedor, projetada como…\*\*
www.onflow.org](https://www.onflow.org/primer)

## **Etapa 1: Introdução à cadência**

O [Introdução à cadência](https://docs.onflow.org/cadence) faz um ótimo trabalho explicando as importantes decisões de design por trás da Cadence e por que elas são importantes. É vital entender antes de tentar aprender o idioma.

Eu também recomendo conferir [post deste blog](https://medium.com/dapperlabs/resource-oriented-programming-bee4d69c8f8e) de Dete Shirley, o CTO do Dapper Labs e um dos principais arquitetos de Flow and Cadence, que está a apenas alguns memes e tweets virais de alcançar o status de culto. Ele explica por que o modelo de programação Cadence, programação orientada a recursos, é o modelo ideal para ativos digitais.

Mais uma postagem de blog para ler sobre o modelo de conta Flow and Cadence é esta da Decentology:

\*\*\*\*[Então, como as contas de Flow são diferentes das contas no Ethereum?Esta postagem do blog é para desenvolvedores que aprendem sobre o blockchain Flow No futuro, assumiremos que você tem…\*\*
www.decentology.com](https://www.decentology.com/guides-and-tutorials/blockchain-accounts-flow-vs-ethereum)

Eles fazem um ótimo trabalho descrevendo o que torna a programação e o modelo de conta Flow únicos e especiais.

Já era hora de uma pausa, certo? Não? Bem, não me deixe te segurar!

## **Etapa 2: Tutoriais de cadência**

Em seguida, você deve concluir todos os Tutoriais de Cadência, começando com [Primeiros passos](https://docs.onflow.org/cadence/tutorial/01-first-steps/) e terminando com [Contrato de Votação](https://docs.onflow.org/cadence/tutorial/08-voting/). Esses tutoriais usam contratos reais para orientá-lo sobre os recursos importantes do Cadence passo a passo.

Os tutoriais ajudarão a familiarizá-lo com o [**Flow Playground**](https://play.onflow.org/), uma ferramenta incrível para escrever rapidamente e testar manualmente seus contratos inteligentes no seu navegador!

![https://miro.medium.com/max/700/1\*bT_xMbOYiX8jVmocjlW2CA.png](https://miro.medium.com/max/700/1\*bT_xMbOYiX8jVmocjlW2CA.png)

Apenas um gosto

Há também um [Extensão do código do Visual Studio](https://docs.onflow.org/vscode-extension) você pode instalar para ter destaque de sintaxe e um emulador de Flow embutido no VSCode! Muito arrumado, certo?

## **Etapa 3: interfaces padrão**

Como você aprenderá nos tutoriais, muitos projetos de blockchain usam tokens fungíveis, tokens não fungíveis ou ambos, mesmo que não precisem.

Existem interfaces padrão para os dois tipos que recomendamos que você utilize para ser interoperável com outros contratos inteligentes. Eles estão cada um em um repositório separado do Github.

Padrão de Fosca Fungível

\*\*\*\*[Flow / Flow-ft Esta é uma descrição do padrão Flow para contratos de token fungíveis. Destina-se a conter o mínimo…\*\*
github.com](https://github.com/onflow/flow-ft)

Padrão de token não fungível

\*\*\*\*[onflow / flow-nftEsta é uma descrição do padrão de trabalho em andamento para contratos de token não fungíveis no Flow Blockchain. Isto é…\*\*
github.com](https://github.com/onflow/flow-nft)

Estes serão seus primeiros exemplos de contratos inteligentes que são realmente implantados no Flow Mainnet e usados em aplicativos reais.

## **Etapa 4: Tópicos avançados de cadência**

Depois de entender bem o básico, mergulhe em algumas explicações mais detalhadas dos recursos do Cadence. O [referência formal ao idioma](https://docs.onflow.org/cadence/language) é um ótimo recurso que todo desenvolvedor de cadência deve ler se tiver tempo e o site de documentos recomendou [Padrões de design de cadência e antipadrões](https://docs.onflow.org/cadence/design-patterns/) que todo desenvolvedor deve estar ciente para manter um código claro e seguro.

## **Também Etapa 4: Contratos de cadência real**

A essa altura, tenho certeza de que você foi totalmente doutrinado no culto da Cadência e está com coceira, então veja o que outros construíram com essa incrível linguagem de programação.

Não? Você bebeu um pouco do [delicioso kool-aid](https://www.nbatopshot.com/) ali? É bastante saboroso. Sim, lá vai você. Agora você entende.

Agora que estamos na mesma página, aqui estão alguns ótimos exemplos de contratos inteligentes da Cadence que estão sendo executados na rede de teste e / ou rede principal. ( Eu posso ser um pouco tendencioso porque ajudei a escrever alguns deles. )

\*\*[Contratos principais de Flow:\*\*](https://github.com/onflow/flow-core-contracts) Este repo contém os contratos e transações inteligentes que fazem parte do protocolo Flow principal. Eles reforçam o comportamento do token da rede Flow, taxas, apostas, épocas e muito mais.

[**Itens de gatinha:**](https://github.com/onflow/kitty-items) A equipe Flow and Cryptokitties reuniu recentemente este incrível exemplo de jogo da NFT, mercado, e aplicação que usa as melhores práticas de ponta mais recentes para o desenvolvimento de cadência e Flow em plena aplicação que está sendo executada na rede de teste!

[**Melhor tiro da NBA:**](https://github.com/dapperlabs/nba-smart-contracts) Você pode ter ouvido falar deste. A Top Shot e seu mercado estão em operação no Flow Mainnet desde junho de 2020 e se tornou extremamente popular. **AVISO LEGAL**: Os contratos Top Shot foram escritos há muito tempo e, portanto, usam alguns padrões de design da Cadence desatualizados e não recomendados para a maioria dos projetos da NFT no futuro. O projeto Kitty Items é um exemplo muito melhor para as melhores práticas da Cadence.

# **Conclusão**

Se você chegou até aqui, parabéns! Espero que agora você tenha ferramentas e conhecimentos suficientes para escrever seus próprios contratos inteligentes em Cadence.

Ao longo do caminho, você tem toda a equipe e comunidade Flow para apoiá-lo! Não hesite em entrar em contato com nosso servidor Discord, o Flow Forum ou através de um problema no repo Flow Github.

Existem outros recursos ou projetos interessantes que você sabe que seriam úteis para os recém-chegados? Sinta-se à vontade para comentar com suas idéias e eu posso incluí-las em um post futuro!

Artigo Original em Inglês: https://joshuahannan.medium.com/taking-your-first-steps-with-cadence-19dde86bbd0


O Flow é uma blockchain projetada para ser rápida, descentralizada e amigável ao desenvolvedor. É projetada para ser usada em aplicativos, jogos e ativos digitais. A arquitetura exclusiva do Flow permite que ele escalável sem fragmentação, mantendo a descentralização e a segurança esperadas de uma blockchain. A linguagem de programação da Flow é a Cadence, que é orientada a recursos e foi desenvolvida especificamente para ativos digitais. Para aprender mais sobre o Flow e a Cadence, é recomendável ler o Primário de Flow e o Introdução à Cadence, bem como outros materiais de aprendizado disponíveis online. A comunidade Flow também é uma fonte valiosa de aprendizado e suporte para aqueles que desejam aprender mais sobre a tecnologia.

![https://miro.medium.com/max/347/1\*M7p33-EGZPFdKcX7oR6mDg.jpeg](https://miro.medium.com/max/347/1\*M7p33-EGZPFdKcX7oR6mDg.jpeg)

Isso é apenas para o administrador pressionar. Não pressione. Por favor. Pretty Please

Chegamos à segunda semana sem esquecer o blog! Pegue isso, inimigos! 🙌

Se você é novo aqui, seja bem-vindo! Este é um blog semanal sobre o Cadence, o novo idioma de ponta do Flow para contratos inteligentes. Eu recomendo começar com [meu primeiro post sobre materiais para iniciantes](https://joshuahannan.medium.com/taking-your-first-steps-with-cadence-19dde86bbd0) antes de ler isso, porque assumirei que os leitores já têm um entendimento básico de Cadence ou simplesmente apreciam meu estilo de escrita. ( Estou lisonjeado! )

# **O que é controle de acesso?**

Controle de acesso é a restrição de campos, funções e tipos para determinados escopos e usuários. É extremamente importante que os desenvolvedores considerem profundamente para garantir que seu código seja protegido contra possíveis vulnerabilidades. Tecnologia Blockchain certamente [teve seu quinhão de bugs e façanhas](https://forum.openzeppelin.com/t/list-of-ethereum-smart-contracts-post-mortems/1191) e muitos deles poderiam ter sido impedidos com um controle de acesso mais bem gerenciado.

Acredito que todo desenvolvedor deve ter um entendimento completo do controle de acesso Cadence antes mesmo de pensar em implantar seu projeto na rede principal. Altos padrões que conheço, mas estamos lidando com coisas com valor real aqui! ( e a maioria de vocês provavelmente não vai me ouvir de qualquer maneira e apenas copie o código Top Shot sem pensar nele )

Ao contrário da maioria dos idiomas, o Cadence fornece duas camadas diferentes de controle de acesso, ambas incorporadas ao idioma:

*   [Controle de acesso baseado em palavras-chave](https://docs.onflow.org/cadence/language/access-control/)
*   [Controle de acesso baseado em capacidade](https://docs.onflow.org/cadence/language/capability-based-access-control/)

Eu recomendaria conferir isso antes de ler mais desta postagem.

Não vou fornecer uma explicação detalhada dos diferentes tipos de controle de acesso neste post, mas vou falar sobre alguns dos motivos para utilizá-los, e alguns exemplos de como eles podem ser usados efetivamente em contratos inteligentes.

# **Dois tipos de controle de acesso em Cadence**

## **Controle de acesso por palavra-chave**

O primeiro tipo de controle de acesso em Cadence é o tipo com o qual a maioria de vocês provavelmente conhece: Usando palavras-chave para especificar o nível de acesso de um campo específico.

O Cadence fornece quatro palavras-chave diferentes para especificar os níveis de acesso. Cada campo, função e tipo é necessário para especificar um nível de acesso.

`pub` ou `access(all)` significa que a declaração é acessível / visível em todos os escopos. Cada um faz a mesma coisa, mas `pub` é mais curto, por isso é recomendável usar.

Por exemplo, um campo público em um tipo pode ser acessado usando a sintaxe de acesso `(`object.field`)` em uma instância do tipo em um escopo externo. Isso não permite que a declaração seja publicamente gravável.

Portanto, se eu tivesse esse contrato implantado na minha conta:

```
contrato de pub HelloWorld {    pub let saudação: Cordas    pub let saudaçõesByLanguage: { String: String }    retorno divertido do pubGreeting ( ): Corda {
        retornar self.greeting
    }}
```

Em uma transação ou script, qualquer pessoa que importe o contrato da minha conta poderá ler o `greeting` campo, `greetingsByLanguage` dicionário ou ligue para o `returnGreeting` função, mas eles não podem substituir o valor inteiro nesses campos, com uma exceção.

Se houver um dicionário público ou campo de matriz, mesmo que não possa ser substituído por alguém como este,

```
HelloWorld.greetingsByLanguage = { // Não é possível
```

um elemento ainda pode ser modificado por alguém como este.

```
HelloWorld.greetingsByLanguage [ "Español" ] = "Hola" // possível
```

Por esse motivo, é altamente recomendável tornar todos os campos em contratos e tipos compostos privados, `access(self)`, por padrão. Você pode definir configuradores e getters para seus campos. Vamos ver como isso se parece no contrato anterior.

```
contrato de pub HelloWorld {    access ( self ) let greeting: String    access ( self ) let greetingsByLanguage: { String: String }    retorno divertido do pubGreeting ( ): Corda {
        retornar self.greeting
    }    pub fun returnLanguageGreeting ( _ idioma: String ): String? {
        retornar self.greetingsByLanguage [ language ]
    }}
```

Isso usa `access(self)`, o que significa que a declaração é acessível / visível apenas nos escopos atual e interno. Por exemplo, um `access(self)` O campo só pode ser acessado por funções do tipo que fazem parte, não por código em um escopo externo. Isso permite que o desenvolvedor seja capaz de definir explicitamente como seus campos são acessados por getters e setters.

As outras duas palavras-chave de acesso são um pouco exclusivas da Cadence.

`access(contract)`significa que a declaração é acessível / visível apenas no escopo do contrato que a definiu. Isso significa que outros tipos e funções definidos no mesmo contrato podem acessá-lo, mas não outros contratos na mesma conta.

Você poderia ter algo assim:

```
contrato de pub HelloWorld {    pub struct Olá {        acesso ( contrato ) var saudação: corda    }    pub fun returnGreeting ( _ olá: Olá ): Corda {
        voltar olá.
    }}
```

Nesta situação, se você tivesse uma instância do `Hello` struct, você não seria capaz de obter diretamente o `greeting` campo usando `Hello.greeting`, mas desde o `returnGreeting` função é definida no mesmo contrato, você pode dar a ela `Hello` estruture e obtenha o `greeting` campo dessa maneira:

```
Olá, Olá, Olá, Olá, Olá, Olá, = "hola" (// inválido porque o campo é contrato de acesso
deixe saudação = helloObject.greeting// Válido: a função de contrato pode acessar o campo e
// devolvê-lo
deixe a saudação = HelloWorld.returnGreeting ( helloObject )// saudação é "hola"
```

Este é apenas um exemplo simples, mas tenho certeza de que você pode imaginar uma utilização mais sofisticada dessa capacidade.

`access(account)`significa que a declaração é acessível / visível apenas no escopo de toda a conta onde é definida. As contas de fluxo podem ter qualquer número de contratos de cadência implantados para eles, portanto, essa palavra-chave significa que quaisquer outros contratos na mesma conta podem acessá-lo.

Com este campo, você pode declarar campos em contratos como `access(account)` , sabendo que você deseja que eles sejam “ privados ” por enquanto, mas mantendo aberta a possibilidade de implantar um novo contrato posteriormente que possa interagir com o primeiro contrato de novas maneiras. Você também pode manter seus contratos mais simples, agrupando apenas funcionalidades semelhantes em um contrato, mas tendo contratos relacionados ainda na mesma conta que podem compartilhar algumas informações entre si.

Essa palavra-chave é a que tenho menos experiência em usar, mas recentemente tenho pensado em mais maneiras de usá-la. Se você tiver algum exemplo de onde o usou, deixe um comentário e me avise!

## **Controle de acesso baseado em capacidade**

A outra forma principal de controle de acesso em Cadence utiliza [Segurança baseada em capacidade](https://en.wikipedia.org/wiki/Capability-based_security), um modelo de segurança que não é usado com muita frequência. A maioria dos modelos de segurança ( e a maioria das outras linguagens de programação de contratos inteligentes ) restringem o acesso com base em *quem você é*, mas a segurança da capacidade é mais sobre *o que você possui*.

Vamos olhar para uma analogia:

![https://miro.medium.com/max/700/1\*uAtIjsm7b2QMc2f7bknWOg.png](https://miro.medium.com/max/700/1\*uAtIjsm7b2QMc2f7bknWOg.png)

tantas escolhas!

Imagem que você está projetando um dispositivo físico para o governo usar para gerenciar o acesso a importantes funcionalidades internas, como imprimir dinheiro, declarar guerra, pagar impostos etc. Todos no país precisam ter acesso a algum subconjunto dessa funcionalidade, mas a especificação de acesso de cada pessoa é diferente de muitas das outras pessoas. Por exemplo, todos precisam ter acesso à funcionalidade “ pagar impostos ”, mas apenas funcionários eleitos do governo precisam ter acesso à “ declarar guerra ” e assim por diante.

Se estivéssemos projetando esse sistema da maneira que a maioria dos contratos inteligentes gerencia o acesso, com uma lista que indica quem tem acesso a quê, então esse dispositivo físico se pareceria com uma placa de controle gigante em um local público com milhares de botões diferentes para cada funcionalidade sobre a qual o governo tem algum controle. Qualquer pessoa na Terra seria capaz de caminhar até este quadro e pressionar qualquer um dos botões, mas o botão executaria algum tipo de varredura biométrica ( como uma varredura de íris ou impressão digital ) para verificar se essa pessoa tem autoridade para executar a ação. Se eles passarem na verificação, a funcionalidade acontecerá. Existe até um botão público para alterar as regras de acesso!

Este é um exemplo artificial, mas tenho certeza de que você pode ver os problemas com isso. Se algum dos botões não foi projetado corretamente ou está com defeito, qualquer pessoa na Terra seria capaz de explorar o botão quebrado para fazer coisas que não deveria!

Uma solução mais eficaz para esse problema seria fornecer a cada cidadão um dispositivo que contenha apenas os botões de funcionalidade que eles podem acessar. Em seguida, cada cidadão armazena esse dispositivo em um local seguro em sua casa ou seguro que somente eles podem acessar. Agora, se houver uma vulnerabilidade em um dos botões, um invasor tem a difícil tarefa de invadir cada casa dos participantes e se proteger individualmente, o que é muito mais difícil e demorado.

É isso que os recursos realizam em Cadence. Em vez de criar uma lista especial de controle de acesso com regras opacas e complexas, o controle de acesso é incorporado aos fundamentos do sistema de tipos Cadence. Os usuários obtêm objetos de recursos especiais que armazenam em sua conta que definem qual funcionalidade eles podem acessar.

Usando o exemplo acima, criaríamos um `HelloAdmin` recurso que permite ao proprietário atualizar o `greeting` campo:

```
contrato de pub HelloWorld {    // Isso precisa ser um acesso ( contract ) para que o recurso definido em
    // o mesmo contrato pode acessá-lo
    acesso ( contrato ) var saudação: corda    retorno divertido do pubGreeting ( ): Corda {
        retornar self.greeting
    }    // Somente o proprietário deste objeto de recurso pode chamar essa função
    recurso de pub HelloAdmin {
        pub fun modificGreeting ( _ newGreeting: String ) {
            HelloWorld.greeting = newGreeting
        }
    }
}
```

Os atacantes nem sequer teriam a oportunidade de explorar muitos bugs em potencial, porque o código nem sequer é acessível a eles para tentar explorar em primeiro lugar!

Os recursos são um assunto complexo, e estou planejando fazer uma postagem no blog no futuro que seja completamente dedicada a eles. Por enquanto, eu recomendaria verificar [post deste blog](https://medium.com/@kleffew/what-is-capability-based-security-227c6e5483a5) sobre recursos genéricos e [Documentação de capacidade de cadência](https://docs.onflow.org/cadence/language/capability-based-access-control/).

# **Conclusão**

Espero ter deixado alguns dos recursos de controle de acesso do Cadence um pouco mais claros para você.

Compartilhe todos os usos interessantes dos recursos de controle de acesso da Cadence que você fez ou viu outros implementarem!

Se você tiver alguma dúvida, toda a equipe e comunidade do Flow está aqui para apoiá-lo! Não hesite em entrar em contato com nosso servidor Discord, o Flow Forum ou através de um problema no repo Flow Github.

Existem outros tópicos ou projetos interessantes que você sabe que seriam úteis para os recém-chegados ou sobre os quais você gostaria que eu escrevesse uma postagem no blog? Sinta-se à vontade para comentar com suas idéias e eu posso incluí-las em um post futuro!

Artigo original em inglês: https://joshuahannan.medium.com/basic-access-control-in-cadence-28c5765c6ec0


O controle de acesso em contratos inteligentes escritos em Cadence, uma linguagem de programação para a plataforma Flow. O controle de acesso é a restrição de acesso a campos, funções e tipos em um contrato para determinados escopos e usuários e é importante para evitar vulnerabilidades no código. O Cadence fornece duas camadas de controle de acesso: baseado em palavras-chave e baseado em capacidade. As palavras-chave "pub" e "access(all)" permitem que uma declaração seja acessível em todos os escopos, enquanto "in" e "access(self)" restringem o acesso a um escopo específico. O controle de acesso baseado em capacidade permite que um contrato conceda ou negue acesso a outros contratos com base em suas capacidades específicas. É recomendado que os desenvolvedores tenham um entendimento completo do controle de acesso em Cadence antes de implantar seus projetos na rede principal.

Novidades