La couche d'autorisation pré-transaction vérifiable pour le capital autonome
Vous avez déjà un agent de trading ? Ajoutez Profit Engine Governor. Gardez la garde. Gardez le contrôle.
PE Governor évalue chaque intention d'ordre soumise selon vos règles, coordonne la capacité du portefeuille entre agents et renvoie une autorisation signée de courte durée pour le montant exact autorisé. Votre exécuteur la vérifie ; PE Governor ne prend jamais la garde des fonds et ne passe jamais l'ordre.
Autorisez du capital neuf, plafonné au montant exact autorisé.
Verdict 02REDUCE
Réduisez une position gérée existante. Ne dépassez jamais le montant renvoyé.
Verdict 03REJECT
Une règle stricte a échoué. N'agissez plus sur ce candidat.
Verdict 04HOLD
Blocage temporaire ou non retenu ce cycle. Suspendez et redemandez.
01Une décision déterministe, rendue en direct
Une décision déterministe, rendue en direct
Cette carte est produite par la politique pure qu'exécute l'endpoint payant, à partir de l'exemple de requête ci-dessous. Une entrée identique donne toujours un hash de décision identique.
Vos agents émettent jusqu'à 50 candidats sur un bus commun : couloir, actif, sens, notionnel demandé, perte maximale et gain net attendu fournis par l'appelant, statut de preuve et expiration.
Phase 02
2. Gouverner
PE Governor applique une seule politique pure : fraîcheur de l'état, réconciliation, coupe-circuit, preuves, budgets de perte, réserve, plafonds notionnels et concurrence — puis classe et retient au plus un gagnant.
Phase 03
3. Obéir
Le capital bouge selon vos règles. Même requête en entrée, décision identique au bit près en sortie, avec les hashs SHA-256 de la requête et de la décision canoniques pour l'audit.
02Un contrôle fondamental pour le capital autonome
Un contrôle fondamental pour le capital autonome
Une couche d’autorisation déterministe qui rend les décisions des agents bornées, auditables et portables dans toute votre pile d’exécution.
Reçus de politique inviolables
Chaque réponse lie la requête canonique et la décision par des hachages SHA-256, la version de la politique, l’horodatage, le montant autorisé exact et les contrôles valeur observée / limite. Les rejeux restent identiques octet pour octet.
Gouvernance à l’échelle du portefeuille
Évaluez jusqu’à 50 candidats issus de plusieurs stratégies face à un instantané de portefeuille unique, récent et réconcilié. Les règles de perte, drawdown, réserve, nominal, concurrence et coupe-circuit s’appliquent avant qu’au plus un gagnant soit retenu.
Paiement nativement machine
Payez le prix publié par décision, par bandes de risque en USDC sur Base via le flux de checkout Coinbase Business, ou utilisez des crédits prépayés. L’idempotence empêche les achats logiques en double.
L’application commence dans votre adaptateur d’exécution
PE Governor renvoie l’autorisation ; votre adaptateur la vérifie et s’y conforme avant de passer un ordre. Coinbase n’applique pas aujourd’hui les décisions PE au niveau de la place de marché, et le paiement ne modifie jamais le verdict.
03Des autorisations signées que votre exécuteur peut vérifier
Des autorisations signées que votre exécuteur peut vérifier
Chaque allocation gouvernée porte une autorisation éphémère, signée cryptographiquement et liée à son intention exacte et au dernier état de risque soumis du portefeuille.
Preuves de politique vérifiables
La signature couvre la charge canonique de la preuve : émetteur, identifiant de clé, verdict, montant exact autorisé, candidat, stratégie, couloir, portée complète, empreinte de la requête, empreinte de la décision, empreinte de l'état du portefeuille, le devis durable et l'expiration. Récupérez la clé publique une fois et vérifiez hors ligne.
Réservations atomiques entre agents
Les agents concurrents d'un même locataire et portefeuille se disputent un unique registre de risque agrégé. Un candidat gagnant ne devient exécutable que si la réservation est accordée ; sinon le verdict est ramené à HOLD.
Tarification par bandes de risque
Le prix d'une décision évolue avec le capital à risque : le plus grand notionnel demandé ou perte maximale de la requête. Le devis est déterministe et lié à l'empreinte. Le paiement achète l'évaluation, jamais un verdict.
Prix déterministe par décision
Le capital à risque vaut max(requestedNotionalUsd, maximumLossUsd) sur les candidats soumis. Une unité de crédit équivaut à 0,05 USDC.
Prix déterministe par décision
Capital à risque
Prix (USDC sur Base)
Unités de crédit
jusqu'à 1 000 $
0.05 USDC
1
jusqu'à 10 000 $
0.10 USDC
2
jusqu'à 100 000 $
1.00 USDC
20
jusqu'à 500 000 $
5.00 USDC
100
au-delà de 500 000 $
10.00 USDC
200
Le même prix s'applique à ALLOCATE, REDUCE, REJECT et HOLD. Il n'y a pas d'abonnement.
Vérifiez avant d'exécuter
Votre adaptateur d'exécution doit vérifier l'empreinte de la charge, la signature, l'émetteur et l'identifiant de clé, la fenêtre de validité, le jeton de réservation actif, toutes les empreintes attendues, ainsi que la correspondance exacte de l'ordre avec l'intention et le montant autorisés. Consommez chaque autorisation une seule fois dans un magasin durable et refusez tout ordre non couvert par une autorisation active.
verify-authorization.ts
import { verifyAuthorizationForOrder } from "./pe-authorization";
// 1. Fetch and cache the published Ed25519 verification key (kid + issuer).
const { issuer, keys } = await (await fetch("/api/pe/v1/keys")).json();
// 2. Gate every order on a live, exactly matching authorization.
const check = await verifyAuthorizationForOrder({
proof: decision.proof, // returned with every 200
publicKeyBase64Url: keys[0].x,
order: {
candidateId, strategyId, assetId, lane, side, reduceOnly,
amountUsd: decision.allocationAmountUsd, // must equal permittedAmountUsd exactly
tenantId, portfolioId, agentId, ownerId, accountScope,
},
expected: {
issuer,
keyId: keys[0].kid,
policyVersion: decision.policyVersion,
requestHash: decision.audit.requestHash,
decisionHash: decision.audit.decisionHash,
portfolioStateHash: decision.proof.payload.portfolioStateHash,
quoteHash: decision.priceQuote.quoteHash,
reservationFencingToken: decision.proof.payload.reservation.fencingToken,
},
// Durable single-use store: ONE atomic operation, never has() then add().
replayStore: {
consumeIfUnused: async (id) => {
const { rowCount } = await db.query(
"INSERT INTO used_authorizations (id) VALUES ($1) ON CONFLICT DO NOTHING",
[id],
);
return rowCount === 1; // false => already consumed
},
},
});
if (!check.valid) throw new Error(check.reason); // never place the order
placeOrder(decision.allocationAmountUsd);
Clés de vérification04Réservez la capacité du portefeuille pendant toute la fenêtre d'exécution
Réservez la capacité du portefeuille pendant toute la fenêtre d'exécution
Facultatif
Vérifier une autorisation signée hors ligne reste suffisant en soi. Si vous voulez aller plus loin, réclamez-la : PE Governor retient alors la part de capacité agrégée de cette autorisation jusqu'à ce que votre adaptateur rende compte du résultat, afin qu'un second agent ne puisse pas consommer deux fois la même marge.
AUTHORIZED
Émise avec la décision et retenant déjà de la capacité pendant sa courte fenêtre de validité.
CLAIMED
Votre adaptateur a lié une clé de réclamation secrète et assume désormais le résultat. Aucun autre appelant ne peut la faire évoluer.
COMMITTED
L'adaptateur a agi. La capacité reste retenue, car le capital engagé travaille jusqu'à la réconciliation.
RELEASED
L'adaptateur a renoncé sans agir. La capacité est restituée immédiatement.
EXPIRED
Personne n'a rendu compte à temps. La capacité est restituée d'elle-même, sans appel de nettoyage.
authorization-lifecycle.ts
// Optional. Offline verification of the proof is still sufficient.
const { authorizationId } = decision.lifecycle;
const claimKey = crypto.randomUUID() + crypto.randomUUID(); // >= 32 chars, keep it
const claim = await fetch(`/api/pe/v1/authorizations/${authorizationId}/claim`, {
method: "POST",
headers: { "x-pe-claim-key": claimKey },
});
if (!claim.ok) return; // someone else owns this authorization
try {
await placeOrderWithYourOwnExecutor(intent); // PE Governor never does this
await fetch(`/api/pe/v1/authorizations/${authorizationId}/commit`, {
method: "POST",
headers: { "x-pe-claim-key": claimKey },
});
} catch {
// stand down and give the capacity straight back
await fetch(`/api/pe/v1/authorizations/${authorizationId}/release`, {
method: "POST",
headers: { "x-pe-claim-key": claimKey },
});
}
L'état du cycle de vie est la tenue de registre de votre propre politique. Confirmer enregistre que votre adaptateur a agi ; PE Governor ne place, n'achemine ni ne règle toujours aucun ordre.
05Installez la politique une fois
Installez la politique une fois
Branchez l'appel avant toute allocation supérieure ou égale au seuil propriétaire. Arrêtez-vous sur REJECT ou HOLD, et ne dépassez jamais un montant REDUCE.
install-policy.txt
# Install once, obey always.
BEFORE any allocation >= OWNER_THRESHOLD_USD:
decision = POST /api/pe/v1/governor # same-origin; production clients resolve it against https://governor.solarly.ai
if decision.decision in ("REJECT", "HOLD"):
stop() # no order, no retry loop
if decision.decision == "REDUCE":
size = min(intended_size, decision.allocationAmountUsd)
if decision.decision == "ALLOCATE":
size = decision.allocationAmountUsd # never more
execute(size) # execution is 100% yours
Payez à la décision en USDC sur Base via un checkout Coinbase Business, ou consommez des crédits prépayés. Aucun abonnement. L'autorisation n'est pas le règlement : seul un checkout COMPLETED libère la décision.
Step 01
POST + clé d'idempotence
Une requête logique est réservée de façon atomique.
Step 02
402 avec URL x402
Exactement un checkout Coinbase est créé.
Step 03
202 pendant le traitement
Réessayez avec la même clé et le même id de checkout.
Step 04
COMPLETED
Le sondage confirme un checkout COMPLETED. La confirmation par webhook signé est disponible lorsqu'elle est configurée.
Step 05
Décision 200
Stockée une fois ; les rejeux sont identiques au bit près.
La machine à états des codes HTTP
POST /api/pe/v1/governor (X-Idempotency-Key: uuid-v4)
|
v
402 Payment Required --payment.x402Url--> client pays the checkout
| |
|<---- retry: same key + X-Checkout-Id ------+
v
202 Accepted checkout ACTIVE / PROCESSING --> back off, retry
|
v
checkout COMPLETED (polling; signed webhook when configured)
|
v
200 OK pe-governor-decision.v1, stored once, replays byte-identical
Boucle de relance côté client
Une intégration minimale. Envoyez une clé d'idempotence UUID v4, lisez l'URL x402 et l'identifiant de checkout dans le corps du 402, payez-le, puis interrogez avec la même clé et le même identifiant jusqu'à la libération de la décision.
retry-loop.ts
import { randomUUID } from "node:crypto";
const ENDPOINT = "/api/pe/v1/governor"; // same-origin; resolves against https://governor.solarly.ai
const idempotencyKey = randomUUID(); // UUID v4, one per logical decision
// 1. First call: body + idempotency key. No payment yet, so expect 402.
let res = await fetch(ENDPOINT, {
method: "POST",
headers: { "content-type": "application/json", "x-idempotency-key": idempotencyKey },
body: JSON.stringify(governorRequest),
});
if (res.status !== 402) throw new Error(`unexpected status ${res.status}`);
// 2. Read the x402 URL and checkout id straight off the 402 body.
const { payment } = await res.json();
const x402Url: string = payment.x402Url; // where the client pays
const checkoutId: string = payment.checkoutId; // echo this back on every retry
// 3. Pay with your x402 client. The authorization response is NOT settlement:
// only a COMPLETED checkout releases the decision.
await x402Client.pay(x402Url, { amount: payment.amount, asset: payment.currency });
// 4. Poll the same request with the same key + checkout id, backing off.
for (let attempt = 0; attempt < 12; attempt++) {
res = await fetch(ENDPOINT, {
method: "POST",
headers: { "x-idempotency-key": idempotencyKey, "x-checkout-id": checkoutId },
}); // body may be omitted on retries
if (res.status === 200) {
const decision = await res.json(); // pe-governor-decision.v1
console.log(decision.decision, decision.allocationAmountUsd, decision.audit.decisionHash);
break;
}
if (res.status !== 202) throw new Error(await res.text()); // 402/409 are terminal
await new Promise((r) => setTimeout(r, Math.min(500 * 2 ** attempt, 8000)));
}
05. Aucune prévision de rendement propre ni revendication d'alpha propriétaire
06. Le gain attendu et la perte maximale sont toujours fournis par l'appelant
07. Aucune application native sur la place de marché n'est revendiquée ; votre adaptateur applique chaque autorisation
08. Une autorisation signée prouve quelle décision de politique a été émise. Ce n'est ni un certificat de conformité, ni une décision de souscription, ni une attestation on-chain, ni une approbation de la place de marché.