Publicado em novembro 13, 2025novembro 15, 2025 in Consultoria, Dinheiro, Pesquisa de I.A., Smart Contracts, Vox Leone

Os Agentes de IA Estão Fragmentando o Setor Financeiro

Durante décadas, os bancos e as grandes instituições financeiras serviram como a espinha dorsal dos nossos sistemas econômicos. Seus serviços eram essenciais, sua expertise exclusiva e sua infraestrutura incomparável.

Uma pessoa usa um iPad sobre uma mesa. — *Imagem: pexels.com*

Mas hoje, uma nova força está emergindo, desafiando o domínio dos gigantes não por meio de confrontos, mas por meio de uma substituição silenciosa e crescente: os agentes de IA.

Os agentes de IA são sistemas de software capazes de correlacionar, buscar dados, analisar instrumentos financeiros e produzir insights acionáveis, tudo sem intervenção humana. Eles não apenas replicam o trabalho de um analista júnior ou de um consultor financeiro automatizado; representam uma mudança fundamental em quem controla o conhecimento, o acesso e a execução financeira.

Essa mudança tem implicações importantes. Ela ameaça corroer os modelos baseados em taxas nos quais muitas instituições financeiras se apoiam. Ela mina a própria ideia de autoridade financeira centralizada. Mais importante ainda, ela estabelece as bases para um ecossistema financeiro fragmentado: um futuro onde as finanças não são mais controladas por algumas instituições monolíticas, mas distribuídas por sistemas inteligentes e interoperáveis.

O que as instituições financeiras costumavam oferecer

Tradicionalmente, bancos e corretoras justificavam suas taxas oferecendo acesso a recursos que os usuários não conseguiam obter por conta própria:

Dados e insights: Investidores institucionais tinham acesso a melhores ferramentas de pesquisa, análises privilegiadas e previsões econômicas.
Infraestrutura de execução: Negociação, transferências, custódia e conformidade eram realizadas em sistemas proprietários e caros.
Assessoria humana: Especialistas ofereciam aconselhamento personalizado, estratégias de longo prazo e a confiança construída por meio de relacionamentos.
Custos regulatórios: As instituições lidavam com a complexidade legal da movimentação de dinheiro e da gestão de riscos.

Essas adições de valor faziam sentido quando o usuário médio não possuía as ferramentas nem a expertise para operar de forma independente. Mas o cenário está mudando rapidamente.

O que os agentes de IA oferecem atualmente

Os agentes de IA modernos eliminam muitas das barreiras que antes exigiam intermediação financeira. Construídos em plataformas como OpenBB, LangChain ou outros ecossistemas de código aberto, esses agentes podem:

Analisar ações, portfólios ou tendências macroeconômicas em tempo real
Realizar análises de risco personalizadas com base em critérios definidos pelo usuário
Extrair e sintetizar dados de APIs, notícias, sentimento em redes sociais e relatórios de resultados
Recomendar alocações de ativos com base em condições em tempo real, e não em modelos estáticos
Oferecer resultados estruturados: painéis, alertas, tabelas, gráficos e até citações

E fazem tudo isso a um custo marginal próximo de zero. Operam continuamente, melhoram com o uso e são totalmente programáveis.

Por exemplo, os agentes financeiros do OpenBB podem ser implantados de forma privada ou compartilhados entre equipes, integrando dados internos e externos. Em uma determinada configuração, os agentes se especializam: um lida com dados macroeconômicos, outro avalia indicadores técnicos e outro se concentra no sentimento do mercado. Um agente supervisor os orquestra, combinando seus resultados em uma única análise útil para o usuário final.

Por que as estruturas de taxas tradicionais estão sob pressão

Os agentes de IA estão prestes a corroer os fundamentos econômicos de muitos serviços financeiros. Alguns dos mais vulneráveis incluem:

Gestão de patrimônio (taxas de 1 a 2% sobre o patrimônio sob gestão). Por que está em risco: Os agentes oferecem portfólios personalizados e estratégias de rebalanceamento a uma fração do custo.
Comissões de negociação. Por que está em risco: o roteamento inteligente de ordens por meio de agentes reduz a dependência de corretoras e minimiza os custos de spread.
Gestão de fundos. Por que está em risco: A IA pode replicar ou superar as estratégias tradicionais, tornando obsoletos os fundos ativos com altas taxas.
Transferências e movimentações. Por que está em risco: Sistemas on-chain e mediados por agentes tornam as transferências globais mais baratas e rápidas.
Análise de crédito. Por que está em risco: Decisões de empréstimo baseadas em IA reduzem a necessidade de serviços de originação caros.

Quando os usuários podem executar um agente que realiza análises melhores, mais rápidas e mais baratas do que um consultor humano, a justificativa para as taxas tradicionais desaparece completamente.

Rumo a um mercado financeiro fragmentado

À medida que os agentes de IA se tornam mais capazes e acessíveis, o mercado financeiro vai se fragmentando. Eis como essa fragmentação acontece:

A infraestrutura bancária torna-se modular: APIs substituem os sistemas antigos, os chamados sistemas legados. Você não precisa mais de um “banco”, precisa de componentes de serviços bancários, como custódia, relações com clientes ou pagamentos, que podem ser integrados conforme a necessidade.

Os serviços de investimento se desagregam: Pesquisa, risco, alocação e execução são separados e recombinados usando agentes personalizados para usuários ou empresas individuais.

O crédito se descentraliza: Empréstimos peer-to-peer e baseados em contratos inteligentes, impulsionados por modelos de pontuação de IA, desafiam os sistemas de crédito centralizados.

A consultoria é personalizada e descentralizada: Agentes treinados com base em seus objetivos financeiros atuam como planejadores financeiros digitais, sem incentivos de vendas.

A conformidade é gerenciada na borda: Agentes de IA podem lidar com KYC/AML (Conheça Seu Cliente/Antilavagem de Dinheiro) localmente, monitorar o risco de transação e se adaptar às regras jurisdicionais sem supervisão centralizada.

Não se trata da criação de uma novas instituições financeiras para substituir as antigas. Trata-se do surgimento de milhares de serviços inteligentes e interoperáveis.

Mas e a confiança?

As instituições financeiras sempre dependeram da confiança. Equity, garantias de segurança, supervisão regulatória. Os agentes de IA não podem substituir completamente isso, mas alteram a base da confiança.

Em vez de confiar em um banco, os usuários confiarão:

No código e na transparência do agente (explicabilidade, registros, citações)
Nos dados que ele utiliza (auditáveis, com fontes, com permissão)
No sistema em que ele opera (seguro, auto-hospedado ou de código aberto)

As instituições que se adaptarem a esse modelo, fornecendo infraestrutura, garantias regulatórias e controle do usuário, ainda poderão prosperar; aquelas que se apegarem à opacidade e às taxas por serviços básicos terão dificuldades.

Uma Reorganização

Os agentes de IA não eliminam a necessidade de serviços financeiros; eles reorganizam a forma como esses serviços são prestados e quem os controla. Aparentemente, as instituições evoluirão para:

Provedores de back-end para conformidade, custódia ou liquidez
Hospedagem de agentes que oferecem ferramentas de IA de nível empresarial para clientes
Agregadores de dados que alimentam os sistemas dos agentes com dados financeiros verificados

O centro de gravidade se desloca das instituições para os agentes e dos produtos para os serviços personalizados.

Enfim

O futuro das finanças não é monolítico. Agentes de IA estão capacitando indivíduos e pequenas empresas a operar em um nível que antes exigia um exército de analistas e milhões em infraestrutura. Essa democratização desafia a economia das finanças tradicionais, especialmente aquelas baseadas em taxas e exclusividade.

A fragmentação está surgindo, não por ideologia, mas simplesmente porque é mais eficiente, mais transparente e mais alinhada ao zeitgeist e às necessidades do usuário.

A fragmentação já começou.

Publicado em maio 9, 2025maio 13, 2025 in Blockchain, Dados, Smart Contracts, Vox Leone

Guia Prático: Blockchain e Contratos Inteligentes II

Na primeira parte deste guia prático exploramos os fundamentos da blockchain. A segunda parte tem um foco claro e objetivo: mostrar na prática a estrutura dos contratos inteligentes e como você pode implementá-los em sua própria blockchain.

Mão escrevendo 'Ethereum" em um quadro 'white board'. — *Imagem: pexels.com*

Se no primeiro volume vimos a estrutura básica do bloco e da blockchain, aqui começamos a plantar os mecanismos que darão vida às aplicações descentralizadas (dApps). Seja para transferências automatizadas, registros imutáveis ou lógica condicional entre partes, os contratos inteligentes são a chave para desbloquear o verdadeiro potencial da Web3.

🚀 Integrando Contratos Inteligentes à Sua Blockchain

Contratos inteligentes permitem acordos automatizados e autoexecutáveis sem a necessidade de uma autoridade central. Você pode implementá-los diretamente na sua blockchain para viabilizar funcionalidades como transferência de ativos, validação de transações ou execução de aplicativos descentralizados (dApps).

🌐 Visão Geral dos Contratos Inteligentes

Contratos inteligentes são programas que rodam na blockchain. Eles podem ser escritos em linguagens como Solidity (comumente usada no Ethereum) ou Vyper, e têm como objetivo automatizar acordos ou transações entre partes.

Em sua blockchain baseada em Go, você essencialmente precisará de:

Uma forma de armazenar contratos inteligentes na blockchain.
Um mecanismo para executar o código do contrato inteligente quando certas condições forem atendidas.

Vamos simular isso de forma simples para começar, utilizando as capacidades nativas do Go. Isso não será tão complexo quanto o Ethereum, mas ilustrará os conceitos. Se você quiser avançar para contratos inteligentes compatíveis com o Ethereum, precisará de Solidity e de um cliente Ethereum como Geth ou Parity.

Abordagem Básica para Integrar Contratos Inteligentes

1️⃣ Representar Contratos Inteligentes

Em Go, você pode representar um contrato inteligente criando uma estrutura (struct) para o código do contrato e seu estado. Vamos começar definindo um contrato inteligente simples que pode atualizar seu estado quando chamado.

type SmartContract struct {
	ID    int
	Code  string  // Este pode ser o código do contrato (por exemplo, código Solidity ou pseudo-código)
	State string  // Armazena o estado do contrato (por exemplo, "ativo", "concluído", etc.)
}

2️⃣ Adicionar Contratos Inteligentes aos Blocos

Você pode modificar a estrutura do bloco para incluir um contrato inteligente em cada bloco.

type Block struct {
	Index         int
	Timestamp     string
	Data          string // Dados da transação ou do contrato inteligente
	PrevHash      string
	Hash          string
	SmartContract *SmartContract // Adiciona um ponteiro para o contrato inteligente (se houver)
}

Ao adicionar um novo bloco, você pode verificar se o bloco deve conter um contrato inteligente e configurá-lo.

func (bc *Blockchain) addBlockWithContract(data string, contract *SmartContract) {
	prevBlock := bc.Chain[len(bc.Chain)-1]
	newBlock := Block{
		Index:         prevBlock.Index + 1,
		Timestamp:     time.Now().String(),
		Data:          data,
		PrevHash:      prevBlock.Hash,
		Hash:          calculateHash(prevBlock.Index+1, prevBlock.Hash, data),
		SmartContract: contract,
	}
	bc.Chain = append(bc.Chain, newBlock)
}

3️⃣ Simular a Execução do Contrato

Uma maneira básica de simular a execução de um contrato é chamando uma função no SmartContract quando certas condições forem atendidas.

Vamos supor que você tenha um contrato que permite alguém “ativá-lo” e definir seu estado como “concluído”:

func (sc *SmartContract) execute() {
	// Para este exemplo simples, vamos dizer que executar significa mudar o estado
	if sc.State == "ativo" {
		sc.State = "concluído"
		fmt.Println("Contrato executado com sucesso!")
	} else {
		fmt.Println("Contrato já está concluído!")
	}
}

Então, na sua blockchain, você poderia ter uma função que verifica se há contratos que precisam ser executados quando um novo bloco é adicionado:

func (bc *Blockchain) executeContracts() {
	for _, block := range bc.Chain {
		if block.SmartContract != nil && block.SmartContract.State == "ativo" {
			block.SmartContract.execute()
		}
	}
}

4️⃣ Acionar Contratos Inteligentes

Agora você pode executar a lógica do contrato inteligente ao adicionar blocos à sua blockchain:

func main() {
	blockchain := Blockchain{}
	blockchain.Chain = append(blockchain.Chain, createGenesisBlock())

	// Cria um novo contrato inteligente
	contract := &SmartContract{
		ID:    1,
		Code:  "transferir(100 tokens)",
		State: "ativo", // Inicialmente ativo, pode ser executado
	}

	// Adiciona o contrato a um novo bloco
	blockchain.addBlockWithContract("Dados da Transação", contract)

	// Executa quaisquer contratos ativos
	blockchain.executeContracts()

	// Imprime a blockchain para verificar o estado do contrato
	for _, block := range blockchain.Chain {
		fmt.Printf("Bloco %d: %s - Estado do Contrato: %s\n", block.Index, block.Timestamp, block.SmartContract.State)
	}
}

5️⃣ Expandir os Contratos Inteligentes

Para tornar este sistema mais semelhante ao que você veria com contratos inteligentes baseados no Ethereum, você poderia:

Adicionar uma linguagem (como Solidity) para escrever contratos mais complexos.
Usar uma máquina virtual para executar a lógica do contrato (semelhante à EVM do Ethereum).
Adicionar mecanismos de gás para limitar quanto de recursos cada execução de contrato consome.
Implementar um algoritmo de consenso para execução descentralizada (Proof of Work, Proof of Stake, etc.).

Considerações do Mundo Real

Para integrar completamente contratos inteligentes em uma blockchain:

Armazenamento de dados: Armazene o código e os estados do contrato de forma descentralizada (por exemplo, IPFS ou em seus blocos).
Ambiente de execução: Você precisará implementar um sistema para interpretar e executar o código do contrato de forma segura. Isso poderia ser semelhante à Máquina Virtual Ethereum (EVM), mas poderia ser muito mais simples na sua blockchain baseada em Go.
Segurança: Contratos inteligentes podem ser vulneráveis a ataques como reentrância ou bugs de estouro. Lidar com isso de forma segura é crucial (por exemplo, testando contratos minuciosamente).

Conectar a um Contrato Inteligente baseado em Ethereum (Avançado)

Se você está procurando conectar sua blockchain Go ao Ethereum ou a uma blockchain semelhante ao Ethereum para executar contratos inteligentes Solidity, aqui está a abordagem geral:

Instalar o Web3 para Go: Esta é uma biblioteca Go que permite interagir com contratos inteligentes do Ethereum. go get github.com/ethereum/go-ethereum
Conectar-se ao Ethereum: Você precisará configurar um nó Ethereum (por exemplo, usando Infura ou executando seu próprio nó) e usar o Web3 em Go para implantar e interagir com contratos inteligentes.

Aqui está um exemplo:

package main

import (
    "fmt"
    "log"

    "github.com/ethereum/go-ethereum/accounts/abi"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)

func main() {
    client, err := ethclient.Dial("https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID")
    if err != nil {
        log.Fatalf("Falha ao conectar ao cliente Ethereum: %v", err)
    }

    address := common.HexToAddress("0xYourContractAddress")

    fmt.Println("Conectado ao Ethereum!")
    fmt.Println("Endereço do Contrato:", address.Hex())
}

Nesta segunda parte, exploramos na prática como os contratos inteligentes funcionam dentro de uma blockchain. Em breve vamos aprofundar ainda mais: analisando padrões de contratos inteligentes, interações entre múltiplos contratos e desafios reais como segurança, escalabilidade e integração com redes como Ethereum.

O futuro é descentralizado — e ele começa com nossas linhas de código.

Publicado em abril 24, 2025abril 25, 2025 in Blockchain, Dados, Smart Contracts

Guia Prático: Blockchain e Contratos Inteligentes I

Há muito tempo tenho vontade de criar um tutorial. No entanto, sempre tive um certo pudor, além do receio de ser (percebido como) apenas mais um.

Imagem decorativa do texto, mostrando objetos de escritório em torno da palavra 'blockchain' — *Imagem: pexels.com*

Sempre estabeleci como condição para um tutorial que o assunto tratado fosse realmente relevante e original. Agora, finalmente, surge a oportunidade de desenvolver um tutorial original sobre esse sistema importante, ainda pouco compreendido, mas cada vez mais presente na realidade do mundo moderno.

A mídia fala constantemente sobre blockchain e seus derivados — como as criptomoedas e os contratos inteligentes mas, para muitos, incluindo colegas de profissão, esses conceitos ainda são envoltos em uma névoa de imprecisão, quando não de total confusão. Este guia tem como objetivo destacar o aspecto concreto dessas tecnologias, trazendo à tona sua implementação real por meio de código, e mostrando, na prática, como interagir com elas dentro do ambiente computacional.

Neste tutorial uso a linguagem Go, tanto pela simplicidade como por seu uso crescente nos projetos voltados à Blockchain. Qualquer LLM poderá refatorar o código facilmente para qualquer outra linguagem, como Python.

O que é uma Blockchain?

O termo “blockchain” vem da junção das palavras em inglês block (bloco) e chain (cadeia), e descreve exatamente o que ela é: uma cadeia de blocos ligados entre si, onde cada bloco contém um conjunto de dados, um carimbo de data/hora (timestamp), e um hash que o conecta ao bloco anterior. Essa estrutura torna os dados praticamente imutáveis, sendo largamente usada para garantir transparência e segurança em ambientes descentralizados.

Um Pouco de História

A ideia de encadear blocos usando hashes não surgiu com o Bitcoin. Já em 1991, Stuart Haber e W. Scott Stornetta propuseram um sistema computacional para armazenar documentos com carimbos de tempo de forma segura — sem possibilidade de adulteração. Esse trabalho é considerado uma das raízes da blockchain moderna. Foi somente em 2008 que Satoshi Nakamoto uniu essa ideia com o conceito de dinheiro digital, criando o Bitcoin e, com ele, a blockchain como a conhecemos hoje.

Conceitos-chave para Entender

🧩 Bloco

Cada bloco é como uma página em um livro-razão digital. Ele possui:

Carimbo de data/hora (T1, T2, T3…): Indica quando o bloco foi criado.
Hash do bloco anterior (PreHash): Uma “impressão digital” do bloco anterior, que o conecta à cadeia.
Hash atual (Root Hash): Calculado com base no conteúdo do bloco e serve para garantir sua integridade.
Dados: Pode conter qualquer informação — transações financeiras, contratos, documentos, etc.

Figura 1 - Diagrama ilustrativo da blockchain. — **Fig 1** – Ilustração da estrutura de um bloco.

Como se vê, o hash do bloco anterior se liga ao hash atual, conectando a cadeia. Se qualquer informação em um bloco for alterada, seu hash muda. Isso quebra a cadeia, tornando evidente que houve uma tentativa de adulteração.

🔐 Hashing

Hashing é o processo de aplicar uma função criptográfica sobre um dado para obter uma sequência de caracteres (o hash). Um dos algoritmos mais usados é o SHA-256, criado pela NSA e adotado amplamente desde os anos 2000. Ele transforma qualquer entrada (como um texto ou número) em uma sequência hexadecimal de 64 caracteres. Pequenas mudanças no dado original geram hashes completamente diferentes — um princípio chamado efeito avalanche.

⛏️ Prova de Trabalho (Proof of Work)

A Prova de Trabalho surgiu para resolver o problema da confiança em redes descentralizadas, como no Bitcoin. Ela exige que os participantes gastem poder computacional para adicionar novos blocos, tornando ataques muito caros e, portanto, inviáveis. A ideia foi inspirada em sistemas anti-spam dos anos 90 (como o Hashcash de Adam Back), onde uma tarefa computacional dificultava o envio de emails em massa.

🛠️ Construindo uma Blockchain Simples em Go

Agora que (provavelmente) entendemos os conceitos, vamos ver como isso se traduz em código.

Etapa 1: Definir a Estrutura do Bloco

package main

import (
    "crypto/sha256"
    "fmt"
    "time"
)

type Block struct {
    Index     int
    Timestamp string
    Data      string
    PrevHash  string
    Hash      string
}

🧱 Aqui definimos os principais componentes do bloco. Veja que a estrutura lógica do bloco define todos os ítens (atributos) do bloco, como ilustrado na Fig 1. Ele é uma estrutura básica, mas com tudo o que precisamos para construir a cadeia.

Etapa 2: Criar o Bloco Gênesis

func createGenesisBlock() Block {
    return Block{
        Index:     0,
        Timestamp: time.Now().String(),
        Data:      "Genesis Block",
        PrevHash:  "",
        Hash:      calculateHash(0, "", "Genesis Block"),
    }
}

📜 O bloco gênesis é o primeiro bloco da blockchain. Ele é especial porque não possui um antecessor. No Bitcoin, ele foi minerado por Satoshi Nakamoto em 3 de janeiro de 2009. Uma curiosidade: sua mensagem de dados incluía o título de uma manchete de jornal daquele dia, uma crítica à crise bancária da época.

Etapa 3: Função de Hash

func calculateHash(index int, prevHash, data string) string {
    record := fmt.Sprintf("%d%s%s", index, prevHash, data)
    hash := sha256.New()
    hash.Write([]byte(record))
    return fmt.Sprintf("%x", hash.Sum(nil))
}

🔍 Essa função garante a integridade do bloco, produzindo um hash único com base nas suas informações. Isso é o que torna a blockchain resistente a modificações: se qualquer dado mudar, o hash será diferente.

Etapa 4: Criar a Blockchain

type Blockchain struct {
    Chain []Block
}

func (bc *Blockchain) addBlock(data string) {
    prevBlock := bc.Chain[len(bc.Chain)-1]
    newBlock := Block{
        Index:     prevBlock.Index + 1,
        Timestamp: time.Now().String(),
        Data:      data,
        PrevHash:  prevBlock.Hash,
        Hash:      calculateHash(prevBlock.Index+1, prevBlock.Hash, data),
    }
    bc.Chain = append(bc.Chain, newBlock)
}

🔗 Aqui a cadeia começa a tomar forma. Cada novo bloco contém o hash do anterior, criando a estrutura de “cadeia”.

Etapa 5: Iniciar e Usar a Blockchain

func main() {
    blockchain := Blockchain{}
    blockchain.Chain = append(blockchain.Chain, createGenesisBlock())

    blockchain.addBlock("Primeiro bloco depois do genesis")
    blockchain.addBlock("Segundo bloco depois do genesis")

    for _, block := range blockchain.Chain {
        fmt.Printf("Index: %d, Timestamp: %s, Data: %s, PrevHash: %s, Hash: %s\n",
            block.Index, block.Timestamp, block.Data, block.PrevHash, block.Hash)
    }
}

📤 A execução do código imprime cada bloco da cadeia, demonstrando como a estrutura vai se formando e se conectando.

Etapa 6: Saída Esperada

Index: 0, Timestamp: ..., Data: Genesis Block, PrevHash: , Hash: 6b3d...
Index: 1, Timestamp: ..., Data: Primeiro bloco depois do genesis, PrevHash: 6b3d..., Hash: 2c6e...
Index: 2, Timestamp: ..., Data: Segundo bloco depois do genesis, PrevHash: 2c6e..., Hash: 9c4a...

📊 Você verá blocos encadeados, com cada PrevHash correspondendo ao Hash do bloco anterior.

🧠 O que mais?

A blockchain construída acima é funcional, mas ainda simples. Você pode expandir com:

✅ Validação da Blockchain

func (bc *Blockchain) isValid() bool {
    for i := 1; i < len(bc.Chain); i++ {
        prevBlock := bc.Chain[i-1]
        block := bc.Chain[i]
        if block.PrevHash != prevBlock.Hash || block.Hash != calculateHash(block.Index, block.PrevHash, block.Data) {
            return false
        }
    }
    return true
}

🔎 Esta função verifica se a cadeia é válida. É um conceito essencial para detectar fraudes ou inconsistências em sistemas descentralizados.

🔨 Prova de Trabalho (Opcional)

Você pode implementar um campo nonce no bloco e ajustar o algoritmo de hash para que o resultado comece com, por exemplo, “0000”. Isso simula a mineração usada no Bitcoin, onde é preciso tentar milhões de combinações até encontrar um hash com a “dificuldade” exigida.

🌐 Descentralização

Até agora, nossa blockchain é local e centralizada. Em um projeto mais complexo, você pode usar:

Go-Ethereum: Implementação oficial do Ethereum em Go.
Gorilla Websocket: Para comunicação P2P entre nós (nodes).
Go-Swagger: Para criar APIs REST que expõem a blockchain.

🎓 Conclusão da primeira parte

Construir uma blockchain do zero é uma excelente forma de aprender estruturas de dados, criptografia, segurança da informação e sistemas distribuídos. Começando com algo simples, você pode continuar a adicionar camadas de complexidade: provas de consenso, contratos inteligentes, persistência em disco, interfaces gráficas e muito mais.

Se você chegou até aqui você está mais perto de entender não só como a blockchain funciona, mas por que ela é revolucionária. Na segunda parte deste pequeno guia, vou mostrar a lógica estrutural de um contrato inteligente e como adicioná-lo à Blockchain.

Estou desenvolvendo um tutorial completo (e executável!) sobre o tema, que abrigarei em meu Github. Você pode acompanhar — e contribuir.

Publicado em dezembro 7, 2021dezembro 8, 2021 in Cripto, Smart Contracts, Software, tecnologia

Bug nos Smart Contracts aciona um alerta jurídico

Na última quinta-feira [02/12] o blog “Schneier on Security” divulgou o caso [e deu início a uma discussão técnica] do hacker que roubou US $ 31 milhões da empresa de blockchain MonoX Finance, explorando um bug no software que o serviço usa para redigir contratos inteligentes.

Especificamente, o atacante usou o mesmo token tanto para o tokenIn quanto para o tokenOut, que são métodos para trocar o valor de um token por outro neste tipo de operação. Funciona mais ou menos assim: O MonoX atualiza os preços após cada troca, calculando novos preços para ambos os tokens [in e out]. Quando a troca é concluída, o preço do tokenIn, ou seja, o token que é enviado pelo usuário, diminui, e o preço do tokenOut, o token recebido pelo usuário, aumenta.

Ao usar o mesmo token para as diferentes operações de tokenIn e tokenOut, o hacker inflou muito o preço do token MONO porque a atualização do tokenOut sobrescreveu a atualização de preço do tokenIn. O hacker então trocou o token por $ 31 milhões em tokens nas blockchains Ethereum e Polygon.

O problema básico neste evento é que, na arquitetura da blockchain, o código é a autoridade final – não há um protocolo de adjudicação. Então, se houver uma vulnerabilidade no código, não há recurso possível [e, claro, existem muitas vulnerabilidades no código].

Para muito observadores, incluindo Bruce Schneier, essa é uma razão suficiente para não usar contratos inteligentes para algo importante, por enquanto.

Os sistemas de adjudicação baseados na intervenção humana não são uma inútil bagagem humana pré Internet. Eles são vitais.
Bruce Schneier

Código de programação versus arbitragem humana

Na modesta opinião deste bloguista, embora, de fato, estejamos muito longe de o código ser um árbitro da justiça melhor do que um ser humano, acho que o problema básico aqui tem menos a ver com o código sendo a autoridade final e mais a ver com a falta de um protocolo de adjudicação.

No momento, não há uma boa maneira de ajustar retrospectivamente os resultados desses chamados contratos “inteligentes” com base em conhecimentos ou fatos que só podem ser totalmente apreciados ex post ao invés de ex ante, seja o conhecimento de funcionalidades não intencionais do código ou circunstâncias específicas não antecipadas pelas partes contratantes.

Este parece ser um problema bem compreendido por profissionais do direito e um aspecto amplamente suportado por diversos sistemas jurídicos (por meio de várias doutrinas, como quebra de expectativa ou previsibilidade). Já os tecnologistas proponentes de contratos inteligentes [incluindo a mim] parecem não ter ainda uma visão clara desses aspectos.

Uma transferência legítima de acordo com as regras codificadas

Para além do ‘problema básico’ descrito acima, existe um outro problema não menos básico e que se não for tratado corretamente deixará os “Contratos Inteligentes” para sempre quebrados: a maioria dos programadores normalmente escreve código sequencial limitado, não código de máquina de estado completo. Assim, uma grande quantidade elementos computacionais é deixada de fora na implementação dos contratos. Esses elementos, portanto, ficam “pendurados” e esperando para ser usados [e abusados].

Alguns críticos da blockchain dos contratos inteligentes argumentam que seria necessário incorporar uma versão forte da chamada Lógica de Hoare para garantir a integridade da computação na blockchain. A lógica de Hoare é um conjunto fundamental de regras, publicadas no final dos anos 1960. O bloco fundamental da Lógica de Hoare é a Tripla de Hoare.

Uma tripla de Hoare é da forma

{P} C {Q}

Onde {P} e {Q} são afirmações sobre o estado do sistema e C é um comando.

P, é a pré-condição
Q, é a pós-condição

Onde as asserções P e Q são expressas como fórmulas na lógica de predicados.

Quando a pré-condição P é atendida, a execução do comando C causa mudanças no sistema e estabelece a pós-condição Q.

Embora seja possível construir um código de “estado completo” com a lógica de Hoare, não é algo que a maioria das pessoas goste de fazer. Em suma, é um processo tedioso, não criativo, e colocar os pingos nos i’s e cruzar os t’s podem ser tarefas incrivelmente tediosas. Portanto, raramente é implementada, o que acaba inevitavelmente trazendo problemas em um tempo futuro.

Na vida normal, a última coisa que alguém realmente deseja é ter contratos irrevogáveis. Então a arbitragem geralmente fica “embutida” informalmente nos contratos inteligentes, através de métodos ad hoc. Em princípio, não há razão para que os contratos inteligentes não possam ter arbitragem embutida. Mas isso apenas cria uma série de questões subsequentes que ninguém quer abordar.

Até que a arbitragem de fato ou o controle total do estado sejam implementados nos Smart Contracts, veremos muito mais desse tipo de coisa acontecendo.

Move fast, break things

Eu temo que o problema descrito aqui seja um resultado lógico da abordagem “mova-se rápido e quebre coisas” preconizadas pelo Manifesto Ágil. As pessoas precisam pensar com clareza sobre até onde [e se] podemos utilizar certos paradigmas de desenvolvimento de sistemas na construção da infraestrutura da blockchain.

E como eu disse em outros posts aqui, precisamos parar de chamar as coisas de “inteligentes” quando elas são estúpidas. Antigamente, um dispositivo que não era útil sem uma conexão de rede era apropriadamente chamado de terminal burro. O código é sempre vulnerável, e qualquer desenvolvedor que não entenda isso é um “stupid hire”.