Salud Vault — Four-Token Architecture

contract SaludCoin is ERC20, AccessControl, Pausable {
  bytes32 public constant MINTER_ROLE  = keccak256("MINTER_ROLE");   // SLUD oracle only
  mapping(address => bool) public transferWhitelist; // CVS, Aetna, Medicare contracts
  // triggerType: 0=MinuteClinic, 1=Rx_refill, 2=Wellness, 3=Medicare_AWV, 4=Vaccine
  event HealthActionRewarded(address indexed user, uint8 triggerType, uint256 amount);

  function earnReward(address user, uint8 triggerType, uint256 amount, bytes calldata proof)
    external onlyRole(MINTER_ROLE) { _mint(user, amount); }

  function redeem(uint256 amount, address serviceContract) external {
    require(transferWhitelist[serviceContract], "Not approved service");
    _burn(msg.sender, amount);
    IServiceContract(serviceContract).creditBeneficiary(msg.sender, amount);
  }
  // _update override: blocks all non-whitelist, non-mint/burn transfers
}

struct CredentialRecord {
  bytes32 medicareIdHash;   // keccak256(MBI) — NOT the MBI
  bytes32 medicaidIdHash;   bytes32 aetnaMemberHash;
  string  vcCid;            // IPFS CID of AES-encrypted W3C VC bundle
  uint64  expiresAt;        bool medicareVerified; bool medicaidVerified;
}
function locked(uint256) external pure returns (bool) { return true; }  // ERC-5192
function transferFrom(address, address, uint256) public pure override {
  revert("SaludID: identity is not transferable");
}
// verifyMedicareEligibility(tokenId, zkProof): ZK proof — reveals nothing about MBI

enum PlanType { SALUD_STARTER, SALUD_FAMILIA, SALUD_PREMIUM,
  MEDICARE_ADVANTAGE, MEDICAID_MANAGED_CARE, DUAL_ELIGIBLE_SPECIAL, CVS_AETNA }
struct PlanMetadata {
  PlanType planType; uint64 effectiveDate; uint64 expiryDate;
  uint16 copayMinuteClinic; uint16 copayPrimary; uint16 copaySpecialist;
  bytes32 planContractHash; bool active;
}
function getCopayForService(uint256 tokenId, uint8 serviceType) external view returns (uint256) {
  require(isActivePlan(tokenId), "Plan expired");
  // serviceType: 0=MinuteClinic, 1=primary, 2=specialist
}

contract SaludReach is ERC1155, AccessControl {
  // ARCHITECTURAL RULE: No function here may call SaludID, SaludPass, or SaludCoin.
  // Enforced by test: verifyZeroHealthContractReference() must pass in CI/CD.
  bytes32 public constant REACH_ORACLE_ROLE = keccak256("REACH_ORACLE_ROLE");
  uint256 public constant BASE_REACH = 0;   // Fungible cross-campaign pool
  uint256 public nextCampaignId = 1;         // Campaign-specific token IDs

  struct Campaign {
    uint256 tokenId; address brand; uint256 budgetUsdc;
    uint256 budgetSpent; uint256 earnRate;
    uint64  expiresAt; uint8 targetTier; bool active;
  }
  mapping(uint256 => Campaign) public campaigns;

  // txType: 0=CVS_front_store, 1=non_CVS_retail, 2=financial_partner, 3=opt_in
  // CRITICAL: txType MUST NOT include any health-coded category (4+)
  function mintReach(
    address wallet, uint256 campaignId, uint8 txType, bytes calldata proof
  ) external onlyRole(REACH_ORACLE_ROLE) {
    require(txType <= 3, "Health-coded txType rejected");  // HIPAA guard
    Campaign storage c = campaigns[campaignId];
    require(c.active && block.timestamp <= c.expiresAt, "Campaign inactive");
    require(c.budgetSpent + c.earnRate <= c.budgetUsdc, "Budget exhausted");
    c.budgetSpent += c.earnRate;
    _mint(wallet, BASE_REACH, c.earnRate, "");       // Base fungible pool
    _mint(wallet, campaignId, c.earnRate, "");     // Campaign semi-fungible
    emit CommercialActionRewarded(wallet, campaignId, txType, c.earnRate);
  }

  function redeemReach(uint256 campaignId, uint256 amount, address rewardContract) external {
    _burn(msg.sender, BASE_REACH, amount);
    IRewardContract(rewardContract).issueBrandReward(msg.sender, amount, campaignId);
  }
}