Andromeda
Ask or search…
K
Comment on page

Weighted Distribution Splitter

Introduction

The Weighted-Distribution-Splitter ADO is a smart contract to split funds among a set of defined recipients. Each of the recipients is assigned a weight which is divided by the total weight to get the percentage of each of the recipients.
In the Weighted Distribution Splitter ADO, each recipient is assigned a weight. The weight represents the proportion of funds that the recipient will receive. The total weight of all recipients is calculated, and then each recipient's weight is divided by the total weight to determine their percentage of the funds.
Whenever the splitter receives funds by executing a send, it automatically splits the funds for distribution to the defined recipients. The splitter can be locked for a predetermined period, acting as a guarantee for recipients that their allocated weights will remain constant during that time.
For example, if there are three recipients with weights 4, 7, and 2 respectively, the total weight is 13. The first recipient will receive 4/13 of the funds, the second recipient will receive 7/13 of the funds, and the third recipient will receive 2/13 of the funds.
If a recipient is then added, the total weight is increased and the percentages are recalculated.
The contract supports modules to extend it's functionality.
ado_type: weighted-distribution-splitter

InstantiateMsg

A maximum of 100 recipients can be set.
The minimum lock_time that can be set is 86,400 which is 1 day.
The maximum lock_time that can be set is 31,536,000 which is 1 year.
Rust
JSON
pub struct InstantiateMsg {
pub recipients: Vec<AddressWeight>,
pub lock_time: Option<u64>,
pub modules: Option<Vec<Module>>,
pub kernel_address: String,
pub owner: Option<String>
}
{
"recipients":[
{
"recipient":{
"address":"andr1..."
},
"weight": 4
},
{
"recipient":{
"address":"andr1..."
},
"weight": 7
},
{
"recipient":{
"address":"andr1..."
},
"weight": 2
}
],
"kernel_address":"andr1..."
}
Name
Type
Description
recipients
The vector of recipients for the contract. Anytime a Send execute message is sent the amount sent will be divided amongst these recipients depending on their assigned weight.
lock_time
Option<u64>
How long the splitter is locked. When locked, no recipients/weights can be added/changed. In seconds.
modules
Option<Vec<Module>>
An optional vector of Andromeda Modules that can be attached to the contract."address-list" module can be added.
kernel_address
String
Contract address of the kernel contract to be used for AMP messaging. Kernel contract address can be found in our deployed contracts.
owner
Option<String>
Optional address to specify as the owner of the ADO being created. Defaults to the sender if not specified.

AddressWeight

Struct containing the recipient of the funds and the assigned weight for that recipient.
pub struct AddressWeight {
pub recipient: Recipient,
pub weight: Uint128,
}
Name
Type
Description
recipient
Recipient
The address to receive the funds.
weight
Uint128
The weight of the above recipient.

ExecuteMsg

UpdateRecipients

Updates the recipients of the splitter. When executed, the previous recipients and distribution are replaced by the new list.
Only available to the contract owner/operator when the contract is not locked.
Rust
JSON
pub enum ExecuteMsg {
UpdateRecipients {
recipients: Vec<AddressWeight>,
}
}
{
"update_recipients":{
"recipients":[
{
"recipient":{
"address":"andr1..."
},
"weight": 1
},
{
"recipient":{
"address":"andr1..."
},
"weight": 4
},
{
"recipient":{
"address":"andr1..."
},
"weight": 12
}
]
}
}
Name
Type
Description
recipients
The new recipients of the split funds with their assigned weights.

AddRecipient

Add a recipient to the list.
Only available to the contract owner/operator.
When a recipient is added, the total weight is changed and all the weights are recalculated appropriately.
Rust
JSON
pub enum ExecuteMsg {
AddRecipient {
recipient: AddressWeight,
}
}
{
"add_recipient":{
"recipient":{
"recipient":{
"address":"andr1..."
},
"weight": 1
}
}
Name
Type
Description
recipient
The recipient to add along with the corresponding weight.

RemoveRecipient

Only available to the contract owner/ operator.
Remove a recipient from the distribution.
Rust
JSON
pub enum ExecuteMsg {
RemoveRecipient {
recipient: Recipient,
}
}
{
"remove_recipient":{
"recipient":{
"address":"andr1..."
}
}
Name
Type
Description
recipient
Recipient
The recipient to remove from the list.

UpdateLock

Used to lock the contract for a certain period of time making it unmodifiable in any way. This can serve as a way to ensure for recipients that their weights from the splitter are fixed for a certain amount of time. The time is calculated in seconds.
Only available to the contract owner/operator.
Cannot be called if a lock is already in action.
The minimum time that can be set is 86,400 which is 1 day.
The maximum time that can be set is 31,536,000 which is 1 year.
Rust
JSON
pub enum ExecuteMsg {
UpdateLock {
lock_time: u64,
}
}
{
"update_lock":{
"lock_time": 200000
}
}
Name
Type
Description
lock_time
u64
The time in seconds to lock the contract for.

UpdateRecipientWeight

Updates the weight of a specific recipient from the list of recipients.
Only available to the contract owner/operator.
Rust
JSON
pub enum ExecuteMsg {
UpdateRecipientWeight {
recipient: AddressWeight,
}
}
{
"update_recipient_weight":{
"recipient":{
"recipient":{
"address":"andr1..."
},
"weight": 1
}
}
Name
Type
Description
recipient
The new weight for the recipient.

Send

Divides any attached funds to the message amongst the recipients list.
A maximum of 5 types of funds can be sent in one send message.
Rust
JSON
pub enum ExecuteMsg {
Send {}
}
{
"send":{}
}

Base Executes

Uses the modules feature.
The rest of the execute messages can be found in the ADO Base section.

QueryMsg

GetSplitterConfig

Queries the current config of the contract.
Rust
JSON
pub enum QueryMsg {
#[returns(GetSplitterConfigResponse)]
GetSplitterConfig {},
}
{
"get_splitter_config":{}
}

GetSplitterConfigResponse

Rust
JSON
pub struct GetSplitterConfigResponse {
pub config: Splitter,
}
{
"config":{
"recipients":[
{
"recipient":{
"address":"andr1..."
},
"weight": 1
},
{
"recipient":{
"address":"andr1..."
},
"weight": 4
},
{
"recipient":{
"address":"andr1..."
},
"weight": 12
}
],
"lock": {
"at_time": "1655212973934"
}
}
}

Splitter

pub struct Splitter {
pub recipients: Vec<AddressWeight>,
pub lock: Expiration,
}
Name
Type
Description
recipients
The vector of recipients for the contract. Anytime a Send execute message is sent the amount sent will be divided amongst these recipients depending on their assigned weight.
locked
The expiration time of the lock. Will return an epoc time which is equal to the current_time + lock_time taken at the point of setting the lock. (Current time refers to the time the lock was set and not the time now.)

GetUserWeight

Queries the user's allocated weight.
Rust
JSON
pub enum QueryMsg {
#[returns(GetUserWeightResponse)]
GetUserWeight {
user: Recipient,
}
}
{
"get_user_weight":{
"user":{
"address":"andr1..."
}
}
}
Name
Type
Description
user
Recipient
The user we want to check the weight for.

GetUserWeightResponse

pub struct GetUserWeightResponse {
pub weight: Uint128,
pub total_weight: Uint128,
}
Name
Type
Description
weight
Uint128
The weight of the user.
total_weight
Uint128
The total weight of the splitter.

Base Queries

The rest of the query messages can be found in the ADO Base section.