BaseTreasury

abstract contract BaseTreasury is
    Initializable,
    ICampaignTreasury,
    CampaignAccessChecker,
    PausableCancellable
{
    using SafeERC20 for IERC20;
    
    bytes32 internal constant ZERO_BYTES;
    uint256 internal constant PERCENT_DIVIDER = 10000;
    
    bytes32 internal PLATFORM_HASH;
    uint256 internal PLATFORM_FEE_PERCENT;
    IERC20 internal TOKEN;
    
    uint256 internal s_pledgedAmount;
    bool internal s_feesDisbursed;
}

uint256 internal constant PERCENT_DIVIDER = 10000;

bytes32 internal constant ZERO_BYTES = 0x0...0;

function __BaseContract_init(
    bytes32 platformHash,
    address infoAddress
) internal;

function getPlatformHash() external view override returns (bytes32);

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

function disburseFees()
    public
    virtual
    override
    whenCampaignNotPaused
    whenCampaignNotCancelled;

protocolShare = (balance * protocolFeePercent) / 10000
platformShare = (balance * platformFeePercent) / 10000

function _checkSuccessCondition() internal view virtual returns (bool);

function withdraw()
    public
    virtual
    override
    whenCampaignNotPaused
    whenCampaignNotCancelled;

modifier whenCampaignNotPaused();

modifier whenCampaignNotCancelled();

event FeesDisbursed(uint256 protocolShare, uint256 platformShare);

event WithdrawalSuccessful(address to, uint256 amount);

event SuccessConditionNotFulfilled();

error TreasuryTransferFailed();

error TreasurySuccessConditionNotFulfilled();

error TreasuryFeeNotDisbursed();

error TreasuryCampaignInfoIsPaused();

contract CustomTreasury is BaseTreasury {
    // Custom state variables
    uint256 private s_customAmount;
    
    // Override initialization
    function initialize(
        bytes32 platformHash,
        address infoAddress,
        string calldata name,
        string calldata symbol
    ) external initializer {
        __BaseContract_init(platformHash, infoAddress);
        // Additional initialization
        s_customAmount = 0;
    }
    
    // Override success condition
    function _checkSuccessCondition() 
        internal 
        view 
        override 
        returns (bool) 
    {
        // Custom logic here
        return s_customAmount >= CUSTOM_THRESHOLD;
    }
    
    // Custom pledge function
    function customPledge(uint256 amount) external {
        // Update custom amount
        s_customAmount += amount;
        s_pledgedAmount += amount;
        
        // Transfer tokens
        TOKEN.safeTransferFrom(msg.sender, address(this), amount);
    }
}

// 1. Check success condition
const isSuccessful = await treasury._checkSuccessCondition();
if (!isSuccessful) {
  throw new Error('Campaign did not reach goal');
}

// 2. Disburse fees
const tx1 = await treasury.disburseFees();
await tx1.wait();

// Listen for event
treasury.on('FeesDisbursed', (protocolShare, platformShare, event) => {
  console.log('Protocol fee:', ethers.utils.formatEther(protocolShare));
  console.log('Platform fee:', ethers.utils.formatEther(platformShare));
});

// 3. Campaign owner withdraws remaining funds
const tx2 = await treasury.withdraw();
await tx2.wait();

// Listen for event
treasury.on('WithdrawalSuccessful', (to, amount, event) => {
  console.log('Owner withdrew:', ethers.utils.formatEther(amount));
});

// Check if campaign is paused
const isPaused = await campaign.paused();
if (isPaused) {
  console.log('Campaign is paused');
}

// Check if campaign is cancelled
const isCancelled = await campaign.cancelled();
if (isCancelled) {
  console.log('Campaign is cancelled');
}

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

// Treasury reads campaign state
const goal = await campaign.getGoalAmount();
const totalRaised = await campaign.getTotalRaisedAmount();
const launchTime = await campaign.getLaunchTime();
const deadline = await campaign.getDeadline();

// Treasury checks if campaign is active
const isPaused = await campaign.paused();
const isCancelled = await campaign.cancelled();

// Treasury uses fee configuration
const protocolFee = await globalParams.getProtocolFeePercent();
const platformFee = await globalParams.getPlatformFeePercent(platformHash);

// Calculate fee amounts
const protocolShare = (balance * protocolFee) / 10000;
const platformShare = (balance * platformFee) / 10000;

// All treasury types inherit from BaseTreasury
contract AllOrNothing is BaseTreasury, ERC721Burnable {
    // Custom pledge logic
    function pledgeForAReward(...) external { ... }
    
    // Override success condition
    function _checkSuccessCondition() 
        internal 
        view 
        override 
        returns (bool) 
    {
        return getTotalPledged() >= getGoal();
    }
}

// Define clear, testable success conditions
function _checkSuccessCondition() 
    internal 
    view 
    override 
    returns (bool) 
{
    // Use descriptive variable names
    uint256 totalRaised = s_pledgedAmount;
    uint256 fundingGoal = INFO.getGoalAmount();
    
    // Make condition explicit
    bool goalReached = totalRaised >= fundingGoal;
    
    return goalReached;
}

// This function MUST be overridden by implementation
function _checkSuccessCondition() 
    internal 
    view 
    virtual 
    returns (bool);

// Can override for custom behavior
function disburseFees() public virtual override;
function withdraw() public virtual override;