Policy-Proved Attestations (PPA)

use blsful::{
    Bls12381G1Impl,
    MultiPublicKey, MultiSignature,
    ProofOfPossession, PublicKey, SecretKey, Signature, SignatureSchemes,
};

fn main() -> Result<(), String> {
    // Create operator keys
    let sk_a: SecretKey<Bls12381G1Impl> = SecretKey::from_hash(b"operator-A-seed");
    let sk_b: SecretKey<Bls12381G1Impl> = SecretKey::from_hash(b"operator-B-seed");

    let pk_a = sk_a.public_key();
    let pk_b = sk_b.public_key();

    // Message to sign
    let msg = b"gSkate";

    // Operators sign the message
    let sig_a = sk_a.sign(msg);
    let sig_b = sk_b.sign(msg);

    // Aggregate signatures
    let agg_sig = MultiSignature::aggregate(vec![sig_a, sig_b])?;

    // Create multi-public key for expected operator set
    let mpk_ab: MultiPublicKey<Bls12381G1Impl> =
        MultiPublicKey::from_public_keys(&[pk_a.clone(), pk_b.clone()]);

    // Verify aggregated signature
    match agg_sig.verify(mpk_ab, msg) {
        Ok(_) => println!("Policy check PASSED: 2-of-2 operators signed the message"),
        Err(e) => println!("Policy check FAILED: {}", e),
    }

    Ok(())
}

use cubist_policy_sdk::{error::Result, policy, AccessDecision, AccessRequest};
use blsful::{Bls12381G1Impl, MultiPublicKey, MultiSignature, PublicKey, SecretKey};
use serde::Deserialize;

const OPERATOR_A_SEED: &[u8] = b"operator-A-seed";
const OPERATOR_B_SEED: &[u8] = b"operator-B-seed";

#[derive(Deserialize)]
struct InvokeInput {
    #[serde(default)]
    msg_utf8: Option<String>,
    #[serde(default)]
    msg_hex: Option<String>,
    agg_sig_hex: String, // Aggregated BLS signature
}

#[policy]
async fn main(req: AccessRequest) -> Result<AccessDecision> {
    // Parse the request body
    let input = match parse_body(&req) {
        Ok(v) => v,
        Err(e) => return Ok(AccessDecision::Deny(format!("invalid input: {e}"))),
    };

    // Build expected operator set (A, B)
    let (pk_a, pk_b) = operator_public_keys();
    let mpk_ab: MultiPublicKey<Bls12381G1Impl> =
        MultiPublicKey::from_public_keys(&[pk_a.clone(), pk_b.clone()]);

    // Parse message
    let msg = match pick_message_bytes(&input) {
        Ok(m) => m,
        Err(e) => return Ok(AccessDecision::Deny(format!("message parse error: {e}"))),
    };

    // Parse aggregated signature
    let agg_sig_bytes = match parse_hex(&input.agg_sig_hex) {
        Ok(b) => b,
        Err(e) => return Ok(AccessDecision::Deny(format!("agg_sig_hex parse error: {e}"))),
    };
    let msig = match multi_sig_from_bytes(&agg_sig_bytes) {
        Ok(s) => s,
        Err(e) => return Ok(AccessDecision::Deny(format!("invalid aggregated signature: {e}"))),
    };

    // Verify 2-of-2 policy (both A and B must have signed)
    match msig.verify(mpk_ab, &msg) {
        Ok(_) => Ok(AccessDecision::Allow),
        Err(err) => Ok(AccessDecision::Deny(format!(
            "policy check failed: aggregated signature does not match operator set (A,B): {err:?}"
        ))),
    }
}

fn operator_public_keys() -> (PublicKey<Bls12381G1Impl>, PublicKey<Bls12381G1Impl>) {
    let sk_a: SecretKey<Bls12381G1Impl> = SecretKey::from_hash(OPERATOR_A_SEED);
    let sk_b: SecretKey<Bls12381G1Impl> = SecretKey::from_hash(OPERATOR_B_SEED);
    (sk_a.public_key(), sk_b.public_key())
}

fn parse_body(req: &AccessRequest) -> std::result::Result<InvokeInput, String> {
    let raw = match &req.request {
        Some(s) => s.as_str(),
        None => return Err("missing request body".into()),
    };
    serde_json::from_str::<InvokeInput>(raw).map_err(|e| format!("serde error: {e}"))
}

fn pick_message_bytes(input: &InvokeInput) -> std::result::Result<Vec<u8>, String> {
    if let Some(s) = &input.msg_utf8 {
        return Ok(s.as_bytes().to_vec());
    }
    if let Some(h) = &input.msg_hex {
        return parse_hex(h);
    }
    Err("provide either msg_utf8 or msg_hex".into())
}

fn parse_hex(s: &str) -> std::result::Result<Vec<u8>, String> {
    let s = s.strip_prefix("0x").unwrap_or(s);
    hex::decode(s).map_err(|e| format!("hex decode error: {e}"))
}