Struct Gateway 

pub struct Gateway { /* private fields */ }

A2A Gateway with reputation-based access control

Implementations

impl Gateway

pub fn new() -> Self

Create a new gateway

pub fn with_rate_limit(max_requests_per_minute: u32) -> Self

Create gateway with custom rate limit

pub fn check_permission( &self, user_pubkey: &str, action: &SwarmAction, ) -> Result<PermissionCheck, GatewayError>

Check if an agent has permission to execute an action

This is the critical security function that enforces reputation-based access control for the 22-Layer Stack.

Security Model

┌─────────────────────────────────────────────────────────────────┐
│                    PERMISSION CHECK FLOW                        │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  Request → Rate Limit Check → Session Verify → Reputation Check │
│                                                                 │
│  Layer 1-16:  score >= 0     → ALLOW                           │
│  Layer 17-21: score >= 300   → ALLOW (Collateral Threshold)    │
│  Layer 22:    score >= 500   → ALLOW (Swarm Coordinator)       │
│                                                                 │
│  Below threshold → 403 FORBIDDEN                               │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

pub fn enforce_permission( &self, user_pubkey: &str, action: &SwarmAction, ) -> Result<(), GatewayError>

Enforce permission check - returns Ok(()) if allowed, Err(Forbidden) if not

USE THIS for actual enforcement in request handlers.

pub fn enforce_swarm_permission( &self, user_pubkey: &str, ) -> Result<(), GatewayError>

Specific check for Layer 22 Swarm Coordination

Returns 403 Forbidden if threshold_proofs[“swarm_coordinator”] is false.

pub fn check_rate_limit(&self, agent_pubkey: &str) -> Result<(), GatewayError>

Check rate limit for an agent

pub fn process_request( &self, request: &A2ARequest, ) -> Result<PermissionCheck, GatewayError>

Process a full A2A request with all security checks

pub fn get_reputation( &self, user_pubkey: &str, ) -> Result<TrustScore, GatewayError>

Get reputation engine for a user (creates if not exists)

pub fn record_attestation( &self, user_pubkey: &str, attestation: &AttestationRecord, ) -> Result<TrustScore, GatewayError>

Update reputation with attestation (used after successful actions)

pub fn hire_sub_agent( &self, user_pubkey: &str, sub_agent_pubkey: &str, task_id: &str, budget: u64, ) -> Result<HireResult, GatewayError>

Hire a sub-agent for a specific task

Security Rules:

1. User must have sufficient reputation (Layer 20 for hire, Layer 22 for swarm)
2. User cannot exceed their tier’s max_sub_agents limit
3. A 1% management fee is captured and deposited to user’s vault

Fee Capture Flow:

User Budget: 1000 CRED
Fee (1%):       10 CRED → User's Vault
Net to Agent:  990 CRED → Sub-Agent

pub fn coordinate_swarm( &self, user_pubkey: &str, task_id: &str, sub_agents: &[String], budget_per_agent: u64, ) -> Result<SwarmCoordinationResult, GatewayError>

Coordinate multiple sub-agents for a complex task (Layer 22)

This is the highest-tier operation requiring Elite-level reputation. Orchestrates multiple sub-agents for parallel task execution.

pub fn release_sub_agent( &self, user_pubkey: &str, sub_agent_pubkey: &str, ) -> Result<bool, GatewayError>

Release a sub-agent (end contract)

pub fn get_sub_agent_status( &self, user_pubkey: &str, ) -> Result<(Vec<String>, u64, u8), GatewayError>

Get sub-agent status for a user

pub fn register_referral( &self, referrer_agent: &str, referred_user: &str, ) -> Result<(), GatewayError>

Register a new referral when a user joins via agent invite code

Called when: User redeems an invite code issued by an agent

pub fn process_referral_bounty( &self, referred_user: &str, verified_credential_tier: u8, ) -> Result<ReferralBountyResult, GatewayError>

Process a referral bounty when a referred user verifies a Tier 1+ credential

Bounty Rules:

1. The referred user must have been invited by an agent (registered referral)
2. The referred user must verify a Tier 1 or higher credential
3. The bounty is 10% of the referrer agent’s current base reputation score
4. Each referral can only be paid once

Returns:

ReferralBountyResult with the boost amount and new score

pub fn get_agent_referral_stats( &self, agent_pubkey: &str, ) -> Result<(Vec<ReferralRecord>, u32), GatewayError>

Get referral statistics for an agent

Trait Implementations

impl Default for Gateway

fn default() -> Self

Returns the “default value” for a type.