# About
Kryptonite is Sei's premier liquid staking platform. It enables users to enhance their staking strategies by providing them with access to liquidity normally locked within their staked assets.
**Mission**\
\
Kryptonite's mission is to become the main DeFi pillar of Sei Network. The main goal is to be fully integrated into the network so that we, as a whole, can attract more users and build a more robust community.\
\
We plan on doing this in a two-fold plan. First, securing Sei by decentralization through our network of validators. And secondly, helping users earn more yield. This is done through the premise of unlocking liquidity within the Sei ecosystem using a combination of LSDs and stablecoins.
# Protocol Overview
## Features
### No Minimums
There is no minimum participation requirement for users. Users can stake any amount of SEI in the staking pool. In comparison to staking directly with the validating nodes, users do not need to perform any operations to benefit from the compounded growth of their staked assets.
### Decentralized
After all SEI is deposited into the platform, it is directly staked to the validating nodes through smart contracts. The Kryptonite platform does not directly hold user assets. Users can initiate redemption at any time, however, according to Sei chain's Unbonding process, their Sei-based assets can be retrieved after approximately 21 days.
### Rich DeFi ecosystem
Kryptonite is not only a Sei Staking platform but is also a rich DeFi ecosystem. Users who stake on the platform receive LST (liquid staking token) assets, which can be used to mint stablecoins to increase their own liquidity. They can also participate in lending products to provide liquidity to borrowers and earn lending interest. By participating in the Kryptonite ecosystem, users can also continuously receive the platform's governance token, SEILOR.
## Framework Diagram
# Platform Overview
1/ Platform's total TVL.
2/ Your value and positions within Kryptonite.
3/ Total amount of $SEILOR burned.
4/ Supported assets current price and your wallet balance.
5/ Vaults where you can stake your assets such as SEI and SEILOR.
6/ After staking your $SEI, you can claim rewards here.
7/ Specify how much $SEI (or associated assets) you'd like to stake. Click "Stake" to stake and receive $stSEI.
Alternatively, Burn is the opposite mechanism. This unstakes your $stSEI back to $SEI. Here you'll also specify how much $stSEI you want to unstake and click "Burn stSEI".
8/ BOOST - this is where you can choose your boost rewards and your vesting periods. Longer vest periods = more rewards 👍
9/ LPs - this section shows you which LP's are active and which one you're able to participate in. These change often, so please check back frequently.
10/ Vest - this allows users to manage their escrowed $SEILOR and enables you to go from veSEILOR back to SEILOR.
11/ You can use this bridge to move your SEILOR from chain to chain while maintaining ownership of your assets.
That's it. Hopefully this helps you easily navigate the Kryptonite application 💪
# Staking SEI
This page will walk you through how to stake your SEI and start earning yield.
\
\
1\. Navigate to the [kASSET](https://app.kryptonite.finance/kasset) tab. Click **Stake & Burn**.
1
2. Specify how much SEI you want to bond. Click **Mint** to mint stSEI. Currenty APR can also be found in the green text. For this screenshot it's showing as 4.46%.
2
3. Current APY can be found on the Mint & Burn mechanism in Yellow text.
Now your SEI is staked and earning auto-compounding rewards as stSEI.
# Burning stSEI\*
This page will walk you through how to burn your stSEI.\
\
1\. Navigate to the [kASSET](https://app.kryptonite.finance/kasset) tab. Click **Stake & Burn**.
1
2. Specify how much SEI you want to burn. Click **Burn stSEI** to burn stSEI.
**\*NOTE** - there is a 21 day unbonding period. At that time your balance will not be reflected until it is complete.
# Getting into an LP
You've staked SEI. But now you want more. Why not explore adding liquidity into an LP?\
\
Here's how you can do it. \
\
There's two ways to add your liquidity into an LP. Single-sided or Double-sided.\
\
Single - Adding either SEI or SEILOR into the pool.\
Double - Adding both SEI and SEILOR into the pool. You must hold both tokens to be able to do this.\
\
1\. Go to Astroport. Go to [Pools](https://app.astroport.fi/pools).
1
2. Search for the correct pool. Be careful there's a lot of fake and scam pools that are out there. Be sure to choose the correct one. And click **Add Liquidity**.
3. Choose Double-Sided or One-Sided. Specify the amount of SEILOR-SEI you want to add to the pool and click **Add Liquidity**.
3
Now that you've added liquidity to an LP. You can now earn additional rewards by staking it on Kryptonite.
4. Navigate to the [SEILOR](https://app.kryptonite.finance/seilor) tab. Here you'll see a few pools that are currently active. For this example, we'll still be looking at SEILOR-SEI.
5. Choose your Boost - **0%, 20%, 30%, 50%, or 100%**. Click **Stake**.
6. Specify how much of the LP token you'd like to stake and click **Stake**.
Now you're staked in a Liquidity Pool. Congrats!
# NFT Game Event Rules
*Kryptonite* is launching the first ever NFT x DeFi x GameFi event on SEI to grow and empower the community.
Prize Pool: **444,400 SEI (Community) + 15,000 SEI (Kryptonite)**
**NFT Sale:**
Total NFT quantity: **4444**
100 SEI per NFT mint
Minting is divided into 2 phases:
Phase 1: Whitelist\
Phase 2: Public\
\
Whitelist will last 2 hours (guaranteed mint).\
Max mint: 1 NFT
After 2 hours, its FCFS (first come, first serve).
All SEI spent on minting goes directly into the prize pool.
And NFTs can be freely traded with an 8% royalty fee charged on each transaction. Royalty fees will also go into the prize pool.
**Medal Acquisition:**
Participate in campaign dedicated tasks to earn medals. e.g. - RT a Twitter post to earn a medal
**Dragon Card Draw:**
**10 $SEILOR** gets you a blind box.\
That SEILOR immediately gets burned.\
\
Each blind box contains 1 of 6 parts of a dragon card. Collecting all 6 creates the full Dragon Card.\
\
Each card can be traded with an 8% royalty fee. This fee also goes into the prize pool.
The event will run for 1 month. And upon completion...
50% - distributed to users that...
Hold Seimen NFTs + Hold Kryptonite Medals + Hold Completed Dragon Cards
And 20% of the initial distribution to the platform treasury
50% - Gets rolled over to the next event iteration
# Staking
## Bond
Users deposit SEI into the smart contract through contract transactions. The smart contract delegates the received SEI to the validating nodes in the whitelist. Based on the current exchange rate between SEI and stSEI, the smart contract provides users with the corresponding amount of stSEI.
## Unbond
Users can transfer stSEI back to the smart contract. The contract will automatically burn the stSEI and exchange it for the corresponding amount of SEI based on the current exchange rate.\
\
Due to the characteristics of the Sei chain, it takes 21 days to withdraw the entire unbonded amount from the chain. A single staking entity can initiate no more than 7 unbond operations within a single validating node.\
\
Currently, the contract automatically caches user unbond operations and initiates the unbonding process with the validating nodes after a 3-day interval. Therefore, the actual redemption time for a single unbond operation ranges from 21 to 24 days. (In the future, the platform will provide a fast channel where burning SEILOR can expedite the withdrawal of SEI).
## Validating Nodes
Kryptonite has partnered with three premium node service providers.
####  Enigma
Validator Address: [seivaloper1zv9z2wqt348dhxqn38xv8dvsu78cle4xs2cdf4](https://www.mintscan.io/sei/validators/seivaloper1zv9z2wqt348dhxqn38xv8dvsu78cle4xs2cdf4)
Account Address: [sei1zv9z2wqt348dhxqn38xv8dvsu78cle4xw9frg9](https://www.mintscan.io/sei/address/sei1zv9z2wqt348dhxqn38xv8dvsu78cle4xw9frg9)
Website:
####  Rhino
Validator Address: [seivaloper146m089lq8mkqw6w0mmlhxz6247g2taha89at74](https://www.mintscan.io/sei/validators/seivaloper146m089lq8mkqw6w0mmlhxz6247g2taha89at74)
Account Address: [sei146m089lq8mkqw6w0mmlhxz6247g2tahae2v9l9](https://www.mintscan.io/sei/address/sei146m089lq8mkqw6w0mmlhxz6247g2tahae2v9l9)
Website:
####  Kingnodes
Validator Address: [seivaloper1wwfpmcvehq6yqdxfccs5rdr745q3kmy06l9d0d](https://www.mintscan.io/sei/validators/seivaloper1wwfpmcvehq6yqdxfccs5rdr745q3kmy06l9d0d)
Account Address: [sei1wwfpmcvehq6yqdxfccs5rdr745q3kmy0ys5rwa](https://www.mintscan.io/sei/address/sei1wwfpmcvehq6yqdxfccs5rdr745q3kmy0ys5rwa)
Website:
# Farming
## Farming
The platform has reserved a total of 350,000,000 (35%) SEILOR tokens for mining users. \
\
Before the establishment of Governance, the initial team will decide in batches to set rewards for users participating in platform activities. Once the Governance mechanism matures, the transition will be made to community governance to determine the timing, weight, and distribution of rewards.
For Phase 1 of Farming, a total of 10,500,000 veSEILOR tokens will be allocated for a period of 30 days. Among them, 10,000,000 veSEILOR tokens will be rewarded to users providing liquidity in the SEI/SEILOR Pool, and 500,000 veSEILOR tokens will be rewarded to users providing liquidity in the STSEI/SEIYAN Pool.
The users in the stSEI/SEIYAN Pool will receive their rewards through an airdrop. After the SEIYAN mining rewards end, 500,000 veSEILOR tokens will be directly distributed to LP users through an airdrop.
## BOOST
#### Boost Effect
Boost is an additional reward provided to users who wish to grow with the platform in the long term. By default, the veSEILOR obtained in Farming is in an unlocked state, and its APY is the initial APY. When a user sets their Boost level to Restart, the APY yield will be effective after the transaction, and the subsequent reward APY will be the sum of (Boost + Base) APY. And at this time, veSEILOR cannot be claimed, including unclaimed rewards, and future rewards.\
\
Only when the corresponding lock-up period is reached, all rewarded veSEILOR can be claimed. Boost rewards come from the allocation of additional mining rewards and also from the allocated 35% total rewards.
#### Boost Restart
By default, the initial state is non-Boost, and the veSEILOR obtained from mining can be claimed at any time. Once a user chooses to activate Boost, the veSEILOR earned from mining will only be claimable after the corresponding lock-up period. After Boost is activated, users can Restart Boost to a higher level at any time. The lock-up period will still be based on the initial Boost activation time, with the end time being the user's latest selected lock-up period. After a lock-up period ends, users can claim their veSEILOR at any time, and they will automatically transition to a non-Boost state.
## Vest
The user receives the initial reward as veSEILOR, which is escrowed SEILOR and has a 1:1 exchange with SEILOR. veSEILOR holds voting governance rights and captures protocol value and other benefits. The veSEILOR vesting period is currently set to 30 days for SEILOR (this parameter can be modified through governance in the future).
# Convert
The Kryptonite Token, SEILOR, was initially issued on the BNB Smart Chain.\
\
BSC SEILOR can be traded on centralized and decentralized exchanges and transferred between users. However, it cannot participate in the core operations of Kryptonite. And as a result, Kryptonite introduced the Convert feature. Users can initiate a Burn contract transaction on the BNB Smart Chain, and the Dapp will automatically fill in the user's Sei wallet address and submit it to the BSC network. Once the Burn transaction is confirmed, the corresponding address on the Sei chain will receive an equivalent amount of SEILOR on the Sei chain.
# Governance
Coming soon
# Bridge
Coming soon
# veSEILOR vs SEILOR
### What is SEILOR?
SEILOR is the governance token of the Kryptonite Protocol. The total supply of SEILOR is 1,000,000,000.
The benefits of holding SEILOR include, but are not limited to, the following:
* Governance participation: SEILOR holders can participate in platform governance, including voting rights and the ability to propose changes.
* Value capture: SEILOR holders can share in the value generated by the Kryptonite Protocol, such as fee distributions and other protocol revenues.
* Platform privileges: SEILOR holders are entitled to various privileges provided by the platform, such as access to exclusive events, airdrops, and other incentive programs.
* Voting rights: SEILOR holders can vote on governance proposals, influencing decisions on parameter adjustments, new feature additions, and protocol upgrades.
* Community engagement: SEILOR holders can engage with the community, participate in discussions, provide feedback, and contribute to the growth of the Kryptonite ecosystem.
### veSEILOR
veSEILOR is escrowed SEILOR, and SEILOR holders can convert their SEILOR to veSEILOR at any time. Holding 100,000 veSEILOR allows the address to initiate proposals, and each veSEILOR represents one voting right. veSEILOR is eligible for protocol value capture airdrops, and the vesting period for veSEILOR to convert back to SEILOR is 30 days.
# SEILOR Tokenomics
A total supply of 1,000,000,000 SEILOR tokens has been allocated as follows:
Allocated
Percent
Total supply
Unlocking rules
Community Offering
17.5%
175,000,000
TGE 20% unlocked, 3 month cliff, unlocked 4% every month
Liquidity, MM, Incentives
23%
230,000,000
TGE 30% unlocked, 2 month cliff, unlocked 5% every month
Mining Rewards
35%
350,000,000
Distributed in batches according to Staking activities
Team
20%
200,000,000
TGE 0% unlocked, 12 month cliff, unlocked 10% every month
Partners & Advisors
4.5%
45,000,000
TGE 0% unlocked, 12 month cliff, unlocked 10% every month
TGE TIME: 08/14/2023 10AM(UTC)
# Staking
# Hub
The Hub contract acts as the central hub for all minted stSei. Native Sei tokens received from users are delegated from here, and undelegations from stSei unbond requests are also handled from this contract. Rewards generated from delegations are withdrawn to the Reward contract, later restaking to validators, and update exchange rate.
## Config
Minimum time delay between undelegation batches [seconds]
underlying_coin_denom
String
Underlying asset denomination of stAsset (Sei)
unbonding_period
u64
Time required for the Hub contract to consider an undelegation batch to be fully undelegated (past the unbonding period) [seconds]
peg_recovery_fee
Decimal
Fee applied to stSei generation and redemption
er_threshold
Decimal
Minimum stSei exchange rate before peg recovery fee is applied
reward_denom
String
Native token denomination for distributed bSei rewards (kUSD)
paused
Option<bool>
The pause system operation switch to facilitate smooth contract upgrades and data migration
## InitMsg
Instantiates the stSei Hub contract. Adds a specified validator to whitelist and bonds the creator's initial Sei deposit. The creator's initial Sei deposit ensures the stSei supply always be a high enough value to prevent rounding errors in the stSei exchange rate calculation.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct InstantiateMsg {
pub epoch_period: u64,
pub underlying_coin_denom: String,
pub unbonding_period: u64,
pub peg_recovery_fee: Decimal,
pub er_threshold: Decimal,
pub reward_denom: String,
pub update_reward_index_addr: String,
}
```
Key
Type
Description
epoch_period
u64
Minimum time delay between undelegation batches [seconds]
underlying_coin_denom
String
Underlying asset denomination of stAsset (Sei)
unbonding_period
u64
Time required for the Hub contract to consider an undelegation batch to be fully undelegated (past the unbonding period) [seconds]
peg_recovery_fee
Decimal
Fee applied to stSei generation and redemption
er_threshold
Decimal
Minimum stSei exchange rate before peg recovery fee is applied
reward_denom
String
Native token denomination for distributed bSei rewards (kUSD)
update_reward_index_addr
String
The address allowed to call UpdateGlobalIndex
## ExecuteMsg
### Receive
Can be called during a Cw20 token transfer when the Hub contract is the recipient. Allows the token transfer to execute a [Receive Hook ](#receive-hooks)as a subsequent action within the same transaction.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
Receive {
sender: String,
amount: Uint128,
msg: Binary,
},
}
```
### BondForStSei
Bonds sei by delegating the sei amount equally between validators from the registry and mints stSei tokens to the message sender. Requires native Sei tokens to be sent to `Hub`.
The platform tries to distribute the stake evenly across all validators. Given a single delegation, the exact number of validators that will receive delegations and the amount that they will receive depends on the current distribution of stake. We take a sorted (ASC) list of validators, calculate the desired amount that each validator should have `target_stake = (total delegated + delegation_amount) / num_validators` and begin adding stake up to the desired amount, starting from the validator with the least stake. The exact amount of a single delegation is calculated as `target_stake - validator_stake`, and you'll have as many delegations as it takes to "drain" the delegation\_amount.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
BondForStSei {},
}
```
| Key | Type | Description |
| --- | ---- | ----------- |
| | | |
| | | |
| | | |
### UpdateGlobalIndex
Distributes Sei delegation rewards to stSei holders. Withdraws all accrued delegation rewards to the `Reward Dispatcher` contract and requests the `Reward` contract to update the global reward index value. Can be issued by the specific address .
### \[Internal] RedelegateProxy
A proxy handler to execute redelegations from Hub address.
Can only be executed by[ Validators Registry ](broken://pages/H9GEC0vUwikX9a1gs9rj)or by the owner of the Hub.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
RedelegateProxy {
// delegator is automatically set to address of the calling contract
src_validator: String,
redelegations: Vec<(String, Coin)>, //(dst_validator, amount)
},
}
```
Key
Type
Description
src_validator
String
Address of source vaildator in redelegation pair
redelegations
Vec<(String, Coin)>
List of(destination validator, redelegation amount)
### \[Internal] BondRewards
Bonds sei by delegating the sei amount equally between validators from the registry.
No stSei tokens have been minted.
Can only be executed by [Rewards Dispatcher](broken://pages/bwqK9e6KOfutHx5u0qK4).
Requires native Sei tokens to be sent to `Hub`.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
BondRewards {},
}
```
| Key | Type | Description |
| --- | ---- | ----------- |
| | | |
| | | |
| | | |
## Receive Hooks
### Unbond
Burns received stSei and equally unbonds a corresponding amount of Sei from a validator from the registry.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum Cw20HookMsg {
Unbond {},
}
```
| Key | Type | Description |
| --- | ---- | ----------- |
| | | |
| | | |
| | | |
## QueryMsg
### Config
Gets the `Hub` contract's configuration.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
Config {},
}
```
| Key | Type | Description |
| --- | ---- | ----------- |
| | | |
| | | |
| | | |
### ConfigResponse
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct ConfigResponse {
pub owner: String,
pub update_reward_index_addr: String,
pub reward_dispatcher_contract: Option,
pub validators_registry_contract: Option,
pub bsei_token_contract: Option,
pub stsei_token_contract: Option,
pub airdrop_registry_contract: Option,
// #[deprecated]
pub token_contract: Option,
}
```
Amount of (fee-applied)bSei requested for undelegation in this batch
requested_stsei
Uint128
Amount of stSei requested for undelegation in this batch
### WithdrawableUnbonded
Gets the amount of undelegated Sei that will be available for withdrawal (unbonding requests past the unbonding period) for the specified user.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
WithdrawableUnbonded {
address: String,
},
}
```
Key
Type
Description
address
String
Address of user that previously unbonded Sei via redeeming bSei
Unix block timestamp when this batch was undelegated
bsei_amount
Uint128
(Fee-applied)amount of bSei unbonded in this batch
bsei_applied_exchange_rate
Decimal
bSei exchange rate at the time of batch undelegation
bsei_withdraw_rate
Decimal
Conversion rate applied when users later withdraw from this batch
stsei_amount
Uint128
(Fee-applied)amount of stSei unbonded in this batch
stsei_applied_exchange_rate
Decimal
stSei exchange rate at the time of batch undelegation
stsei_withdraw_rate
Decimal
Convertion rate applied when users later withdraw from this batch
released
bool
Indication on whether is batch is released(processed as fully undelegated by the contract)
# Reward
The Reward contract contains the logic for distributing Sei delegation rewards to holders of stSei. After the Hub contract withdraws Sei delegation rewards to the Reward contract, the Hub contract can request all rewards to be redelegated, which then updates the stSei vs Sei exchange rate.
## Config
The supported swap denoms type is configured as "usei"
## ExecuteMsg
### ClaimRewards
Claims bSei holder's accrued rewards to the specified address. Sends rewards to the message sender if the `recipient` is not specified.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
/// return the accrued reward in uusd to the user.
ClaimRewards { recipient: Option },
}
```
\* = optional
### SetOwner
Transfer ownership permissions to a new owner address.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
SetOwner {
new_owner_addr: String,
},
}
```
Key
Type
Description
new_owner_addr
String
The address of new owner
### AcceptOwnership
The new owner accepts ownership permissions.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
AcceptOwnership {},
}
```
### \[Internal] SwapToRewardDenom
Swaps all withdrawn delegation rewards to `reward_denom`. Can only be issued by the `Hub`
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
SwapToRewardDenom {},
}
```
| Key | Type | Desciption |
| --- | ---- | ---------- |
| | | |
### \[Internal] UpdateGlobalIndex
Updates the global reward index based on the newly withdrawn rewards. Can only be issued by the [Rewards Dispatcher](broken://pages/bwqK9e6KOfutHx5u0qK4)
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
UpdateGlobalIndex {},
}
```
Key
Type
Description
### \[Internal] IncreaseBalance
Increases stored user's bSei balance. Stores the user's accrued rewards to pending rewards and updates user's reward index to the current global reward index. Can only be issued by the `Token`.
### \[Internal] DecreaseBalance
Decreases stored user's bSei balance. Stores the user's accrued rewards to pending rewards and updates user's reward index to the current global reward index. Can only be issued by the `Token`.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
DecreaseBalance {
address: String,
amount: Uint128
},
}
```
Key
Type
Description
address
String
Address of user whose balance has decreased
amount
Uint128
Amount of bINJ balance decreased
### UpdateSwapDenom
Add or remove Native token denomination types supported by the [Swap Extension](broken://pages/aecTtgcR55hEz3feD4Y6).
# Rewards Dispatcher
The Rewards Dispatcher contract accumulates the rewards from Hub's delegations and manages the rewards.
All rewards from *stSei* tokens (the share of all rewards proportional to the amount of *stSei* tokens minted) are converted to Luna and are re-delegated back to the validators pool.
All rewards from *bSei* (the share of all rewards proportional to the amount of *bSei* tokens minted) are sent to the Reward Contract and handled the old way.
## Config
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Config {
pub owner: CanonicalAddr,
pub hub_contract: CanonicalAddr,
pub bsei_reward_contract: CanonicalAddr,
pub stsei_reward_denom: String,
pub bsei_reward_denom: String,
pub krp_keeper_address: CanonicalAddr,
pub krp_keeper_rate: Decimal,
pub swap_contract: CanonicalAddr,
pub swap_denoms: Vec,
pub oracle_contract: CanonicalAddr,
}
```
## ExecuteMsg
### \[Internal] SwapToRewardDenom
Swaps all native tokens on his balance to Sei and kUSD proportional to the minted stSei and bSei amount.
Can only be executed by the [Hub](broken://pages/uDcmHmpc0mZMeW8nOOdR).
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
SwapToRewardDenom {
bsei_total_bonded: Uint128,
stsei_total_bonded: Uint128,
},
}
```
Key
Type
Description
bsei_total_bonded
Uint128
Total amount of minted bSei
stsei_total_bonded
Uint128
Total amount of minted stSei
### \[Internal] DispatchRewards
Re-stakes the stSei rewards (with subtracted Fee) and sends the bSei rewards to the old bSei Rewards contract (with subtracted Fee).
Can only be executed by the [Hub](broken://pages/uDcmHmpc0mZMeW8nOOdR).
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
DispatchRewards {},
}
```
### UpdateConfig
Updates the dispatcher's configuration. Can only be executed by the owner.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
UpdateConfig {
hub_contract: Option,
bsei_reward_contract: Option,
stsei_reward_denom: Option,
bsei_reward_denom: Option,
krp_keeper_address: Option,
krp_keeper_rate: Option,
},
}
```
"true" represents "add", and "false" represents "remove"
### UpdateOracleContract
Update the contract address of the [Oracle](broken://pages/GZsWYCeNNKVDvIf1ouxL), which can only be modified by the owner.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
UpdateOracleContract{
oracle_contract: String,
}
}
```
# Validators Registry
The Validator Registry contract stores an approved validators whitelist.
The main query of the contract - [`GetValidatorsForDelegation` ](#getvalidatorsfordelegation)returns a list of approved validators sorted by total\_delegated amount.
The [Hub ](broken://pages/uDcmHmpc0mZMeW8nOOdR)uses this query to equally distribute delegations between validators.
## Config
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Config {
pub owner: CanonicalAddr,
pub hub_contract: CanonicalAddr,
}
```
## ExecuteMsg
### AddValidator
Adds a validator to the registry. Can only be executed by the owner.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
AddValidator { validator: Validator },
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct Validator {
pub address: String,
}
```
Key
Type
Description
validator
Validator
validator struct
Key
Type
Description
address
String
Operator address
### RemoveValidator
Removes a validator from the registry. Can only be executed by the owner.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
RemoveValidator { address: String},
}
```
Key
Type
Description
address
String
Operator address
### UpdateConfig
Updates a registry's configuration. Can only be issued by the owner.
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
UpdateConfig {
hub_contract: Option,
},
}
```
# Tokens: stSei and bSei
stSei and bSei tokens are assets built for the Sei blockchain, their value backed by underlying Sei delegations. stSei and bSei tokens follow full compliance with the CW20 standard, having the potential to be integrated into a wide variety of decentralized finance applications.
## Base
This handles balances and transfers. Note that all amounts are handled as `Uint128` (128 bit integers with JSON string representation). Handling decimals is left to the UI and not interpreted
### Messages
`Transfer{recipient, amount}` - Moves `amount` tokens from the `env.sender` account to the `recipient` account. This is designed to send to an address controlled by a private key and *does not* trigger any actions on the recipient if it is a contract.
`Send{contract, amount, msg}` - Moves `amount` tokens from the `env.sender` account to the `recipient` account. `contract` must be an address of a contract that implements the `Receiver` interface. The `msg` will be passed to the recipient contract, along with the amount.
`Burn{amount}` - Remove `amount` tokens from the balance of `env.sender` and reduce `total_supply` by the same amount.
### Queries
`Balance{address}` - Returns the balance of the given address. Returns "0" if the address is unknown to the contract. Return type is `BalanceResponse{balance}`.
`TokenInfo{}` - Returns the token info of the contract. Return type is `TokenInfoResponse{name, symbol, decimal, total_supply}`.
### Receiver
The counter-part to `Send` is `Receive`, which must be implemented by any contract that wishes to manage CW20 tokens. This is generally *not* implemented by any CW20 contract.
`Receive{sender, amount, msg}` - This is designed to handle `Send` messages. The address of the contract is stored in `env.sender` so it cannot be faked. The contract should ensure the sender matches the token contract it expects to handle, and not allow arbitrary addresses.
The `sender` is the original account requesting to move the tokens and `msg` is a `Binary` data that can be decoded into a contract-specific message. This can be empty if we have only one default action, or it may be a `ReceiveMsg` variant to clarify the intention. For example, if I send to a uniswap contract, I can specify which token I want to swap against using this field.
## Allowances
A contract may allow actors to delegate some of their balance to other accounts. This is not as essential as with ERC20 as we use `Send`/`Receive` to send tokens to a contract, not `Approve`/`TransferFrom`. But it is still a nice use-case, and you can see how the Cosmos SDK wants to add payment allowances to native tokens. This is mainly designed to provide access to other public-key-based accounts.
There was an issue with race conditions in the original ERC20 approval spec. If you had an approval of 50 and I then want to reduce it to 20, I submit a Tx to set the allowance to 20. If you see that and immediately submit a tx using the entire 50, you then get access to the other 20. Not only did you quickly spend the 50 before I could reduce it, you get another 20 for free.
The solution discussed in the Ethereum community was an `IncreaseAllowance` and `DecreaseAllowance` operator (instead of `Approve`). To originally set an approval, use `IncreaseAllowance`, which works fine with no previous allowance. `DecreaseAllowance` is meant to be robust, that is if you decrease by more than the current allowance (eg. the user spent some in the middle), it will just round down to 0 and not make any underflow error.
### Messages
`IncreaseAllowance{spender, amount, expires}` - Set or increase the allowance such that `spender` may access up to `amount + current_allowance` tokens from the `env.sender` account. This may optionally come with an `Expiration` time, which if set limits when the approval can be used (by time or height).
`DecreaseAllowance{spender, amount, expires}` - Decrease or clear the allowance such that `spender` may access up to `current_allowance - amount` tokens from the `env.sender` account. This may optionally come with an `Expiration` time, which if set limits when the approval can be used (by time or height). If `amount >= current_allowance`, this will clear the allowance (delete it).
`TransferFrom{owner, recipient, amount}` - This makes use of an allowance and if there was a valid, un-expired pre-approval for the `env.sender`, then we move `amount` tokens from `owner` to `recipient` and deduct it from the available allowance.
`SendFrom{owner, contract, amount, msg}` - `SendFrom` is to `Send`, what `TransferFrom` is to `Transfer`. This allows a pre-approved account to not just transfer the tokens, but to send them to another contract to trigger a given action. **Note** `SendFrom` will set the `Receive{sender}` to be the `env.sender` (the account that triggered the transfer) rather than the `owner` account (the account the money is coming from). This is an open question whether we should switch this?
`BurnFrom{owner, amount}` - This works like `TransferFrom`, but burns the tokens instead of transfering them. This will reduce the owner's balance, `total_supply` and the caller's allowance.
### Queries
`Allowance{owner, spender}` - This returns the available allowance that `spender` can access from the `owner`'s account, along with the expiration info. Return type is `AllowanceResponse{balance, expiration}`.
## Mintable
This allows another contract to mint new tokens, possibly with a cap. There is only one minter specified here, if you want more complex access management, please use a multisig or other contract as the minter address and handle updating the ACL there.
### Messages
`Mint{recipient, amount}` - If the `env.sender` is the allowed minter, this will create `amount` new tokens (updating total supply) and add them to the balance of `recipient`, as long as it does not exceed the cap.
### Queries
`Minter{}` - Returns who and how much can be minted. Return type is `MinterResponse {minter, cap}`. Cap may be unset.
If the cap is set, it defines the maximum `total_supply` that may ever exist. If initial supply is 1000 and cap is `Some(2000)`, you can only mint 1000 more tokens. However, if someone then burns 500 tokens, the minter can mint those 500 again. This allows for dynamic token supply within a set of parameters, especially when the minter is a smart contract.
## Enumerable
This should be enabled with all blockchains that have iterator support. It allows us to get lists of results with pagination.
## Marketing
This allows us to attach more metadata on the token to help with displaying the token in wallets. When you see a token's website, then see it in a wallet, you know what it is. However, if you see it in a wallet or a DEX trading pair, there is no clear way to find out any more info about it.
This extension allows us to attach more "Marketing" metadata, which has no effect on the on-chain functionality of the token, but is very useful in providing a better client-side experience. Note, that we add a new role `marketing`, which can update such info, but not affect on-chain logic.
### Messages
`UploadLogo{url | embedded}` - If the `env.sender` is the allowed marketing account, this will either set a new URL reference where the logo is served, or allow them to upload a small (less than 5KB) SVG or PNG logo onto the blockchain to be served.
`UpdateMarketing{project, description, marketing}` - If the `env.sender` is the allowed marketing account, this will update some marketing-related metadata on the contract.
### Queries
`MarketingInfo{}` - Returns marketing-related metadata. Return type is `MarketingInfoResponse {project, description, logo, marketing}`.
`DownloadLogo{}` - If the token's logo was previously uploaded to the blockchain (see `UploadLogo` message), then it returns the raw data to be displayed in a browser. Return type is `DownloadLogoResponse{ mime_type, data }`.
### Queries
`AllAllowances{owner, start_after, limit}` - Returns the list of all non-expired allowances by the given owner. `start_after` and `limit` provide pagination.
`AllAccounts{start_after, limit}` - Returns the list of all accounts that have been created on the contract (just the addresses). `start_after` and `limit` provide pagination.
# SEILOR Token
# Boost
veSEILOR holders receive a varied percentage of yield boost depending on the lock-up length.
## Config
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct BoostConfig {
pub gov: Addr,
pub ve_seilor_lock_settings: Vec,
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct VeSeilorLockSetting {
pub duration: Uint128,
pub mining_boost: Uint128,
}
```
Return true or false.
# Seilor
Kryptonite is an open-source Decentralized Autonomous Organization (DAO) project. It is governed by individuals worldwide who hold its governance token, SEILOR. Through a governance system that includes Executive Voting and Governance Polling, SEILOR holders can influence the protocol's direction. The SEILOR token is the native token of the kryptonite Protocol, providing essential functionalities such as staking, governance, minting, and liquidator rewards. SEILOR is an ERC-20 governance token with a maximum supply of 100,000,000. SEILOR holders manage the kryptonite Protocol and oversee the financial risks associated with kUSD to ensure stability, transparency, and efficiency. The voting weight of SEILOR is proportional to the amount staked by a voter in the voting contract. In other words, the more SEILOR tokens locked in the contract, the greater the voter's decision-making power.
## Config
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct SeilorConfig {
pub max_supply: u128,
pub fund: Addr,
pub gov: Addr,
pub distribute: Addr,
pub new_gov: Option,
pub cross_chain_swap_contract: Option,
}
```
### Mint
Only with the "mintable" extension. If authorized, creates amount new tokens and adds to the recipient balance.
```rust
#[cw_serde]
pub enum ExecuteMsg {
Mint {
recipient: String,
amount: Uint128
}
}
```
```json
{
"mint": {
"recipient": "sei...",
"amount": "100000000000000000000000000"
}
}
```
Key
Type
Description
recipient
String
Recipient's address
amount
Uint128
Amount to be minted
### Burn
Burn is a base message to destroy tokens forever
```rust
#[cw_serde]
pub enum ExecuteMsg {
Burn {
amount: Uint128
}
}
```
```json
{
"burn": {
"amount": "100000000000000000000000000"
}
}
```
Key
Type
Description
amount
Uint128
Amount to be burned
### Transfer
Transfer is a base message to move tokens to another account without triggering actions
```rust
#[cw_serde]
pub enum ExecuteMsg {
Transfer {
recipient: String,
amount: Uint128
}
}
```
```json
{
"transfer": {
"recipient": "sei...",
"amount": "100000000000000000000000000"
}
}
```
Key
Type
Description
recipient
String
Recipient's address
amount
Uint128
Amount to be transfered
### Send
Send is a base message to transfer tokens to a contract and trigger an action on the receiving contract.
```rust
#[cw_serde]
pub enum ExecuteMsg {
Send {
contract: String,
amount: Uint128,
msg: Binary
}
}
```
```json
{
"send": {
"contract": "sei...",
"amount": "100000000000000000000000000",
"msg": "eyJh..."
}
}
```
Key
Type
Description
contract
String
The contract to be trigger on action
amount
Uint128
Amount to be transfered
msg
Binary
Message to be sent
### IncreaseAllowance
Only with "approval" extension. Allows spender to access an additional amount tokens from the owner's (env.sender) account. If expires is Some(), overwrites current allowance expiration with this one.
```rust
#[cw_serde]
pub enum ExecuteMsg {
IncreaseAllowance {
spender: String,
amount: Uint128,
expires: Option
}
}
```
```json
{
"increase_allowance": {
"spender": "sei...",
"amount": "100000000000000000000000000",
"expires": null
}
}
```
Key
Type
Description
spender
String
The spender's address
amount
Uint128
Amount to increase for allowance
expires*
Expiration
Expiration time
\* = optional
### DecreaseAllowance
Only with "approval" extension. Lowers the spender's access of tokens from the owner's (env.sender) account by amount. If expires is Some(), overwrites current allowance expiration with this one.
```rust
#[cw_serde]
pub enum ExecuteMsg {
DecreaseAllowance {
spender: String,
amount: Uint128,
expires: Option
}
}
```
```json
{
"decrease_allowance": {
"spender": "sei...",
"amount": "100000000000000000000000000",
"expires": null
}
}
```
### UpdateMinter
Only with the "mintable" extension. The current minter may set a new minter. Setting the minter to None will remove the token's minter forever.
```rust
#[cw_serde]
pub enum ExecuteMsg {
UpdateMinter {
minter: Option
}
}
```
```json
{
"update_minter": {
"minter": null
}
}
```
Key
Type
Description
minter*
String
The new miner's address
\* = optional
### UpdateMarketing
Only with the "marketing" extension. If authorized, updates marketing metadata. Setting None/null for any of these will leave it unchanged. Setting Some("") will clear this field on the contract storage
```rust
#[cw_serde]
pub enum ExecuteMsg {
UpdateMarketing {
project: Option,
description: Option,
marketing: Option,
}
}
```
```json
{
"update_marketing": {
"project": null,
"description": null,
"marketing": null
}
}
```
Key
Type
Description
project*
String
Project name
description*
String
Project description
marketing*
String
Marketing URL
\* = optional
### UploadLogo
If set as the "marketing" role on the contract, upload a new URL, SVG, or PNG for the token
```rust
#[cw_serde]
pub enum ExecuteMsg {
UploadLogo {
logo: String
}
}
```
```json
{
"upload_logo": {
"logo": "https://..."
}
}
```
### Allowance
Only with "allowance" extension. Returns how much spender can use from owner account, 0 if unset. Return type: AllowanceResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
Allowance {
owner: String,
spender: String
}
}
```
```json
{
"allowance": {
"owner": "sei...",
"spender": "sei..."
}
}
```
Key
Type
Description
owner
String
The owner's address
spender
String
The spender's address
### AllowanceResponse
```rust
#[cw_serde]
pub struct AllowanceResponse {
pub allowance: Uint128,
pub expires: Expiration,
}
#[cw_serde]
#[derive(Copy)]
pub enum Expiration {
/// AtHeight will expire when `env.block.height` >= height
AtHeight(u64),
/// AtTime will expire when `env.block.time` >= time
AtTime(Timestamp),
/// Never will never expire. Used to express the empty variant
Never {},
}
```
```json
{
"allowance": "100000000000000000000000000",
"expires": {
"at_height": "0",
"at_time": "0",
"never": {}
}
}
```
Key
Type
Description
allowance
Uint128
The amount allowed to be spent by spender
expires
Expiration
Expiration time
Key
Type
Description
at_height
u64
AtHeight will expire when env.block.height >= height
at_time
Timestamp
AtTime will expire when env.block.time >= time
never
Never will never expire. Used to express the empty variant
### Minter
Only with "mintable" extension. Returns who can mint and the hard cap on maximum tokens after minting. Return type: MinterResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
Minter {}
}
```
```json
{
"minter": {}
}
```
### MinterResponse
```rust
#[cw_serde]
pub struct MinterResponse {
pub minter: Addr,
pub cap: Option,
}
```
```json
{
"minter": "sei...",
"cap": "100000000000000000000000000"
}
```
Key
Type
Description
minter
Addr
the minter's address
cap*
Uint128
cap is a hard cap on total supply that can be achieved by minting. Note that this refers to total_supply. If None, there is unlimited cap.
\* = optional
### MarketingInfo
Only with "marketing" extension Returns more metadata on the contract to display in the client:
description, logo, project url, etc. Return type: MarketingInfoResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
MarketingInfo {}
}
```
```json
{
"marketing_info": {}
}
```
### MarketingInfoResponse
```rust
#[cw_serde]
pub struct MarketingInfoResponse {
/// A URL pointing to the project behind this token.
pub project: Option,
/// A longer description of the token and it's utility. Designed for tooltips or such
pub description: Option,
/// A link to the logo, or a comment there is an on-chain logo stored
pub logo: Option,
/// The address (if any) who can update this data structure
pub marketing: Option,
}
```
```json
{
"project": "https://...",
"description": "Ku...",
"logo": {
"url": "logo",
"embedded": "iVBORw0KGgoAAAANSUhEUgAA..."
},
"marketing": "sei..."
}
```
Key
Type
Description
project*
String
A URL pointing to the project behind this token.
description*
String
A longer description of the token and it's utility. Designed for tooltips or such
logo*
String
A link to the logo, or a comment there is an on-chain logo stored
marketing*
Addr
The address (if any) who can update this data structure
### DownLoadLogo
Only with "marketing" extension Downloads the embedded logo data (if stored on chain). Errors if no logo data stored for this contract. Return type: DownloadLogoResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
DownloadLogo {}
}
```
```json
{
"download_logo": {}
}
```
### DownloadLogoResponse
When we download an embedded logo, we get this response type. We expect a SPA to be able to accept this info and display it.
```rust
#[cw_serde]
pub struct DownloadLogoResponse {
/// The mime type of the image
pub mime_type: String,
/// The raw bytes of the image
pub data: Binary,
}
```
```json
{
"mime_type": "image/png",
"data": "iVBORw0KGgoAAAANSUhEUgAA..."
}
```
Key
Type
Description
mime_type
String
The mime type of the image
data
Binary
The raw bytes of the image
### AllAllowances
Only with "enumerable" extension (and "allowances") Returns all allowances this owner has approved. Supports pagination. Return type: AllAllowancesResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
AllAllowances {
owner: String,
start_after: Option,
limit: Option,
}
}
```
```json
{
"all_allowances": {
"owner": "sei...",
"start_after": "sei...",
"limit": 10
}
}
```
The amount of tokens the spender is allowed to spend
expires
Expiration
When the allowance expires
### AllAccounts
Only with "enumerable" extension Returns all accounts that have balances. Supports pagination. Return type: AllAccountsResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
AllAccounts {
start_after: Option,
limit: Option,
}
}
```
```json
{
"all_accounts": {
"start_after": "sei...",
"limit": 10
}
}
```
Key
Type
Description
start_after*
String
The address to start after, used for pagination
limit*
u32
The number of accounts to limit the query to
\* = optional
# Staking
Lock LP tokens to obtain veSEILOR tokens. The total amount of rewards is determined based on the configuration of this contract and the boost locking time. LP tokens can be withdrawn in advance, but the rewards cannot be withdrawn until they expire according to the lock.
## Config
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct StakingConfig {
pub gov: Addr,
// Immutable variables for staking and rewards tokens
pub staking_token: Addr,
pub rewards_token: Addr,
pub boost: Addr,
pub fund: Addr,
pub reward_controller_addr: Addr,
pub new_gov: Option,
}
```
# Ve Seilor
veSEILOR is escrowed SEILOR. It has the same value as SEILOR and is subject to the total supply of SEILOR. veSEILOR cannot be traded or transferred but has voting rights and can share in protocol earnings. Mining rewards are the primary source of veSEILOR. veSEILOR holders can convert their veSEILOR to SEILOR through a vesting process. Once the process is started, veSEILOR will be linearly converted to SEILOR over a period of 30 days.
## Config
```rust
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct VoteConfig {
pub max_supply: u128,
pub fund: Addr,
pub gov: Addr,
pub max_minted: Uint128,
pub total_minted: Uint128,
pub new_gov: Option,
}
```
### SetMinters
Updates the minters of the contract. Can only be issued by the gov address.
```rust
#[cw_serde]
pub enum ExecuteMsg {
SetMinters {
contracts: Vec,
is_minter: Vec
}
}
```
```json
{
"set_minters": {
"contracts": [
"sei1..."
],
"is_minter": [
true
]
}
}
```
Key
Type
Description
contracts
Vec<Addr>
List of contracts to be updated
is_minter
Vec<bool>
List of corresponding mint permissions
### Mint
Mints veSEILOR. Can only be issued by the mint permissions.
```rust
#[cw_serde]
pub enum ExecuteMsg {
Mint {
recipient: String,
amount: Uint128,
}
}
```
```json
{
"mint": {
"recipient": "sei1...",
"amount": "650000000000000"
}
}
```
Key
Type
Description
recipient
String
Recipient's address
amount
Uint128
Amount of veSEILOR to mint
### Burn
Burns veSEILOR. Can only be issued by the mint permissions.
```rust
#[cw_serde]
pub enum ExecuteMsg {
Burn {
user: String,
amount: Uint128,
}
}
```
```json
{
"burn": {
"user": "sei1...",
"amount": "650000000000000"
}
}
```
Key
Type
Description
user
String
The user address for veSEILOR to be burned
amount
Uint128
The amount of veSEILOR to be burned
### UpdateMarketing
Only with the "marketing" extension. If authorized, updates marketing metadata. Setting None/null for any of these will leave it unchanged. Setting Some("") will clear this field on the contract storage
```rust
#[cw_serde]
pub enum ExecuteMsg {
UpdateMarketing {
project: Option,
description: Option,
marketing: Option,
}
}
```
```json
{
"update_marketing": {
"project": null,
"description": null,
"marketing": null
}
}
```
Key
Type
Description
project*
String
Project name
description*
String
Project description
marketing*
String
Marketing URL
### UploadLogo
If set as the "marketing" role on the contract, upload a new URL, SVG, or PNG for the token
```rust
#[cw_serde]
pub enum ExecuteMsg {
UploadLogo {
logo: String
}
}
```
```json
{
"upload_logo": {
"logo": "https://..."
}
}
```
The balance of SEILOR tokens for the queried user's address.
### TokenInfo
Returns metadata on the contract - name, decimals, supply, etc. Return type: TokenInfoResponse
```rust
#[cw_serde]
pub enum QueryMsg {
TokenInfo {}
}
```
```json
{
"token_info": {}
}
```
### TokenInfoResponse
```rust
#[cw_serde]
pub struct TokenInfoResponse {
pub name: String,
pub symbol: String,
pub decimals: u8,
pub total_supply: Uint128,
}
```
```json
{
"name": "SEILOR",
"symbol": "SEILOR",
"decimals": 18,
"total_supply": "100000000000000000000000000"
}
```
### Minter
Only with "mintable" extension. Returns who can mint and the hard cap on maximum tokens after minting. Return type: MinterResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
Minter {}
}
```
```json
{
"minter": {}
}
```
### MinterResponse
```rust
#[cw_serde]
pub struct MinterResponse {
pub minter: Addr,
pub cap: Option,
}
```
```json
{
"minter": "sei...",
"cap": "100000000000000000000000000"
}
```
Key
Type
Description
minter
Addr
the minter's address
cap*
Uint128
cap is a hard cap on total supply that can be achieved by minting. Note that this refers to total_supply. If None, there is unlimited cap.
### AllAccounts
Only with "enumerable" extension Returns all accounts that have balances. Supports pagination. Return type: AllAccountsResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
AllAccounts {
start_after: Option,
limit: Option,
}
}
```
```json
{
"all_accounts": {
"start_after": "sei...",
"limit": 10
}
}
```
Key
Type
Description
start_after*
String
The address to start after, used for pagination
limit*
u32
The number of accounts to limit the query to
\* = optional
### MarketingInfo
Only with "marketing" extension Returns more metadata on the contract to display in the client:
description, logo, project url, etc. Return type: MarketingInfoResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
MarketingInfo {}
}
```
```json
{
"marketing_info": {}
}
```
### MarketingInfoResponse
```rust
#[cw_serde]
pub struct MarketingInfoResponse {
/// A URL pointing to the project behind this token.
pub project: Option,
/// A longer description of the token and it's utility. Designed for tooltips or such
pub description: Option,
/// A link to the logo, or a comment there is an on-chain logo stored
pub logo: Option,
/// The address (if any) who can update this data structure
pub marketing: Option,
}
```
```json
{
"project": "https://...",
"description": "Ku...",
"logo": {
"url": "logo",
"embedded": "iVBORw0KGgoAAAANSUhEUgAA..."
},
"marketing": "sei..."
}
```
Key
Type
Description
project*
String
A URL pointing to the project behind this token.
description*
String
A longer description of the token and it's utility. Designed for tooltips or such
logo*
String
A link to the logo, or a comment there is an on-chain logo stored
marketing*
Addr
The address (if any) who can update this data structure
### DownLoadLogo
Only with "marketing" extension Downloads the embedded logo data (if stored on chain). Errors if no logo data stored for this contract. Return type: DownloadLogoResponse.
```rust
#[cw_serde]
pub enum QueryMsg {
DownloadLogo {}
}
```
```json
{
"download_logo": {}
}
```
### DownloadLogoResponse
When we download an embedded logo, we get this response type. We expect a SPA to be able to accept this info and display it.
```rust
#[cw_serde]
pub struct DownloadLogoResponse {
/// The mime type of the image
pub mime_type: String,
/// The raw bytes of the image
pub data: Binary,
}
```
```json
{
"mime_type": "image/png",
"data": "iVBORw0KGgoAAAANSUhEUgAA..."
}
```
### ChangeOwner
Change the contract owner, only can issued by current owner.
```rust
#[cw_serde]
pub enum ExecuteMsg {
ChangeOwner {
new_owner: String,
},
}
```
```json
{
"change_owner": {
"new_owner": "sei...addr..."
}
}
```
Key
Type
Description
new_owner
string
The address of the new contract owner.
### SetConfigFeedValid
Set whether the oracle is available, the default is available, the type is bool.
```rust
#[cw_serde]
pub enum ExecuteMsg {
SetConfigFeedValid {
asset: String,
valid: bool,
},
}
```
```
{
"set_config_feed_valid": {
"asset": "factory/sei1h3ukufh4lhacftdf6kyxzum4p86rcnel35v4jk/usdt",
"valid": true
}
}
```
Key
Type
Description
asset
string
The address of the asset
valid
bool
Whether the oracle is available
### ChangePythContract
Change the pyth contract address, only can issued by current owner.
```rust
#[cw_serde]
pub enum ExecuteMsg {
ChangePythContract {
pyth_contract: String,
},
}
```
```
{
"change_pyth_contract": {
"pyth_contract": "sei...addr..."
}
}
```
Key
Type
Description
pyth_contract
String
The pyth contract address
## QueryMsg
All query messages are described below. A custom struct is defined for each query response.
### QueryPrice
Returns the price of the asset.
```rust
#[cw_serde]
#[derive(QueryResponses)]
pub enum QueryMsg {
#[returns(PriceResponse)]
QueryPrice { asset: String },
}
```
```
{
"query_price": {
"asset": "factory/sei1h3ukufh4lhacftdf6kyxzum4p86rcnel35v4jk/usdt"
}
}
```
The address of the contract to receive the swap fees. If not set, use self
\* = optional
### ChangeOwner
Change the contract `owner`.only can issued by current owner.
```rust
#[cw_serde]
pub enum ExecuteMsg {
ChangeOwner {
new_owner: Addr,
},
}
```
```
{
"change_owner": {
"new_owner": "sei...addr..."
}
}
```
Key
Type
Description
new_owner
Addr
The new owner of the contract
### UpdatePairStatus
Update whether the trading pair pool is available, the default is available, the type is bool.
```rust
#[cw_serde]
pub enum ExecuteMsg {
UpdatePairStatus {
asset_infos: [AssetInfo; 2],
is_disabled: bool,
},
}
```
```json
{
"update_pair_status": {
"asset_infos": [
{
"native_token": {
"denom": "usei"
}
},
{
"native_token": {
"denom": "factory/sei1h3ukufh4lhacftdf6kyxzum4p86rcnel35v4jk/usdt"
}
}
],
"is_disabled": false
}
}
```
Key
Type
Description
asset_infos
Pair
Swap the asset pair
is_disabled
bool
The status of the pair
### UpdatePairMaxSpread
Set the maximum spread for a single pool, and use the default value of sparrow swap if it is not set by default
```
#[cw_serde]
pub enum ExecuteMsg {
UpdatePairMaxSpread {
asset_infos: [AssetInfo; 2],
max_spread: Decimal,
},
}
```
```
{
"update_pair_max_spread": {
"asset_infos": [
{
"native_token": {
"denom": "usei"
}
},
{
"native_token": {
"denom": "factory/sei1h3ukufh4lhacftdf6kyxzum4p86rcnel35v4jk/usdt"
}
}
],
"max_spread": 123456
}
}
```
Key
Type
Description
asset_infos
Pair
Swap the asset pair
max_spread
Decimal
The max spread of the pair
### SetWhitelist
To set those addresses you can call the SwapDenom method.
```
#[cw_serde]
pub enum ExecuteMsg {
SetWhitelist {
caller: Addr,
is_whitelist: bool,
},
}
```
```
{
"set_whitelist": {
"caller": "sei...addr...",
"is_whitelist": true
}
}
```
### SimulationResponse
```rust
/// This structure holds the parameters that are returned from a swap simulation response
#[cw_serde]
pub struct SimulationResponse {
/// The amount of ask assets returned by the swap
pub return_amount: Uint128,
/// The spread used in the swap operation
pub spread_amount: Uint128,
/// The amount of fees charged by the transaction
pub commission_amount: Uint128,
}
```
```
{
"return_amount": "123456",
"spread_amount": "123456",
"commission_amount": "123456"
}
```
### ReverseSimulationResponse
```rust
/// This structure holds the parameters that are returned from a reverse swap simulation response.
#[cw_serde]
pub struct ReverseSimulationResponse {
/// The amount of offer assets returned by the reverse swap
pub offer_amount: Uint128,
/// The spread used in the swap operation
pub spread_amount: Uint128,
/// The amount of fees charged by the transaction
pub commission_amount: Uint128,
}
```
```
{
"offer_amount": "123456",
"spread_amount": "123456",
"commission_amount": "123456"
}
```
### CumulativePricesResponse
```rust
/// This structure is used to return a cumulative prices query response.
#[cw_serde]
pub struct CumulativePricesResponse {
/// The two assets in the pool to query
pub assets: [Asset; 2],
/// The total amount of LP tokens currently issued
pub total_share: Uint128,
/// The last value for the token0 cumulative price
pub price0_cumulative_last: Uint128,
/// The last value for the token1 cumulative price
pub price1_cumulative_last: Uint128,
}
```
```json
{
"assets": [
{
"info": {
"native_token": {
"denom": "usei"
}
},
"amount": "123456"
},
{
"info": {
"native_token": {
"denom": "factory/sei1h3ukufh4lhacftdf6kyxzum4p86rcnel35v4jk/usdt"
}
},
"amount": "123456"
}
],
"total_share": "123456",
"price0_cumulative_last": "123456",
"price1_cumulative_last": "123456"
}
```
# Pool2 Farming
### Farming Reward
Users can provide liquidity to two pools on Astrosport and obtain LP Tokens for the respective pools. These LP Tokens can be staked in the SEILOR module of the platform to earn veSEILOR.
#### SEI/SEILOR POOL
Reward duration: 30 days.
Total reward amount: 10,000,000 veSEILOR.
#### STSEI/SEIYAN POOL
Reward duration: 30 days.
Total reward amount: 892,800 SEIYAN & 500,000 veSEILOR.
### Farming Contract Addresses
#### [SEI/SEILOR POOL](https://app.astroport.fi/pools/sei13pzdhenzugwa02tm975g2y5kllj26rf4x4ykpqtrfw2h4mcezmmqz06dfr/provide)