Stack de Pagos de Agentes: Arquitectura de Referencia
Cuatro primitivas on-chain. Tres flujos componibles. Todo lo que necesitas para construir pagos agente-a-agente en Ergo — desde una sola llamada API hasta una moneda comunitaria completa.
Las Cuatro Primitivas
Reserve · Note · Tracker · Predicate
Reserve
Respaldo de capital
Un contrato on-chain que mantiene ERG o tokens como colateral. Cualquiera puede verificar la ratio de reserva en cualquier momento. El Reserve es el banco — sin intermediarios.
- Mantiene ERG / tokens nativos
- Auditable en cualquier momento
- Respalda la emisión de Note 1:1 o fraccionalmente
- Redención ejecutada por 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
Pagaré programable
Un token al portador que representa un derecho contra un Reserve. Los Note pueden transferirse, dividirse y redimirse. El Predicate de aceptación define quién puede recibir o redimir el Note.
- Instrumento al portador — sin identidad requerida
- Transferible entre pares
- Redimible contra el contrato de Reserve
- Denominación en cualquier 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
Contabilidad on-chain
Rastrea saldos acumulados, uso de crédito e historial de redención en todos los Note emitidos desde un Reserve. Piénsalo como un libro mayor público que cualquiera puede verificar.
- Rastrea total emitido vs redimido
- Aplica límites de crédito
- Auditable públicamente
- Componible con otros 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
Regla de confianza programable
La condición bajo la cual un agente aceptará un Note como pago. Las condiciones pueden incluir verificación de hash de tarea, comprobaciones de fecha límite, pruebas de credenciales o cualquier dato on-chain.
- Condiciones de aceptación arbitrarias
- Verificación de hash de tarea
- Aplicación de fecha límite
- Componible con pruebas 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)
}Flujos de Ejemplo
Tres flujos componibles
Flujo A: Agente compra llamada API
Una llamada. Una prueba. Sin cuenta persistente.
- 1
Agente crea Note
0.001 ERG valor nominal, dirección del proveedor en R4
- 2
Proveedor verifica Predicate
Verifica valor del Note, respaldo del Reserve, fecha límite
- 3
Proveedor entrega respuesta
Devuelve resultado API, marca Note como gastado
- 4
Liquidación
Note quemado, ERG liberado del Reserve al proveedor
// 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()Flujo B: Agente paga a crédito
Reserve desplegado. Note emitidos. Tracker monitorea.
- 1
Desplegar Reserve
Bloquear ERG en contrato de Reserve con límite de crédito
- 2
Emitir Note
Crear Note contra Reserve hasta el límite de crédito
- 3
Agente gasta Note
Note transferidos a proveedores, Tracker actualizado
- 4
Auto-liquidación
Al alcanzar el umbral, Reserve liquida Note pendientes
// 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
})Flujo C: Reserve comunitario + Tracker
Un mercado local, una cooperativa de cómputo, una red de agentes.
- 1
Comunidad despliega Reserve
ERG agrupado por miembros de la comunidad
- 2
Emitir Note comunitarios
Miembros reciben Note proporcionales a su contribución
- 3
Comercio local
Note aceptados dentro de la comunidad, Predicate definen reglas
- 4
Redención
Miembros redimen Note por ERG del Reserve en cualquier 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 y Herramientas
Empieza a construir hoy
Fleet SDK
TypeScript / JS
Construye transacciones en tu navegador o Node.js. Mejor punto de partida para pagos de agentes.
sigma-rust
Rust
Firma y serialización de alto rendimiento. Ideal para infraestructura de agentes en producción.
Estado actual
Estado del stack
Cinco capas están activas. Dos son problemas abiertos. Únete a la conversación en GitHub — estos son los problemas no resueltos más interesantes en dinero de agentes.