Address Fee Split Manager

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.

creator(address _flaunch, uint _tokenId) returns (address)

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.

creatorTotalClaimed(address _creator) returns (uint)

Tracks the total claims for creators

feesCreator() returns (uint)

The total fees that have been claimed for creators

feesSplit() returns (uint)

The total fees that have been claimed for the split recipients

getCreatorFee(uint _amount) returns (uint)

Calculates the creator fee that will be taken from the amount passed in.

isValidRecipient(address _recipient, bytes memory _data) returns (bool)

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.

recipientShare(address _recipient, bytes memory _data) returns (uint)

Gets the percentage share that a recipient address is allocated from the whole of the revenue fees.

tokens(address _creator) returns (FlaunchToken[] memory flaunchTokens)

Returns an array of all FlaunchToken data assigned to the creator.

tokenTotalClaimed(address _flaunch, uint _tokenId) returns (uint)

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.

deposit(FlaunchToken calldata _flaunchToken, address _creator, bytes calldata _data)

Deposits a FlaunchToken into the manager.

transferRecipientShare(uint _newRecipient)

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.

rescue(FlaunchToken calldata _flaunchToken, address _recipient)

Rescues the ERC721, extracting it from the manager and transferring it to a recipient.

setCreator(FlaunchToken calldata _flaunchToken, address payable _creator)

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.

transferManagerOwnership(address _newManagerOwner)

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!

ABI

AddressFeeSplitManager.json

21KB

Open