Fixed Amount Splitter

Introduction

The Fixed Amount Splitter ADO is a smart contract used to split funds to a preset number of addresses. Each of the addresses has a specific amount assigned by the contract owner. Once a Send message is triggered, the attached funds are distributed to the recipients based on the assigned amounts.

The splitter can be locked for a specified time as a kind of insurance for recipients that their percentages will not be changed for a certain period of time.

We also have a percentage based spliiter, weighted distribution splitter, and conditional splitter.

Ado_type: fixed-amount-splitter

Version: 1.1.0-beta

InstantiateMsg

A maximum of 100 recipients can be set.

The recipient addresses need to be unique.

A maximum of 2 Coin types can be used.

The minimum lock_time that can be set is 1 day.

The maximum lock_time that can be set is 1 year.

Rust

pub struct InstantiateMsg {
    pub recipients: Vec<AddressAmount>,
    pub lock_time: Option<Expiry>,
    pub default_recipient: Option<Recipient>,
    pub kernel_address: String,
    pub owner: Option<String>,
}

JSON

{
"recipients":[
                {
                  "recipient":{
                    "address":"andr1..."
                    },
                  "coins":[{"denom":"uandr","amount":"10000"}]
                  },
                  {
                  "recipient":{
                    "address":"andr1..."
                    },
                  "coins":[{"denom":"uandr","amount":"20000"}]
                  },
                  {
                  "recipient":{
                    "address":"andr1..."
                    },
                  "coins":[{"denom":"uandr","amount":"60000"}]
                  }
              ],
"lock_time":{
      "from_now": 100000000
      },
"kernel_address":"andr1..."
}

Name	Type	Description
recipients	Vec<AddressAmount>	The recipient list of the splitter. Can be updated after instantiation if there is no current lock time.
lock_time	Option<Expiry>	How long the splitter is locked. When locked, no recipients can be added/changed.
default_recipient	Option<Recipient>	An optional recipient to receive any leftover funds in case the split is not exactly distributed or there are any leftover funds. Defaults to the sender if not specified.
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.

Anytime a Send execute message is sent, the amount sent will be divided amongst the recipients depending on their assigned percentage.

AddressAmount

The splitter uses a basic array of structs to determine recipients and how the funds are divided.

Rust

pub struct AddressAmount {
    pub recipient: Recipient,
    pub coins: Vec<Coin>,
}

JSON

{
    "recipient":{
        "address":"andr1..."
     },
    "coins":[{"denom":"uandr","amount":"10000"}]
}

Read more about the Recipient struct here.

ExecuteMsg

UpdateRecipients

Updates the recipients of the splitter contract. Only executable by the contract owner when the contract is not locked.

Only available to the contract owner when the contract is not locked.

A maximum of 100 recipients can be set.

The recipients should be unique.

Rust

pub enum ExecuteMsg {
    UpdateRecipients { 
        recipients: Vec<AddressAmount> 
    },
}

JSON

{
    "update_recipients": {
        "recipients":[
                {
                  "recipient":{
                    "address":"andr1..."
                    },
                  "coins":[{"denom":"uandr","amount":"10000"}]
                  },
                  {
                  "recipient":{
                    "address":"andr1..."
                    },
                  "coins":[{"denom":"uandr","amount":"20000"}]
                  },
                  {
                  "recipient":{
                    "address":"andr1..."
                    },
                  "coins":[{"denom":"uandr","amount":"60000"}]
                  }
              ],
    }
}

Name	Type	Description
recipients	Vec<AddressAmount>	The new list of addresses to receive funds.

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 when the contract is not already locked.

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

pub enum ExecuteMsg {
    UpdateLock {
        lock_time: Expiry,
    },
}

JSON

{
    "update_lock": {
        "lock_time":{
            "from_now": 6000000
        }
    }
}

Name	Type	Description
lock_time	Expiry	How long the splitter is locked. When locked, no recipients can be added/changed.

Send

Divides any attached funds to the message amongst the recipients list based on the assigned amounts.

Make sure to attach funds when executing a Send.

Rust

pub enum ExecuteMsg {
    Send {
        config: Option<Vec<AddressAmount>>   
    }
}

JSON

{
"send": {}
}

Name	Type	Description
config	Option<Vec<AddressAmount>>	An optional set of recipients/amounts to use. If not defined, then the default configuration (List defined at instantiation) will be used.

UpdateDefaultRecipient

Updates the set default recipient.

Only available to the contract owner.

Rust

pub enum ExecuteMsg {
  UpdateDefaultRecipient {
        recipient: Option<Recipient>,
    },
}

JSON

{
    "update_default_recipient": {
        "recipient":{
            "address":"andr1..."
            }
        }
}

Name	Type	Description
recipient	Option<Recipient>	The new recipient to receive any leftover funds in case the split is not exactly distributed. For example if a user sets 40% to one user, and 50% to another, and forgets about the last 10%, they would go this default recipient. Defaults to the sender if not specified.

Base Executes

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

QueryMsg

GetSplitterConfig

The current config of the Splitter contract.

Rust

pub enum QueryMsg {
    #[returns(GetSplitterConfigResponse)]
    GetSplitterConfig {},
}

JSON

{
"get_splitter_config": {}
}

GetSplitterConfigResponse

Rust

pub struct GetSplitterConfigResponse {
    pub config: Splitter,
}

JSON

{
    "config": {
        "recipients": [
            {
                "recipient":{
                   "addr":"andr1..."
                    },
                "coin":[{"denom":"uandr","amount":"100000"}]
            },
            ...
        ],
        "lock": 12384395739430    
    }
}

Name	Type	Description
config	Splitter	The Splitter config struct.

Splitter

The splitter's config is stored in a basic struct.

pub struct Splitter {
    pub recipients: Vec<AddressAmount>,
    pub lock: MillisecondsExpiration,
}

Name	Type	Description
recipients	Vec<AdressPercent>	The vector of the assigned recipients to receive the funds along with their percentages.
lock	MillisecondsExpiration	Returns the timestamp in milliseconds of the end date for the lock.

Base Queries

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