The Rise of Agent-to-Agent Contracts: From Handshake to Hash

import hashlib
import hmac
import secrets
import requests
import json
import os

class AutonomousSigningAgent:
    def __init__(self, agent_id: str, principal_name: str, api_key: str):
        self.agent_id = agent_id
        self.principal_name = principal_name
        self.api_key = api_key

    def generate_handshake_nonce(self) -> str:
        """Generate cryptographically secure 256-bit nonce."""
        return secrets.token_hex(32)

    def compute_document_hash(self, markdown_content: str) -> str:
        """Compute immutable SHA-256 hash of proposed contract terms."""
        return hashlib.sha256(markdown_content.encode("utf-8")).hexdigest()

    def execute_contract(
        self,
        title: str,
        contract_markdown: str,
        counterparty_name: str,
        counterparty_email: str
    ) -> dict:
        """Execute contract via Signbee single-endpoint REST primitive."""
        nonce = self.generate_handshake_nonce()
        doc_hash = self.compute_document_hash(contract_markdown)

        payload = {
            "title": title,
            "markdown": contract_markdown,
            "recipient_name": counterparty_name,
            "recipient_email": counterparty_email,
            "metadata": {
                "initiating_agent_id": self.agent_id,
                "principal": self.principal_name,
                "handshake_nonce": nonce,
                "proposed_terms_hash": doc_hash,
                "standard": "IEEE-P2048.1"
            }
        }

        response = requests.post(
            "https://signb.ee/api/v1/send",
            headers={
                "Authorization": f"Bearer {self.api_key}",
                "Content-Type": "application/json"
            },
            json=payload
        )

        if response.status_code != 200:
            raise RuntimeError(f"Signbee dispatch failed: {response.text}")

        return response.json()

# Simulation: Procurement Agent executes API capacity agreement
if __name__ == "__main__":
    agent = AutonomousSigningAgent(
        agent_id="agent_alpha_v4",
        principal_name="DeepCompute Corp",
        api_key=os.environ.get("SIGNBEE_API_KEY", "sb_live_...")
    )

    contract_markdown = """# Autonomous Compute Service Level Agreement
**Effective Date:** 2026-09-04  
**Parties:** DeepCompute Corp (Customer) & CloudGrid Ltd (Provider)

## 1. Scope of Work
Provider agrees to deliver 128x H100 GPU compute nodes with 99.99% availability.

## 2. Commercial Terms
* Price: $1.85 per node/hour
* Billing Cadence: Micro-settlement every 60 minutes
* Dispute Resolution: Cryptographic SHA-256 audit verification
"""

    result = agent.execute_contract(
        title="Automated GPU SLA 2026",
        contract_markdown=contract_markdown,
        counterparty_name="CloudGrid Procurement Agent",
        counterparty_email="agent@cloudgrid.network"
    )

    print(f"Contract Dispatched Successfully!")
    print(f"Document ID: {result.get('document_id')}")
    print(f"Signing URL: {result.get('signing_url')}")
    print(f"Audit Trail Status: {result.get('status')}")

import crypto from "crypto";
import fs from "fs";

interface AuditVerificationResult {
  verified: boolean;
  computedHash: string;
  expectedHash: string;
  admissibleUnderFRE902: boolean;
}

export function verifySignedDocumentHash(
  pdfFilePath: string,
  expectedHash: string
): AuditVerificationResult {
  const fileBuffer = fs.readFileSync(pdfFilePath);
  
  const computedHash = crypto
    .createHash("sha256")
    .update(fileBuffer)
    .digest("hex");

  const verified = crypto.timingSafeEqual(
    Buffer.from(computedHash, "utf8"),
    Buffer.from(expectedHash, "utf8")
  );

  return {
    verified,
    computedHash,
    expectedHash,
    admissibleUnderFRE902: verified
  };
}

// Example usage
const result = verifySignedDocumentHash(
  "./signed_contract.pdf",
  "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
);
console.log("Audit Evidence Status:", result);