← Voltar ao início

Arquitetura

Parity

Verificação de ações tokenizadas na Solana. Como o sistema responde sem fazer uma única chamada externa no momento da visita.

1. O problema

A mesma ação americana existe na Solana como vários tokens, de emissores diferentes, e eles não são intercambiáveis. Negociam em pools separados, carregam poderes de emissor diferentes, e alguns não podem ser vendidos de jeito nenhum.

Toda interface mostra um preço e um botão de compra. Nenhuma mostra se o emissor pode congelar aquele saldo, se ele pode tirar o token da carteira sem assinatura do dono, ou quanto custa de verdade sair da posição.

O problema de engenharia é este: responder essas três perguntas para qualquer ticker, em menos de um segundo, sem carteira conectada, sem gastar chamada de API por visita, e sem nunca mostrar poder de custódia desatualizado.

2. Os números

Tudo abaixo foi medido contra a mainnet da Solana. Os scripts que produziram esses números estão no repositório e a saída bruta é commitada em data/.

32
tokens no registro verificado
96
cotações ao Jupiter por rodada de coleta (32 tokens × 3 tamanhos)
15 min
intervalo entre coletas
1,5 s
espera proposta entre cada chamada ao agregador
0
chamadas externas numa visita normal ao site
77
testes, nenhum deles precisa de rede
30 de 32
tokens podem ser congelados pelo emissor
16 de 32
têm delegado permanente, o emissor move sem assinatura do dono
13 de 32
não retornaram rota nenhuma: aparecem com preço e não podem ser negociados
US$ 132
custo real de entrada numa ordem de US$ 1.000 em AMDx

3. O desenho

São três caminhos independentes. O que importa é que o caminho da direita, o da visita, não cruza nenhuma fronteira externa.

COLETA — A CADA 15 MINGitHub ActionsJupiter96 cotações, 1,5 s entre cadaJSONL do diacommit + pushBUILD — A CADA COMMIT DE DADOBuild na Vercellê registro, snapshotse custódia via RPC1 página por ticker gerada antesLEITURA — A CADA VISITAVisitanteCDNHTML estáticoZERO CHAMADA EXTERNARPC · Jupiter · DBfronteira externa

Separar os três é o que permite que um pico de tráfego não encoste no RPC nem no agregador. Quem visita o site lê HTML que já existia antes da visita acontecer.

4. As decisões

Toda decisão tem preço. Abaixo está o que escolhi, o que descartei, por quê, e o que isso custa.

01. O git é o banco de dados

Escolhi
Cada rodada de coleta acrescenta linhas a um arquivo JSONL do dia e faz um commit no próprio repositório.
Em vez de
Postgres, ou qualquer banco hospedado.
Porque
O dado é append-only, é pequeno, e o valor dele depende de ser verificável por terceiro. O git dá carimbo de tempo que eu não controlo, hospedagem de graça e trilha de auditoria sem eu escrever uma linha para isso. Qualquer número publicado no site pode ser conferido contra o commit que o gerou.
Preço que pago
Não existe consulta. Para responder como a liquidez do AMDx se moveu em três semanas, eu leio e parseio arquivos. Não há índice. A partir de certo volume isso deixa de funcionar.

02. Nenhuma chamada externa no caminho de leitura

Escolhi
Uma página por entrada do registro, gerada antes. Ticker desconhecido é recusado sem sair para a rede.
Em vez de
Buscar cotação ao vivo a cada visita.
Porque
RPC de camada gratuita e o tier público do Jupiter têm limite de requisição. Um pico de tráfego ou custaria dinheiro ou falharia exatamente quando mais gente está olhando. Página de 15 minutos atrás é melhor que página que não carrega.
Preço que pago
O dado é tão fresco quanto o último build. E token fora do registro não tem resposta, o que também é proteção, mas continua sendo limitação.

03. Duas políticas de frescor na mesma tela

Escolhi
Liquidez vem dos snapshots commitados. Custódia é lida do nó RPC pelo adapter.
Em vez de
Uma política de cache única para tudo.
Porque
Os dois dados falham de formas diferentes. Liquidez muda o tempo todo, e mostrar um número de 15 minutos atrás é aceitável desde que rotulado. Custódia quase nunca muda, mas quando um emissor ativa autoridade de congelamento, mostrar o valor antigo é o pior erro possível do produto, porque é exatamente o aviso que a pessoa veio buscar.
Preço que pago
A página mistura dois carimbos de tempo. Isso precisa ser exibido ao usuário, senão engana.

04. Núcleo puro, entrada e saída só nas bordas

Escolhi
Toda lógica financeira em src/core como função pura, sem I/O. Rede apenas em src/adapters, passando dado simples para dentro.
Em vez de
Funções que buscam e calculam no mesmo lugar.
Porque
Caminho que mexe com dinheiro precisa de teste de propriedade. Função que faz chamada de rede não pode ser executada dez mil vezes com entrada gerada. Com a separação, os 77 testes rodam sem rede nenhuma.
Preço que pago
Mais arquivos, e uma camada de mapeamento entre o dado do adapter e o tipo do núcleo.

05. Limite de requisição autoimposto, 1,5 segundo

Escolhi
Uma espera fixa de 1.500 ms entre cada cotação, dentro do job.
Em vez de
Requisições em paralelo, ou tentar de novo quando levar 429.
Porque
O job tem 15 minutos de janela e precisa de uns 3. Gastar tempo é de graça. Levar bloqueio no tier público do Jupiter não é. Lento e certo ganha de rápido e bloqueado.
Preço que pago
A rodada leva minutos em vez de segundos. Se o registro crescer para 300 tokens, são 900 cotações vezes 1,5 s, ou seja 22 minutos, e estoura a janela. Essa decisão tem validade conhecida.

06. Concorrência resolvida pelo git, não por trava

Escolhi
Grupo de concorrência no Actions com cancel-in-progress falso, rebase com autostash antes do push, e saída sem commit quando não há dado novo.
Em vez de
Uma tabela de lock ou uma fila.
Porque
Existe exatamente um escritor e o dado é append-only por dia. O tratamento de conflito do próprio git cobre a única corrida real, que é outro commit entrar entre o checkout e o push.
Preço que pago
Se uma rodada passar de 15 minutos, as execuções enfileiram em vez de rodar junto, e o espaçamento da série começa a derivar.

5. O que quebra

Incluindo o que está mal resolvido hoje. Página de arquitetura que só lista acerto não serve para nada.

O agendamento do GitHub não é pontual

A documentação do GitHub avisa que execução agendada pode atrasar ou ser descartada em horário de pico. Isso deixa a série com espaçamento irregular e com buracos. Importa porque o site apresenta a série como prova. A parte honesta é que cada registro carrega o próprio carimbo de captura, então o buraco fica visível em vez de escondido. A parte não resolvida é que nada avisa quando acontece.

Falha do coletor é silenciosa

Se o job falhar, porque o Jupiter mudou o formato da resposta, porque o runner levou bloqueio, ou porque o push foi recusado, o site continua servindo o último build sem nenhum sinal de que a série parou. Hoje o único aviso é a notificação do GitHub, que depende de alguém ler.

Build com RPC fora do ar

Custódia é lida ao vivo no build. Se o nó estiver indisponível naquele momento, o comportamento correto é o build falhar, e não publicar dado de custódia de idade desconhecida. É o tipo de falha que só aparece no dia em que acontece.

Deriva do registro

Mint adicionado ao registro entra sem histórico. E se um emissor mudar um poder entre dois builds, o site mostra o valor antigo até o próximo build, que é exatamente o caso que o produto existe para evitar.

O Jupiter é fonte única

O custo de saída é o que o agregador responde. Se o roteamento dele mudar ou errar, o Parity publica isso como fato. Não existe segunda fonte para cruzar.

6. O que eu mudaria em 100x

Cenário: 10 mil tokens monitorados em vez de 32, e 50 mil visitas por dia com pico de 500 por segundo.

O que sobrevive sem mudar nada

O caminho de leitura. Página estática em CDN não liga para 50 mil visitantes nem para o pico. Esse lado já está resolvido pelo desenho atual.

O que quebra primeiro

O coletor. Dez mil tokens vezes 3 tamanhos vezes 1,5 segundos dá 12 horas e meia por passada. A cadência de 15 minutos vira impossível antes de qualquer outra coisa dar problema.

Na ordem em que eu mudaria

  1. 1

    Acabar com a cadência única. Token não é tudo igual: um mint sem rota e sem volume não precisa de cotação a cada 15 minutos, um líquido precisa. Cadência por faixa, com os quentes a cada 15 minutos e a cauda longa uma vez por dia.

  2. 2

    Tirar a espera fixa e ir para um tier pago com limite declarado e concorrência controlada, para a passada ser limitada pelo limite de requisição e não por sleep.

  3. 3

    Tirar o volume do git. Dez mil tokens em 96 rodadas por dia faz o repositório crescer centenas de MB por semana e torna o clone inviável. Snapshot vai para armazenamento de objeto, endereçado por conteúdo, e só o hash do resumo diário continua commitado. A propriedade de auditoria se mantém, o peso sai.

  4. 4

    Parar de reconstruir todas as páginas a cada commit de dado. Com 10 mil páginas isso deixa de fechar. Liquidez passa a regeneração incremental por página, custódia continua no build.

Esta página descreve o sistema como ele está hoje, incluindo o que ainda não está resolvido. Os números vêm de medição na mainnet e se movem com o tempo.