---
# System prepended metadata

title: Baal Events

---

# Baal Events

EVENTS

event SetupComplete(
    bool lootPaused, - default false 
    bool sharesPaused, - default false
    uint32 gracePeriod, - set period 
    uint32 votingPeriod, - now set period 
    uint256 proposalOffering, - anti-spam 
    uint256 quorumPercent, - quorum? 
    uint256 sponsorThreshold, - for auto-sponsoring
    uint256 minRetentionPercent, - new dilution bound
    string name, - for shares / voting token
    string symbol, - for shares / voting token 
    address[] guildTokens, - ragequitable tokens
    uint256 totalShares, - ? 
    uint256 totalLoot - ? 
    ** Do we need to add the GnosisSafe vault? 
); 
    
    
event SubmitProposal(
    uint256 indexed proposal, - proposal count 
    bytes32 indexed proposalDataHash, - action data
    uint256 votingPeriod, - might drop this now 
    bytes proposalData, - raw data 
    uint256 expiration, - outside time for processing before auto fail
    bool selfSponsor, - true / false depending on whether submitter has enought DAO votes (incl. delegated votes)
    uint256 timestamp, - time submitted 
    string details - details 
); /*emits after proposal is submitted*/
    
    
event SponsorProposal(
    address indexed member, - who sponsored 
    uint256 indexed proposal, - proposal number / order
    uint256 indexed votingStarts - when voting starts
); /*emits after member has sponsored proposal*/
    
    
event CancelProposal(uint256 indexed proposal); - same as old moloch 

/*emits when proposal is cancelled*/
    event SubmitVote(
        address indexed member, - voter 
        uint256 balance, - total voting weight including delegated shares 
** We probably want to show a voter's specific voting weight for a proposal at the time of voting, since the delegation relies on a snapshot that might not completely match. 
        uint256 indexed proposal, - proposal index
        bool indexed approved
); /*emits after vote is submitted on proposal*/
    
event ProcessProposal(
    uint256 indexed proposal, - proposal order
    bool passed, - did proposal get more yes > no
    bool actionFailed - alerts to failure to execute actions
); /*emits when proposal is processed & executed*/

    
event ProcessingFailed(uint256 indexed proposal); - duplicate event if processing fails -- don't know if we actually need this. 

/*emits when proposal is processed & executed*/
event Ragequit(
    address indexed member, - ragequitter
    address to, - address where RQ tokens are being sent
    uint256 indexed lootToBurn,- burned loot
    uint256 indexed sharesToBurn, - burned shares
    address[] tokens - the tokens that are being burned. 

** These tokens default to the GuildToken list, but there's now an advanced ragequit function that allows someone to note which tokens can be burned. 

); 
/*emits when users burn Baal `shares` and/or `loot`for given `to` account*/

event Approval(
    address indexed owner, - Baal shareholder
    address indexed spender, - person getting to spend shares
    uint256 amount - amount to be pulled
); 
**Just like ERC20 approval 
/*emits when Baal `shares` are approved for pulls with erc20 accounting*/

event Transfer(
    address indexed from, - either from Baal when minting shares for a member or from Member when burning shares
    address indexed to, - either to 0x when burning shares or to another member when minting
    uint256 amount - amount being minted or burned
    ); 
    ** If it's from member to member that's a transfer
    **I think this works as an event for us, but we could consider separate events for minting and burning to make things a little clearer. 
    /*emits when Baal `shares` are minted, burned or transferred with erc20 accounting*/


event TransferLoot(
    address indexed from,
    address indexed to,
    uint256 amount
); 
** Same deal as above when it comes to watching the to / from in terms of understanding whether loot is being minted or burned. 
** Probably place to do cleanup, since this might be duplicative with Loot having it's own events.
    /*emits when Baal `loot` is minted, burned or transferred*/
    
event DelegateChanged(
    address indexed delegator, -- person delegating 
    address indexed fromDelegate, -- old delegate (could be delegator)
    address indexed toDelegate -- new delegate
); 
**Just emits when there's a change in WHO is the delegate 
/*emits when an account changes its voting delegate*/

event DelegateVotesChanged(
    address indexed delegate,
    uint256 previousBalance,
    uint256 newBalance
); 
**Updates the balance of the delegate's voting weight at the snapshot time of the function being called. Means that they won't be able to use voting power on proposals in the works, but on future proposals. 

/*emits when a delegate account's voting balance changes*/

event ShamanSet(address indexed shaman, uint256 permission); /*emits when a shaman permission changes*/

Permissions: 
* Admin - just transferrability 
* Manager - Mint / burn 
* Governor - God mode to change gov config 

event GuildTokenSet(address indexed token, bool enabled); /*emits when a guild token changes*/

event GovernanceConfigSet(
    uint32 voting,- new voting period 
    uint32 grace, - new grace period
    uint256 newOffering, - new offering 
    uint256 quorum, - new quorum 
    uint256 sponsor, - new self-sponsor threshold
    uint256 minRetention - new dilution bound
); /*emits when gov config changes*/

event SharesPaused(bool paused); 
**When paused shares are non-transferrable 
/*emits when shares are paused or unpaused*/

event LootPaused(bool paused); 
**When paused loot is non-transferrable 
/*emits when loot is paused or unpaused*/