FiatEnabled

abstract contract FiatEnabled {
    uint256 internal s_fiatRaisedAmount;
    bool internal s_fiatFeeIsDisbursed;
    mapping(bytes32 => uint256) internal s_fiatAmountById;
    
    event FiatTransactionUpdated(bytes32 indexed fiatTransactionId, uint256 amount);
    event FiatFeeDisbusementStateUpdated(bool isDisbursed, uint256 protocolFeeAmount, uint256 platformFeeAmount);
    
    error FiatEnabledAlreadySet();
    error FiatEnabledDisallowedState();
    error FiatEnabledInvalidTransaction();
}

function getFiatRaisedAmount() public view returns (uint256);

function getFiatTransactionAmount(bytes32 fiatTransactionId) 
    external 
    view 
    returns (uint256 amount);

function checkIfFiatFeeDisbursed() external view returns (bool);

function _updateFiatTransaction(
    bytes32 fiatTransactionId,
    uint256 fiatTransactionAmount
) internal;

function _updateFiatFeeDisbursementState(
    bool isDisbursed,
    uint256 protocolFeeAmount,
    uint256 platformFeeAmount
) internal;

event FiatTransactionUpdated(
    bytes32 indexed fiatTransactionId,
    uint256 fiatTransactionAmount
);

event FiatFeeDisbusementStateUpdated(
    bool isDisbursed,
    uint256 protocolFeeAmount,
    uint256 platformFeeAmount
);

error FiatEnabledAlreadySet();

error FiatEnabledDisallowedState();

error FiatEnabledInvalidTransaction();

// Record a fiat payment
const transactionId = ethers.utils.keccak256(
  ethers.utils.toUtf8Bytes('stripe-payment-12345')
);
const amount = ethers.utils.parseEther('100'); // $100

// Update transaction (internal function called by owner)
await treasury._updateFiatTransaction(transactionId, amount);

// Listen for event
treasury.on('FiatTransactionUpdated', (txId, amount, event) => {
  console.log('Fiat transaction recorded:', ethers.utils.formatEther(amount));
});

// Get total fiat raised
const fiatRaised = await treasury.getFiatRaisedAmount();
console.log('Fiat raised:', ethers.utils.formatEther(fiatRaised), 'USD');

// Get total crypto raised
const cryptoRaised = await treasury.getTotalPledged();

// Total campaign funding
const totalFunding = fiatRaised.add(cryptoRaised);
console.log('Total funding:', ethers.utils.formatEther(totalFunding));

// Verify a fiat transaction
const transactionId = ethers.utils.keccak256(
  ethers.utils.toUtf8Bytes('stripe-payment-12345')
);

try {
  const amount = await treasury.getFiatTransactionAmount(transactionId);
  console.log('Transaction amount:', ethers.utils.formatEther(amount));
} catch (error) {
  if (error.message.includes('FiatEnabledInvalidTransaction')) {
    console.log('Transaction not found');
  }
}

// Disburse fiat fees
const protocolFee = ethers.utils.parseEther('2');
const platformFee = ethers.utils.parseEther('3');

await treasury._updateFiatFeeDisbursementState(true, protocolFee, platformFee);

// Check if fees disbursed
const feesDisbursed = await treasury.checkIfFiatFeeDisbursed();
console.log('Fees disbursed:', feesDisbursed);

// Integrate with Stripe, Plaid, etc.
async function processFiatPayment(paymentMethod, amount) {
  // Process payment through on-ramp
  const transaction = await stripe.charges.create({
    amount: amount * 100, // Convert to cents
    currency: 'usd',
    source: paymentMethod
  });
  
  // Record in treasury
  const transactionId = ethers.utils.keccak256(
    ethers.utils.toUtf8Bytes(`stripe-${transaction.id}`)
  );
  
  await treasury._updateFiatTransaction(
    transactionId,
    ethers.utils.parseEther(amount.toString())
  );
  
  return transactionId;
}

// Track both crypto and fiat
async function getTotalFunding() {
  const cryptoRaised = await treasury.getTotalPledged();
  const fiatRaised = await treasury.getFiatRaisedAmount();
  
  // Convert fiat to crypto equivalent (using oracle)
  const exchangeRate = await getUSDToTokenRate();
  const fiatInTokens = fiatRaised.mul(exchangeRate).div(ethers.constants.WeiPerEther);
  
  const totalFunding = cryptoRaised.add(fiatInTokens);
  return totalFunding;
}

// Record immediately after payment success
await paymentProcessor.charge(amount).then(async (result) => {
  if (result.success) {
    await treasury._updateFiatTransaction(
      generateTransactionId(result),
      amount
    );
  }
});

// Listen to all events
treasury.on('FiatTransactionUpdated', (txId, amount, event) => {
  // Store in database
  await database.recordFiatTransaction({
    campaignId,
    transactionId: txId,
    amount,
    timestamp: event.blockTimestamp
  });
});