struct AccessPolicy {
    address sender;      // Creator of the policy
    address recipient;   // Authorized accessor
    uint64 expiry;       // Expiration timestamp
    uint32 maxAttempts;  // Maximum access attempts
    uint32 attempts;     // Current attempt count
    bool valid;          // Policy validity flag
}

mapping(bytes32 => AccessPolicy) public policies;

function createPolicy(
    bytes32 policyId,
    address recipient,
    uint256 expiry,
    uint256 maxAttempts
) external

const policyId = keccak256(toUtf8Bytes(uniqueString));
const recipient = '0x742d...';
const expiry = Math.floor(Date.now() / 1000) + 86400; // 24 hours
const maxAttempts = 3;

await contract.createPolicy(policyId, recipient, expiry, maxAttempts);

function logAttempt(bytes32 policyId, bool success) external

await contract.logAttempt(policyId, true);

function isPolicyValid(bytes32 policyId) external view returns (bool)

const isValid = await contract.isPolicyValid(policyId);

event PolicyCreated(
    bytes32 indexed policyId,
    address indexed sender,
    address indexed recipient,
    uint256 expiry,
    uint256 maxAttempts
);

event VerificationAttempt(
    bytes32 indexed policyId,
    bool success
);

// 1. Generate unique policyId
const uniqueString = `${address}-${Date.now()}-${randomBytes(8)}`;
const policyId = keccak256(toUtf8Bytes(uniqueString));

// 2. Create policy
const tx = await contract.createPolicy(
  policyId,
  recipientAddress,
  Math.floor(Date.now() / 1000) + 86400,
  3
);
await tx.wait();

// 3. Store metadata (off-chain)
await fetch('/api/storeMetadata', {
  method: 'POST',
  body: JSON.stringify({
    policyId,
    cid: ipfsCid,
    sender: address,
    recipient: recipientAddress,
    // ...
  })
});

// 1. Verify SIWE
const token = await authenticate();

// 2. Check policy
const isValid = await contract.isPolicyValid(policyId);
if (!isValid) throw new Error('Policy invalid');

// 3. Log attempt
const tx = await contract.logAttempt(policyId, true);
await tx.wait();

// 4. Fetch and decrypt content
const content = await fetchFromIPFS(cid);
const decrypted = await decrypt(content, secretKey);

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract Shield {
    struct AccessPolicy {
        address sender;
        address recipient;
        uint64 expiry;
        uint32 maxAttempts;
        uint32 attempts;
        bool valid;
    }

    mapping(bytes32 => AccessPolicy) public policies;

    event PolicyCreated(bytes32 indexed policyId, address indexed sender, address indexed recipient, uint256 expiry, uint256 maxAttempts);
    event VerificationAttempt(bytes32 indexed policyId, bool success);

    function createPolicy(bytes32 policyId, address recipient, uint256 expiry, uint256 maxAttempts) external {
        require(policies[policyId].sender == address(0), "Policy already exists");
        policies[policyId] = AccessPolicy({
            sender: msg.sender,
            recipient: recipient,
            expiry: uint64(expiry),
            maxAttempts: uint32(maxAttempts),
            attempts: 0,
            valid: true
        });
        emit PolicyCreated(policyId, msg.sender, recipient, expiry, maxAttempts);
    }

    function logAttempt(bytes32 policyId, bool success) external {
        AccessPolicy storage policy = policies[policyId];
        require(policy.sender != address(0), "Policy does not exist");
        require(policy.valid, "Policy is not valid");
        require(msg.sender == policy.recipient, "Only the recipient can log an attempt");
        require(block.timestamp < policy.expiry, "Policy has expired");
        require(policy.attempts < policy.maxAttempts, "Max attempts reached");

        policy.attempts++;

        if (policy.attempts >= policy.maxAttempts) {
            policy.valid = false;
        }

        emit VerificationAttempt(policyId, success);
    }

    function isPolicyValid(bytes32 policyId) external view returns (bool) {
        AccessPolicy storage policy = policies[policyId];
        return policy.valid && block.timestamp < policy.expiry && policy.attempts < policy.maxAttempts;
    }
}