Agent-Zahlungs-Stack: Referenzarchitektur
Vier On-Chain-Primitive. Drei kombinierbare Abläufe. Alles, was Sie brauchen, um Agent-zu-Agent-Zahlungen auf Ergo aufzubauen — von einem einzigen API-Aufruf bis zu einer vollständigen Community-Währung.
Die vier Primitive
Reserve · Note · Tracker · Predicate
Reserve
Kapitaldeckung
Ein On-Chain-Vertrag, der ERG oder Token als Sicherheit hält. Jeder kann das Reserve-Verhältnis jederzeit überprüfen. Die Reserve ist die Bank — kein Mittelsmann.
- Hält ERG / native Token
- Jederzeit überprüfbar
- Deckt Note-Ausgabe 1:1 oder anteilig
- Einlösung durch Vertrag erzwungen
{
// 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
Programmierbarer Schuldschein
Ein Inhabertoken, der einen Anspruch gegen eine Reserve darstellt. Notes können übertragen, geteilt und eingelöst werden. Das Akzeptanz-Predicate definiert, wer die Note empfangen oder einlösen kann.
- Inhaberinstrument — keine Identität erforderlich
- Peer-to-Peer übertragbar
- Einlösbar gegen Reserve-Vertrag
- Denomination in beliebigem 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
On-Chain-Buchhaltung
Verfolgt kumulative Salden, Kreditnutzung und Einlösungshistorie über alle von einer Reserve ausgegebenen Notes. Denken Sie daran als öffentliches Hauptbuch, das jeder verifizieren kann.
- Verfolgt Gesamtausgabe vs. eingelöst
- Setzt Kreditlimits durch
- Öffentlich überprüfbar
- Kombinierbar mit anderen Verträgen
{
// 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
Programmierbare Vertrauensregel
Die Bedingung, unter der ein Agent eine Note als Zahlung akzeptiert. Bedingungen können Task-Hash-Verifizierung, Fristprüfungen, Nachweisbelege oder beliebige On-Chain-Daten umfassen.
- Beliebige Akzeptanzbedingungen
- Task-Hash-Verifizierung
- Fristdurchsetzung
- Kombinierbar mit Sigma-Beweisen
{
// 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)
}Beispielabläufe
Drei kombinierbare Abläufe
Ablauf A: Agent kauft API-Aufruf
Ein Aufruf. Ein Beweis. Kein dauerhaftes Konto.
- 1
Agent erstellt Note
0,001 ERG Nennwert, Anbieteradresse in R4
- 2
Anbieter prüft Predicate
Verifiziert Note-Wert, Reserve-Deckung, Frist
- 3
Anbieter liefert Antwort
Gibt API-Ergebnis zurück, markiert Note als ausgegeben
- 4
Abrechnung
Note verbrannt, ERG von Reserve an Anbieter freigegeben
// 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()Ablauf B: Agent zahlt auf Kredit
Reserve bereitgestellt. Notes ausgegeben. Tracker überwacht.
- 1
Reserve bereitstellen
ERG im Reserve-Vertrag mit Kreditlimit sperren
- 2
Notes ausgeben
Notes gegen Reserve bis zum Kreditlimit erstellen
- 3
Agent gibt Notes aus
Notes an Anbieter übertragen, Tracker aktualisiert
- 4
Auto-Abrechnung
Bei Erreichen des Schwellenwerts rechnet Reserve ausstehende Notes ab
// 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
})Ablauf C: Community-Reserve + Tracker
Ein lokaler Marktplatz, eine Rechen-Kooperative, ein Agent-Netzwerk.
- 1
Community stellt Reserve bereit
ERG von Community-Mitgliedern gepoolt
- 2
Community-Notes ausgeben
Mitglieder erhalten Notes proportional zum Beitrag
- 3
Lokaler Handel
Notes innerhalb der Community akzeptiert, Predicates definieren Regeln
- 4
Einlösung
Mitglieder lösen Notes jederzeit gegen ERG aus der Reserve ein
// 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 & Tools
Fangen Sie heute an zu bauen
Fleet SDK
TypeScript / JS
Erstellen Sie Transaktionen in Ihrem Browser oder Node.js. Bester Einstiegspunkt für Agent-Zahlungen.
sigma-rust
Rust
Hochleistungs-Signierung und Serialisierung. Ideal für Agent-Produktionsinfrastruktur.
Aktueller Stand
Stack-Status
Fünf Schichten sind live. Zwei sind offene Probleme. Nehmen Sie an der Diskussion auf GitHub teil — dies sind die interessantesten ungelösten Probleme im Bereich Agent-Geld.