adk-payments 0.5.0

Protocol-neutral agentic commerce and payment orchestration for ADK-Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use chrono::Utc;
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value, json};

use adk_core::Result;
use async_trait::async_trait;

use crate::protocol::ap2::error::Ap2Error;
use crate::protocol::ap2::types::{
    AuthorizationArtifact, CartMandate, IntentMandate, PaymentMandate,
};

/// Verification metadata captured after one authorization artifact passes policy.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct VerifiedAuthorization {
    pub artifact_kind: String,
    pub verified_at: chrono::DateTime<Utc>,
    #[serde(default, skip_serializing_if = "Map::is_empty")]
    pub claims: Map<String, Value>,
}

impl VerifiedAuthorization {
    fn new(artifact_kind: impl Into<String>, claims: Map<String, Value>) -> Self {
        Self { artifact_kind: artifact_kind.into(), verified_at: Utc::now(), claims }
    }
}

/// Verifies merchant authorization artifacts bound to `CartMandate`.
#[async_trait]
pub trait MerchantAuthorizationVerifier: Send + Sync {
    async fn verify_cart_authorization(
        &self,
        mandate: &CartMandate,
        artifact: &AuthorizationArtifact,
    ) -> Result<VerifiedAuthorization>;
}

/// Verifies user authorization artifacts bound to intent or payment mandates.
#[async_trait]
pub trait UserAuthorizationVerifier: Send + Sync {
    async fn verify_intent_authorization(
        &self,
        mandate: &IntentMandate,
        artifact: &AuthorizationArtifact,
    ) -> Result<VerifiedAuthorization>;

    async fn verify_payment_authorization(
        &self,
        mandate: &PaymentMandate,
        artifact: &AuthorizationArtifact,
    ) -> Result<VerifiedAuthorization>;
}

/// Minimal verifier that requires a non-empty merchant authorization artifact.
pub struct RequireMerchantAuthorization;

#[async_trait]
impl MerchantAuthorizationVerifier for RequireMerchantAuthorization {
    async fn verify_cart_authorization(
        &self,
        mandate: &CartMandate,
        artifact: &AuthorizationArtifact,
    ) -> Result<VerifiedAuthorization> {
        if artifact.value.trim().is_empty() {
            return Err(Ap2Error::MissingMerchantAuthorization {
                cart_id: mandate.contents.id.clone(),
            }
            .into());
        }

        let mut claims = Map::new();
        claims.insert("merchant_name".to_string(), json!(mandate.contents.merchant_name));
        claims.insert("artifact_type".to_string(), json!(artifact.artifact_type));
        claims.insert("content_type".to_string(), json!(artifact.content_type));
        Ok(VerifiedAuthorization::new("merchant_authorization", claims))
    }
}

/// Minimal verifier that requires non-empty detached or embedded user authorization.
pub struct RequireUserAuthorization;

#[async_trait]
impl UserAuthorizationVerifier for RequireUserAuthorization {
    async fn verify_intent_authorization(
        &self,
        mandate: &IntentMandate,
        artifact: &AuthorizationArtifact,
    ) -> Result<VerifiedAuthorization> {
        if artifact.value.trim().is_empty() {
            return Err(Ap2Error::MissingIntentAuthorization {
                transaction_id: mandate.natural_language_description.clone(),
            }
            .into());
        }

        let mut claims = Map::new();
        claims.insert(
            "user_cart_confirmation_required".to_string(),
            json!(mandate.user_cart_confirmation_required),
        );
        claims.insert("artifact_type".to_string(), json!(artifact.artifact_type));
        claims.insert("content_type".to_string(), json!(artifact.content_type));
        Ok(VerifiedAuthorization::new("intent_authorization", claims))
    }

    async fn verify_payment_authorization(
        &self,
        mandate: &PaymentMandate,
        artifact: &AuthorizationArtifact,
    ) -> Result<VerifiedAuthorization> {
        if artifact.value.trim().is_empty() {
            return Err(Ap2Error::MissingUserAuthorization {
                payment_mandate_id: mandate.payment_mandate_contents.payment_mandate_id.clone(),
            }
            .into());
        }

        let mut claims = Map::new();
        claims.insert(
            "payment_mandate_id".to_string(),
            json!(mandate.payment_mandate_contents.payment_mandate_id),
        );
        claims.insert("artifact_type".to_string(), json!(artifact.artifact_type));
        claims.insert("content_type".to_string(), json!(artifact.content_type));
        Ok(VerifiedAuthorization::new("user_authorization", claims))
    }
}