The AddressFeeSplitManager allows revenue to be distributed across any number of addresses. Each address can be given a percentage (as small as 0.00001%) and can claim independently of each other.
Multiple Flaunch stream tokens can be held inside the manager, and the creator will also receive a share of their revenue before it is distributed to the nominated addresses.
Addresses that receive a fee split are immutable at point of manager creation.
Initialization
/**
* Parameters passed during manager initialization.
*
* @member creatorShare The 5dp percentage share that a creator will earn from their token
* @member recipientShares Revenue recipients and their share
*/
struct InitializeParams {
uint creatorShare;
RecipientShare[] recipientShares;
}
/**
* Defines a revenue recipient and the share that they will receive.
*
* @member recipient The share recipient of revenue
* @member share The 5dp percentage that the recipient will receive
*/
struct RecipientShare {
address recipient;
uint share;
}
Deposit
No additional data required
Public Read Calls
amountClaimed(address _recipient) returns (uint)
The amount claimed for the recipient
balances(address _recipient) returns (uint)
Allows the caller to check the balance of their position. This will check all of the creator's tokens and their fee split share.
The address of the user allocated as the creator of the token
creatorFees() returns (uint)
Gets the total amount of fees allocated to creators, including any fees that are pending against the manager. These pending fees will be claimed during the recipient claim flow.
creatorShare() returns (uint)
The percentage that a creator will receive before other recipients, accurate to 5 decimal places.
Checks if the recipient has either been given a share at initialization or has any tokens that they created held in the manager.
managerFees() returns (uint)
Gets the total amount of fees held by the manager, including any fees that are pending against the manager. These pending fees will be claimed during the recipient claim flow.
managerFees() returns (uint)
Gets the total amount of fees held by the manager, including any fees that are pending against the manager. These pending fees will be claimed during the recipient claim flow.
managerOwner() returns (address)
The owner of the manager that can make protected function calls.
The total amount of ETH that has been claimed for a specific token
Public Write Calls
claim() returns (uint)
Allows for a claim call to be made without requiring any additional requirements for bytes to be passed, as these would always be unused for this FeeSplit Manager.
Allows the user to transfer their recipient share to another user.
The recipient share can only be transferred by the address that owns the recipient share. If the new recipient already has a recipient share, then these will be merged.
Protected Calls
Only the owner of the manager can make these calls
Allows a protocol owner to make a claim, without any additional {FlaunchToken} logic being passed in the parameters. This returns the amount of ETH claimed during the call.
Allows the end-owner creator of the ERC721 to be updated by the intermediary platform. This will change the recipient of fees that are earned from the token externally and can be used for external validation of permissioned calls.
Transfers ownership of the contract to a new account (newOwner).
Who is using the AddressFeeSplitManager?
We are currently working with a small number of launchpads to implement our AddressFeeSplitManager. When they are released as public code repositories, we will share and document the implementations. Check back soon!
