Requisition Fulfillment Service

import grpc
from wfa.measurement.system.v1alpha import requisitions_service_pb2
from wfa.measurement.system.v1alpha import requisitions_service_pb2_grpc

def fulfill_requisition(
    stub,
    requisition_name: str,
    nonce: int,
    build_label: str,
    warnings: list[str] = None
):
    """
    Mark a requisition as fulfilled after uploading encrypted sketch.
    
    Args:
        stub: Requisitions service gRPC stub
        requisition_name: Full resource name of requisition
        nonce: Decrypted nonce from requisition spec
        build_label: Version identifier of sketch generator
        warnings: Optional list of warning messages
    
    Returns:
        Updated Requisition message with FULFILLED state
    """
    # Build fulfillment context
    fulfillment_context = requisitions_service_pb2.Requisition.FulfillmentContext(
        build_label=build_label
    )
    if warnings:
        fulfillment_context.warnings.extend(warnings)
    
    # Create request
    request = requisitions_service_pb2.FulfillRequisitionRequest(
        name=requisition_name,
        nonce=nonce,
        fulfillment_context=fulfillment_context
    )
    
    # Call service
    try:
        requisition = stub.FulfillRequisition(request)
        print(f"Requisition fulfilled: {requisition.name}")
        print(f"State: {requisition.state}")
        return requisition
    except grpc.RpcError as e:
        print(f"Error fulfilling requisition: {e.code()} - {e.details()}")
        raise

# Usage
with grpc.secure_channel('kingdom.example.com:443', credentials) as channel:
    stub = requisitions_service_pb2_grpc.RequisitionsStub(channel)
    
    requisition = fulfill_requisition(
        stub,
        requisition_name="computations/abc123/requisitions/req456",
        nonce=0x1234567890ABCDEF,  # Decrypted from requisition spec
        build_label="edp-simulator-v2.1.0",
        warnings=[
            "10 events excluded due to invalid timestamps",
            "Data coverage: 99.5%"
        ]
    )

import hashlib
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes

class RequisitionFulfiller:
    def __init__(self, private_key_pem, blob_storage_client):
        self.private_key = serialization.load_pem_private_key(
            private_key_pem.encode(),
            password=None
        )
        self.storage = blob_storage_client
    
    def process_requisition(self, requisition, encrypted_spec):
        """
        Complete workflow: decrypt spec, generate sketch, fulfill requisition.
        """
        # 1. Decrypt requisition specification
        spec = self._decrypt_requisition_spec(encrypted_spec)
        nonce = spec.nonce
        
        # 2. Verify nonce hash
        computed_hash = hashlib.sha256(nonce.to_bytes(8, 'big')).digest()
        if computed_hash != requisition.nonce_hash:
            raise ValueError("Nonce hash mismatch")
        
        # 3. Generate sketch from event data
        events = self._query_events(spec.event_groups, spec.filters)
        sketch = self._generate_sketch(events, spec.sketch_params)
        
        # 4. Encrypt sketch with duchy keys
        encrypted_sketch = self._encrypt_sketch(sketch, spec.duchy_public_keys)
        
        # 5. Upload sketch to blob storage
        sketch_uri = self.storage.upload(
            data=encrypted_sketch,
            path=f"requisitions/{requisition.name}/sketch"
        )
        
        # 6. Fulfill requisition
        return self._fulfill_requisition(
            requisition_name=requisition.name,
            nonce=nonce,
            build_label="my-edp-v1.0.0"
        )
    
    def _decrypt_requisition_spec(self, encrypted_spec):
        """Decrypt requisition spec using data provider's private key."""
        decrypted = self.private_key.decrypt(
            encrypted_spec,
            padding.OAEP(
                mgf=padding.MGF1(algorithm=hashes.SHA256()),
                algorithm=hashes.SHA256(),
                label=None
            )
        )
        # Parse protobuf
        from wfa.measurement.api.v2alpha import requisition_spec_pb2
        spec = requisition_spec_pb2.RequisitionSpec()
        spec.ParseFromString(decrypted)
        return spec
    
    def _generate_sketch(self, events, sketch_params):
        """Generate Liquid Legions sketch from events."""
        # Implementation specific to sketch protocol
        pass
    
    def _encrypt_sketch(self, sketch, duchy_keys):
        """Layer encrypt sketch for duchy processing."""
        # Implementation specific to encryption protocol
        pass