Stack di Pagamento Agent: Architettura di Riferimento
Quattro primitive on-chain. Tre flussi componibili. Tutto ciò che serve per costruire pagamenti agent-to-agent su Ergo — da una singola chiamata API a una valuta comunitaria completa.
Le Quattro Primitive
Reserve · Note · Tracker · Predicate
Reserve
Garanzia di capitale
Un contratto on-chain che detiene ERG o token come garanzia. Chiunque può verificare il rapporto di riserva in qualsiasi momento. La Reserve è la banca — nessun intermediario.
- Detiene ERG / token nativi
- Verificabile in qualsiasi momento
- Supporta l'emissione di Note 1:1 o frazionalmente
- Rimborso applicato dal contratto
{
// 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
Pagherò programmabile
Un token al portatore che rappresenta un credito contro una Reserve. I Note possono essere trasferiti, divisi e rimborsati. Il Predicate di accettazione definisce chi può ricevere o rimborsare il Note.
- Strumento al portatore — nessuna identità richiesta
- Trasferibile peer-to-peer
- Rimborsabile contro il contratto di Reserve
- Denominazione in qualsiasi 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
Contabilità on-chain
Traccia saldi cumulativi, utilizzo del credito e cronologia dei rimborsi su tutti i Note emessi da una Reserve. Pensalo come un registro pubblico verificabile da chiunque.
- Traccia totale emesso vs rimborsato
- Applica limiti di credito
- Verificabile pubblicamente
- Componibile con altri contratti
{
// 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
Regola di fiducia programmabile
La condizione sotto la quale un agente accetterà un Note come pagamento. Le condizioni possono includere verifica dell'hash del task, controlli di scadenza, prove di credenziali o qualsiasi dato on-chain.
- Condizioni di accettazione arbitrarie
- Verifica dell'hash del task
- Applicazione delle scadenze
- Componibile con prove 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)
}Flussi di Esempio
Tre flussi componibili
Flusso A: L'agente acquista una chiamata API
Una chiamata. Una prova. Nessun account persistente.
- 1
L'agente crea un Note
Valore nominale 0,001 ERG, indirizzo del fornitore in R4
- 2
Il fornitore verifica il Predicate
Verifica valore del Note, garanzia Reserve, scadenza
- 3
Il fornitore consegna la risposta
Restituisce il risultato API, segna il Note come speso
- 4
Regolamento
Note bruciato, ERG rilasciato dalla Reserve al fornitore
// 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()Flusso B: L'agente paga a credito
Reserve distribuita. Note emessi. Tracker monitora.
- 1
Distribuire la Reserve
Bloccare ERG nel contratto Reserve con limite di credito
- 2
Emettere Note
Creare Note contro Reserve fino al limite di credito
- 3
L'agente spende i Note
Note trasferiti ai fornitori, Tracker aggiornato
- 4
Auto-regolamento
Al raggiungimento della soglia, Reserve regola i Note in sospeso
// 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
})Flusso C: Reserve comunitaria + Tracker
Un marketplace locale, una cooperativa di calcolo, una rete di agenti.
- 1
La comunità distribuisce la Reserve
ERG messi in comune dai membri della comunità
- 2
Emettere Note comunitari
I membri ricevono Note proporzionali al contributo
- 3
Commercio locale
Note accettati nella comunità, i Predicate definiscono le regole
- 4
Rimborso
I membri rimborsano Note per ERG dalla Reserve in qualsiasi 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)
}`SDK e Strumenti
Inizia a costruire oggi
Fleet SDK
TypeScript / JS
Costruisci transazioni nel tuo browser o Node.js. Miglior punto di partenza per i pagamenti degli agenti.
sigma-rust
Rust
Firma e serializzazione ad alte prestazioni. Ideale per infrastruttura di agenti in produzione.
Stato attuale
Stato dello stack
Cinque livelli sono attivi. Due sono problemi aperti. Unisciti alla conversazione su GitHub — questi sono i problemi irrisolti più interessanti nel denaro degli agenti.