# 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*/