Proof of Intents (PoI)

In the Agentic Economy, disparate AI agents must execute complex workflows that span multiple blockchains, off-chain systems, and decentralized services.

A Proof of Intent (PoI) is Backpac's cryptographic system for linking these separate execution steps together into a unified, traceable, and secure settlement flow.

What is a Proof of Intent?

When an agent needs to perform an on-chain action, it first creates a PoI. This PoI acts as an overarching container or "session" for the entire workflow.

Rather than sending isolated RPC payload requests directly to the network, the agent attaches the PoI ID to its Execution Intents.

Key Benefits

1. Cryptographic Identity Binding: A PoI is signed using an agent's decentralized identity (e.g., Ed25519 DID), anchoring everything done under that PoI to a specific, authenticated actor.
2. Intent Chaining: An agent can link multiple transactions (or off-chain steps) back to one parent PoI, or even establish Parent-Child PoI relationships.
3. Auditability: Validators, receivers, and external systems can independently verify the status and cryptographic Proof of Transport (PoT) for everything associated with a PoI.

The PoI Lifecycle

1. Creation

An agent uses their Backpac account to mint a new PoI. This generates a unique identifier and records the intent's initiation parameters (e.g., maximum depth, time-to-live).

Schema (ProofOfIntent)

interface ProofOfIntent {
  po_intent_id: string;         // Unique identifier (e.g., 'poi_123')
  status: 'ACTIVE' | 'EXPIRED' | 'COMPLETED'; // Lifecycle status
  agent_did: string;            // Decentralized Identity of the creating agent
  expires_at: string;           // ISO 8601 timestamp defining the intent TTL
}

Example JSON Response:

{
  "po_intent_id": "poi_3192bd89z",
  "status": "ACTIVE",
  "agent_did": "did:key:z6MkAGENT",
  "expires_at": "2026-06-01T12:00:00Z"
}

2. Execution Intent Binding

When the agent dispatches an Execution Intent (the actual blockchain transaction, such as eth_sendRawTransaction), it passes the PoI ID via the x-backpac-poi-id header.

Backpac then associates the transaction's result exclusively with this PoI.

3. Settlement and Proof of Transport

Once the bound Execution Intent is finalized on-chain (reaching the desired confirmation depth), Backpac generates a Proof of Transport (PoT).

The PoT is not just a receipt; it is a full cryptographic bundle verifiable client-side.

Schema (ProofOfTransport)

interface ProofOfTransport {
  po_intent_id: string;         // The overarching parent Proof of Intent
  execution_intent_id: string;  // The specific on-chain transaction execution ID
  status: 'FINALIZED' | 'SAFE'; // The cryptographic settlement status reached
  payload_hash: string;         // SHA-256 hash of the submitted transaction payload
  signature: string;            // Ed25519 signature of the payload hash by Backpac
  version: string;              // Key version identifier matching public 'kid' in JWKS
}

Example JSON Response:

{
  "po_intent_id": "poi_3192bd89z",
  "execution_intent_id": "ei_99182",
  "status": "FINALIZED",
  "payload_hash": "e3b0...2711",
  "signature": "Ed25519_JWKS_SIGNATURE_HERE",
  "version": "v1:2026-02-14.genesis"
}

Verifying Proof of Transport (PoT)

Because PoT bundles use standard JSON Web Key Sets (JWKS), the receiving party—who might be another autonomous agent entirely—can trustlessly verify that Backpac executed and settled the workflow.

1. Fetch the bundle: GET /v1/proofs/:intent_id
2. Fetch Backpac's Keys: GET /.well-known/jwks.json
3. Verify Locally: Perform an Ed25519 signature validation on the payload hash using the public key matching the version header.

Typescript / Node.js

import { verify } from '@noble/ed25519';

async function verifyProofOfTransport(intentId: string) {
  // 1. Fetch Proof Bundle
  const proofRes = await fetch(`https://api.backpac.xyz/v1/proofs/${intentId}`);
  const { payload_hash, signature, version } = await proofRes.json();

  // 2. Fetch JWKS Public Key
  const jwksRes = await fetch('https://api.backpac.xyz/.well-known/jwks.json');
  const { keys } = await jwksRes.json();
  const publicKey = keys.find(k => k.kid === version).x;

  // 3. Cryptographic Verification
  const isValid = await verify(
    signature,
    payload_hash,
    Buffer.from(publicKey, 'base64').toString('hex')
  );

  if (!isValid) throw new Error("Invalid Settlement Proof");
  console.log("✅ Proof of Transport cryptographically verified.");
}

Python

import requests
from nacl.signing import VerifyKey
import base64

def verify_proof_of_transport(intent_id):
    # 1. Fetch Proof Bundle
    proof = requests.get(f"https://api.backpac.xyz/v1/proofs/{intent_id}").json()
    
    # 2. Fetch JWKS
    jwks = requests.get("https://api.backpac.xyz/.well-known/jwks.json").json()
    pub_key_b64 = next(k['x'] for k in jwks['keys'] if k['kid'] == proof['version'])
    
    # 3. Cryptographic Verification
    verify_key = VerifyKey(base64.urlsafe_b64decode(pub_key_b64 + '=='))
    try:
        verify_key.verify(
            bytes.fromhex(proof['payload_hash']),
            bytes.fromhex(proof['signature'])
        )
        print("✅ Proof of Transport cryptographically verified.")
        return True
    except Exception as e:
        raise ValueError("Invalid Settlement Proof") from e

By establishing absolute proof of settlement that any third party can verify without querying a node, PoI unblocks multi-agent, cross-domain economic workflows.