GlobalParams

contract GlobalParams is IGlobalParams, Ownable {
    address private s_protocolAdminAddress;
    address private s_tokenAddress;
    uint256 private s_protocolFeePercent;
    mapping(bytes32 => bool) private s_platformIsListed;
    mapping(bytes32 => address) private s_platformAdminAddress;
    mapping(bytes32 => uint256) private s_platformFeePercent;
    mapping(bytes32 => bytes32) private s_platformDataOwner;
    mapping(bytes32 => bool) private s_platformData;
    Counters.Counter private s_numberOfListedPlatforms;
}

function enlistPlatform(
    bytes32 platformHash,
    address platformAdminAddress,
    uint256 platformFeePercent
) external onlyOwner notAddressZero(platformAdminAddress);

function delistPlatform(bytes32 platformHash) external onlyOwner;

function checkIfPlatformIsListed(bytes32 platformHash) external view override returns (bool);

function getNumberOfListedPlatforms() external view override returns (uint256);

function getProtocolAdminAddress() external view override returns (address);

function updateProtocolAdminAddress(address newAdminAddress) external onlyOwner notAddressZero(newAdminAddress);

function getTokenAddress() external view override returns (address);

function updateTokenAddress(address newTokenAddress) external onlyOwner notAddressZero(newTokenAddress);

function getProtocolFeePercent() external view override returns (uint256);

function updateProtocolFeePercent(uint256 newFeePercent) external onlyOwner;

function getPlatformAdminAddress(bytes32 platformHash) external view override returns (address);

function updatePlatformAdminAddress(
    bytes32 platformHash,
    address newAdminAddress
) external onlyPlatformAdmin(platformHash) notAddressZero(newAdminAddress);

function getPlatformFeePercent(bytes32 platformHash) external view override returns (uint256);

function updatePlatformFeePercent(
    bytes32 platformHash,
    uint256 newFeePercent
) external onlyPlatformAdmin(platformHash);

function addPlatformData(
    bytes32 platformHash,
    bytes32 platformDataKey
) external onlyPlatformAdmin(platformHash);

function removePlatformData(bytes32 platformHash, bytes32 platformDataKey) external onlyPlatformAdmin(platformHash);

function checkPlatformData(bytes32 platformHash, bytes32 platformDataKey) external view returns (bool);

modifier notAddressZero(address account);

modifier onlyPlatformAdmin(bytes32 platformHash);

event PlatformEnlisted(
    bytes32 indexed platformHash,
    address indexed platformAdminAddress,
    uint256 platformFeePercent
);

event PlatformDelisted(bytes32 indexed platformHash);

event ProtocolAdminAddressUpdated(address indexed newAdminAddress);

event TokenAddressUpdated(address indexed newTokenAddress);

event ProtocolFeePercentUpdated(uint256 newFeePercent);

event PlatformAdminAddressUpdated(
    bytes32 indexed platformHash,
    address indexed newAdminAddress
);

event PlatformDataAdded(
    bytes32 indexed platformHash,
    bytes32 indexed platformDataKey
);

event PlatformDataRemoved(
    bytes32 indexed platformHash,
    bytes32 platformDataKey
);

error GlobalParamsInvalidInput();

error GlobalParamsPlatformAlreadyListed(bytes32 platformHash);

error GlobalParamsPlatformNotListed(bytes32 platformHash);

// Enlist a new platform
const platformHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes('my-platform'));
const platformAdmin = '0x...'; // Platform admin address
const platformFeePercent = 500; // 5% fee (in basis points)

const tx = await globalParams.enlistPlatform(platformHash, platformAdmin, platformFeePercent);
await tx.wait();

// Add platform data
const categoryKey = ethers.utils.keccak256(ethers.utils.toUtf8Bytes('category'));
await globalParams.addPlatformData(platformHash, categoryKey);

const nameKey = ethers.utils.keccak256(ethers.utils.toUtf8Bytes('name'));
await globalParams.addPlatformData(platformHash, nameKey);

// Get protocol configuration
const protocolAdmin = await globalParams.getProtocolAdminAddress();
const tokenAddress = await globalParams.getTokenAddress();
const protocolFee = await globalParams.getProtocolFeePercent();

console.log('Protocol Admin:', protocolAdmin);
console.log('Token Address:', tokenAddress);
console.log('Protocol Fee:', protocolFee.toString(), 'basis points');

// Update protocol admin
const newAdmin = '0x...';
await globalParams.updateProtocolAdminAddress(newAdmin);

// Update token
const newToken = '0x...';
await globalParams.updateTokenAddress(newToken);

// Update protocol fee
const newFee = 300; // 3%
await globalParams.updateProtocolFeePercent(newFee);

// Check if platform is listed
const isListed = await globalParams.checkIfPlatformIsListed(platformHash);
if (!isListed) {
  console.log('Platform not found');
}

// Get platform configuration
const platformAdmin = await globalParams.getPlatformAdminAddress(platformHash);
const platformFee = await globalParams.getPlatformFeePercent(platformHash);

// Update platform settings (as platform admin)
await globalParams.updatePlatformFeePercent(platformHash, 600); // 6%

// Update admin address
const newAdmin = '0x...';
await globalParams.updatePlatformAdminAddress(platformHash, newAdmin);

// Add custom platform data
const tagsKey = ethers.utils.keccak256(ethers.utils.toUtf8Bytes('tags'));
await globalParams.addPlatformData(platformHash, tagsKey);

// Check if data exists
const exists = await globalParams.checkPlatformData(platformHash, tagsKey);

// Remove data
await globalParams.removePlatformData(platformHash, tagsKey);

// Before creating a campaign, validate platforms
async function validateCampaignPlatforms(selectedPlatforms) {
  for (const platformHash of selectedPlatforms) {
    const isListed = await globalParams.checkIfPlatformIsListed(platformHash);
    if (!isListed) {
      throw new Error(`Platform ${platformHash} is not listed`);
    }
    
    const platformFee = await globalParams.getPlatformFeePercent(platformHash);
    console.log(`Platform ${platformHash} fee:`, platformFee, 'basis points');
  }
}

// Use in campaign creation
await validateCampaignPlatforms(selectedPlatformHashes);

// Campaign factory uses GlobalParams for validation
const factory = new ethers.Contract(
  factoryAddress,
  factoryABI,
  signer
);

// Factory queries GlobalParams during campaign creation
// to validate platform listings

// Campaign contracts read from GlobalParams
const protocolFee = await campaign.getProtocolFeePercent();
const tokenAddress = await campaign.getTokenAddress();

// Protocol admin operations
const isPaused = await campaign.paused();
const protocolAdmin = await campaign.getProtocolAdminAddress();

// Monitor platform enlistment
globalParams.on('PlatformEnlisted', (platformHash, adminAddress, feePercent, event) => {
  console.log('New platform enlisted:', platformHash);
  console.log('Admin:', adminAddress);
  console.log('Fee:', feePercent);
  
  // Update database
  await database.savePlatform(platformHash, adminAddress, feePercent);
});

// Monitor protocol updates
globalParams.on('ProtocolAdminAddressUpdated', (newAdmin) => {
  console.log('Protocol admin updated:', newAdmin);
  // Update access control
});