Stack de Pagamento de Agentes: Arquitetura de Referência
Quatro primitivas on-chain. Três fluxos combináveis. Tudo que você precisa para construir pagamentos agente-a-agente no Ergo — de uma única chamada API até uma moeda comunitária completa.
As Quatro Primitivas
Reserve · Note · Tracker · Predicate
Reserve
Garantia de capital
Um contrato on-chain que mantém ERG ou tokens como garantia. Qualquer pessoa pode verificar a taxa de reserva a qualquer momento. A Reserve é o banco — sem intermediários.
- Mantém ERG / tokens nativos
- Auditável a qualquer momento
- Garante emissão de Note 1:1 ou fracionariamente
- Resgate aplicado pelo contrato
{
// Reserve contract: allow withdrawal only
// if redemption note is burned
val noteBox = INPUTS(1)
val burnCheck = noteBox.tokens.size == 0
sigmaProp(burnCheck && SELF.R4[Long].get > 0)
}Note
IOU programável
Um token ao portador representando um crédito contra uma Reserve. Notes podem ser transferidos, divididos e resgatados. O Predicate de aceitação define quem pode receber ou resgatar o Note.
- Instrumento ao portador — sem identidade necessária
- Transferível ponto a ponto
- Resgatável contra contrato de Reserve
- Denominação em qualquer token
{
// Note: transferable by holder,
// redeemable against reserve
val holder = SELF.R4[GroupElement].get
val isHolder = proveDlog(holder)
val isRedemption = INPUTS.exists { box =>
box.tokens.exists(_._1 == reserveId)
}
isHolder || isRedemption
}Tracker
Contabilidade on-chain
Rastreia saldos acumulados, uso de crédito e histórico de resgate em todos os Note emitidos por uma Reserve. Pense nele como um livro-razão público que qualquer pessoa pode verificar.
- Rastreia total emitido vs resgatado
- Aplica limites de crédito
- Auditável publicamente
- Combinável com outros contratos
{
// Tracker: ensure running total
// doesn't exceed credit limit
val limit = SELF.R4[Long].get
val used = SELF.R5[Long].get
val newUsed = used + INPUTS(0).value
sigmaProp(newUsed <= limit)
}Acceptance Predicate
Regra de confiança programável
A condição sob a qual um agente aceitará um Note como pagamento. As condições podem incluir verificação de hash de tarefa, verificações de prazo, provas de credenciais ou quaisquer dados on-chain.
- Condições de aceitação arbitrárias
- Verificação de hash de tarefa
- Aplicação de prazos
- Combinável com provas Sigma
{
// Accept note only if:
// 1. Task hash matches R4
// 2. Deadline not passed
val taskHash = SELF.R4[Coll[Byte]].get
val deadline = SELF.R5[Int].get
val inputHash = INPUTS(0).R4[Coll[Byte]].get
val onTime = HEIGHT <= deadline
sigmaProp(taskHash == inputHash && onTime)
}Fluxos de Exemplo
Três fluxos combináveis
Fluxo A: Agente compra chamada API
Uma chamada. Uma prova. Sem conta persistente.
- 1
Agente cria Note
0,001 ERG valor nominal, endereço do provedor em R4
- 2
Provedor verifica Predicate
Verifica valor do Note, garantia Reserve, prazo
- 3
Provedor entrega resposta
Retorna resultado API, marca Note como gasto
- 4
Liquidação
Note queimado, ERG liberado da Reserve para o provedor
// Fleet SDK: create a note for API payment
import { TransactionBuilder, OutputBuilder, SAFE_MIN_BOX_VALUE } from "@fleet-sdk/core"
const noteBox = new OutputBuilder(
1_000_000n, // 0.001 ERG
NOTE_CONTRACT_ADDRESS
)
.setAdditionalRegisters({
R4: SGroupElement(providerPubKey), // recipient
R5: SLong(BigInt(HEIGHT + 100)), // deadline
R6: SColl(SByte, taskHashBytes), // task identifier
})
const tx = new TransactionBuilder(currentHeight)
.from(inputs)
.to(noteBox)
.sendChangeTo(agentAddress)
.payMinFee()
.build()Fluxo B: Agente paga a crédito
Reserve implantada. Notes emitidos. Tracker monitora.
- 1
Implantar Reserve
Bloquear ERG no contrato Reserve com limite de crédito
- 2
Emitir Notes
Criar Notes contra Reserve até o limite de crédito
- 3
Agente gasta Notes
Notes transferidos para provedores, Tracker atualizado
- 4
Auto-liquidação
Ao atingir o limite, Reserve liquida Notes pendentes
// Deploy a reserve with 10 ERG, 100 ERG credit limit
const reserveBox = new OutputBuilder(
10_000_000_000n, // 10 ERG collateral
RESERVE_CONTRACT_ADDRESS
)
.setAdditionalRegisters({
R4: SLong(100_000_000_000n), // 100 ERG credit limit
R5: SLong(0n), // issued so far
R6: SGroupElement(ownerKey), // reserve controller
})
// Issue a note against the reserve
const noteBox = new OutputBuilder(
1_000_000_000n, // 1 ERG face value
NOTE_CONTRACT_ADDRESS
)
.setAdditionalRegisters({
R4: SGroupElement(agentKey), // holder
R5: SColl(SByte, reserveId), // backing reserve
})Fluxo C: Reserve comunitária + Tracker
Um marketplace local, uma cooperativa de computação, uma rede de agentes.
- 1
Comunidade implanta Reserve
ERG reunidos pelos membros da comunidade
- 2
Emitir Notes comunitários
Membros recebem Notes proporcionais à contribuição
- 3
Comércio local
Notes aceitos na comunidade, Predicates definem regras
- 4
Resgate
Membros resgatam Notes por ERG da Reserve a qualquer momento
// Community reserve: multiple funders
const communityReserve = new OutputBuilder(
TOTAL_POOLED_ERG,
MULTISIG_RESERVE_CONTRACT
)
.setAdditionalRegisters({
R4: SColl(SGroupElement, memberKeys), // governance
R5: SInt(3), // 3-of-5 threshold
R6: SColl(SByte, communityTokenId), // community token
})
// Acceptance predicate: only members of community
const memberPredicate = `{
val isMember = CONTEXT.dataInputs(0)
.R4[Coll[GroupElement]].get
.exists(pk => proveDlog(pk))
sigmaProp(isMember)
}`SDKs e Ferramentas
Comece a construir hoje
Fleet SDK
TypeScript / JS
Construa transações no seu navegador ou Node.js. Melhor ponto de partida para pagamentos de agentes.
sigma-rust
Rust
Assinatura e serialização de alto desempenho. Ideal para infraestrutura de agentes em produção.
Estado atual
Status do stack
Cinco camadas estão ativas. Duas são problemas abertos. Junte-se à conversa no GitHub — estes são os problemas não resolvidos mais interessantes em dinheiro de agentes.