{ "contract_name": "dexter-multi-staking", "contract_version": "3.0.0", "idl_version": "1.0.0", "instantiate": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "InstantiateMsg", "type": "object", "required": [ "fee_tier_interval", "instant_unbond_fee_bp", "instant_unbond_min_fee_bp", "keeper_addr", "minimum_reward_schedule_proposal_start_delay", "owner", "unlock_period" ], "properties": { "fee_tier_interval": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "instant_unbond_fee_bp": { "description": "value between 0 and 1000 (0% to 10%) are allowed", "type": "integer", "format": "uint64", "minimum": 0.0 }, "instant_unbond_min_fee_bp": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "keeper_addr": { "$ref": "#/definitions/Addr" }, "minimum_reward_schedule_proposal_start_delay": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "owner": { "$ref": "#/definitions/Addr" }, "unlock_period": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false, "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" } } }, "execute": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "ExecuteMsg", "oneOf": [ { "description": "Allows an admin to update config params", "type": "object", "required": [ "update_config" ], "properties": { "update_config": { "type": "object", "properties": { "fee_tier_interval": { "type": [ "integer", "null" ], "format": "uint64", "minimum": 0.0 }, "instant_unbond_fee_bp": { "type": [ "integer", "null" ], "format": "uint64", "minimum": 0.0 }, "instant_unbond_min_fee_bp": { "type": [ "integer", "null" ], "format": "uint64", "minimum": 0.0 }, "keeper_addr": { "anyOf": [ { "$ref": "#/definitions/Addr" }, { "type": "null" } ] }, "unlock_period": { "type": [ "integer", "null" ], "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Creates a new reward schedule for rewarding LP token holders a specific asset. Asset is distributed linearly over the duration of the reward schedule. This entry point is strictly meant for proposing reward schedules with native tokens. For proposing reward schedules with CW20 tokens, CW20 transfer with CreateRewardSchedule HookMsg is used. Only owner can create a reward schedule proposal.", "type": "object", "required": [ "create_reward_schedule" ], "properties": { "create_reward_schedule": { "type": "object", "required": [ "end_block_time", "lp_token", "start_block_time", "title" ], "properties": { "actual_creator": { "description": "The user on whose behalf the reward schedule might be being created by the owner This is particularly useful for the Gov admin scenario where a user proposes a reward schedule on the chain governance and the gov admin actually creates the reward schedule for the user", "anyOf": [ { "$ref": "#/definitions/Addr" }, { "type": "null" } ] }, "end_block_time": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "lp_token": { "$ref": "#/definitions/Addr" }, "start_block_time": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "title": { "type": "string" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Allows an admin to allow a new LP token to be rewarded This is needed to prevent spam related to adding new reward schedules for random LP tokens", "type": "object", "required": [ "allow_lp_token" ], "properties": { "allow_lp_token": { "type": "object", "required": [ "lp_token" ], "properties": { "lp_token": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": ". Allows an admin to remove an LP token from being rewarded. Existing reward schedules for the LP token will still be valid.", "type": "object", "required": [ "remove_lp_token" ], "properties": { "remove_lp_token": { "type": "object", "required": [ "lp_token" ], "properties": { "lp_token": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Allows the contract to receive CW20 tokens. The contract can receive CW20 tokens from LP tokens for staking and CW20 assets to be used as rewards.", "type": "object", "required": [ "receive" ], "properties": { "receive": { "$ref": "#/definitions/Cw20ReceiveMsg" } }, "additionalProperties": false }, { "description": "Allows to bond LP tokens to the contract. Bonded tokens are eligible to receive rewards.", "type": "object", "required": [ "bond" ], "properties": { "bond": { "type": "object", "required": [ "amount", "lp_token" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "lp_token": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Allows to unbond LP tokens from the contract. After unbonding, the tokens are still locked for a locking period. During this period, the tokens are not eligible to receive rewards. After the locking period, the tokens can be withdrawn.", "type": "object", "required": [ "unbond" ], "properties": { "unbond": { "type": "object", "required": [ "lp_token" ], "properties": { "amount": { "anyOf": [ { "$ref": "#/definitions/Uint128" }, { "type": "null" } ] }, "lp_token": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Instantly unbonds LP tokens from the contract. No locking period is applied. The tokens are withdrawn from the contract and sent to the user. An Instant Unbonding fee is applicable to the amount being unbonded. The fee is calculated as a percentage of the amount being unbonded and sent to the protocol treasury.", "type": "object", "required": [ "instant_unbond" ], "properties": { "instant_unbond": { "type": "object", "required": [ "amount", "lp_token" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "lp_token": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Unlocks the tokens which are locked for a locking period. After unlocking, the tokens are withdrawn from the contract and sent to the user.", "type": "object", "required": [ "unlock" ], "properties": { "unlock": { "type": "object", "required": [ "lp_token" ], "properties": { "lp_token": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Instant unlock is a extension of instant unbonding feature which allows to insantly unbond tokens which are in a locked state post normal unbonding. This is useful when a user mistakenly unbonded the tokens instead of instant unbonding or if a black swan event occurs and the user has the LP tokens in a locked state after unbonding.", "type": "object", "required": [ "instant_unlock" ], "properties": { "instant_unlock": { "type": "object", "required": [ "lp_token", "token_locks" ], "properties": { "lp_token": { "$ref": "#/definitions/Addr" }, "token_locks": { "description": "Altought it is use possible to index or something similar to calculate this, it would lead to problems with order of transaction execution, thus it is better to pass the full lock explicitly.", "type": "array", "items": { "$ref": "#/definitions/TokenLock" } } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Allows to withdraw unbonded rewards for a specific LP token. The rewards are sent to the user's address.", "type": "object", "required": [ "withdraw" ], "properties": { "withdraw": { "type": "object", "required": [ "lp_token" ], "properties": { "lp_token": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Allows a reward schedule creator to claim back amount that was not allocated to anyone since no token were bonded. This can only be claimed after reward schedule expiry", "type": "object", "required": [ "claim_unallocated_reward" ], "properties": { "claim_unallocated_reward": { "type": "object", "required": [ "reward_schedule_id" ], "properties": { "reward_schedule_id": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Allows the owner to transfer ownership to a new address. Ownership transfer is done in two steps: 1. The owner proposes a new owner. 2. The new owner accepts the ownership. The proposal expires after a certain period of time within which the new owner must accept the ownership.", "type": "object", "required": [ "propose_new_owner" ], "properties": { "propose_new_owner": { "type": "object", "required": [ "expires_in", "owner" ], "properties": { "expires_in": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "owner": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Allows the new owner to accept ownership.", "type": "object", "required": [ "claim_ownership" ], "properties": { "claim_ownership": { "type": "object", "additionalProperties": false } }, "additionalProperties": false }, { "description": "Allows the owner to drop the ownership transfer proposal.", "type": "object", "required": [ "drop_ownership_proposal" ], "properties": { "drop_ownership_proposal": { "type": "object", "additionalProperties": false } }, "additionalProperties": false } ], "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" }, "Binary": { "description": "Binary is a wrapper around Vec to add base64 de/serialization with serde. It also adds some helper methods to help encode inline.\n\nThis is only needed as serde-json-{core,wasm} has a horrible encoding for Vec. See also .", "type": "string" }, "Cw20ReceiveMsg": { "description": "Cw20ReceiveMsg should be de/serialized under `Receive()` variant in a ExecuteMsg", "type": "object", "required": [ "amount", "msg", "sender" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "msg": { "$ref": "#/definitions/Binary" }, "sender": { "type": "string" } }, "additionalProperties": false }, "TokenLock": { "type": "object", "required": [ "amount", "unlock_time" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "unlock_time": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false }, "Uint128": { "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" } } }, "query": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "QueryMsg", "oneOf": [ { "description": "Returns current config of the contract", "type": "object", "required": [ "config" ], "properties": { "config": { "type": "object", "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns currently unclaimed rewards for a user for a give LP token If a future block time is provided, it will return the unclaimed rewards till that block time.", "type": "object", "required": [ "unclaimed_rewards" ], "properties": { "unclaimed_rewards": { "type": "object", "required": [ "lp_token", "user" ], "properties": { "block_time": { "type": [ "integer", "null" ], "format": "uint64", "minimum": 0.0 }, "lp_token": { "$ref": "#/definitions/Addr" }, "user": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns current token locks for a user for a given LP token If a future block time is provided, it will return the token locks and unlocked value at that block time based on current unlock period", "type": "object", "required": [ "token_locks" ], "properties": { "token_locks": { "type": "object", "required": [ "lp_token", "user" ], "properties": { "block_time": { "type": [ "integer", "null" ], "format": "uint64", "minimum": 0.0 }, "lp_token": { "$ref": "#/definitions/Addr" }, "user": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns raw state of the token locks for a user for a given LP token It might include the token locks which are already unlocked and won't give the current ideal view of the token locks but the actual one as it is stored in the contract", "type": "object", "required": [ "raw_token_locks" ], "properties": { "raw_token_locks": { "type": "object", "required": [ "lp_token", "user" ], "properties": { "lp_token": { "$ref": "#/definitions/Addr" }, "user": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns the total staked amount for a given LP token", "type": "object", "required": [ "bonded_lp_tokens" ], "properties": { "bonded_lp_tokens": { "type": "object", "required": [ "lp_token", "user" ], "properties": { "lp_token": { "$ref": "#/definitions/Addr" }, "user": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns the current unlocking fee percentage (bp) and actual fee for a given token lock", "type": "object", "required": [ "instant_unlock_fee" ], "properties": { "instant_unlock_fee": { "type": "object", "required": [ "lp_token", "token_lock", "user" ], "properties": { "lp_token": { "$ref": "#/definitions/Addr" }, "token_lock": { "$ref": "#/definitions/TokenLock" }, "user": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "type": "object", "required": [ "instant_unlock_fee_tiers" ], "properties": { "instant_unlock_fee_tiers": { "type": "object", "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns the LP tokens which are whitelisted for rewards", "type": "object", "required": [ "allowed_l_p_tokens_for_reward" ], "properties": { "allowed_l_p_tokens_for_reward": { "type": "object", "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns the current owner of the contract", "type": "object", "required": [ "owner" ], "properties": { "owner": { "type": "object", "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns the reward schedule for a given LP token and a reward asset", "type": "object", "required": [ "reward_schedules" ], "properties": { "reward_schedules": { "type": "object", "required": [ "asset", "lp_token" ], "properties": { "asset": { "$ref": "#/definitions/AssetInfo" }, "lp_token": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns the current reward state for a given LP token and a reward asset", "type": "object", "required": [ "reward_state" ], "properties": { "reward_state": { "type": "object", "required": [ "asset", "lp_token" ], "properties": { "asset": { "$ref": "#/definitions/AssetInfo" }, "lp_token": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns the staking information for a given user based on the last interaction with the contract", "type": "object", "required": [ "staker_info" ], "properties": { "staker_info": { "type": "object", "required": [ "asset", "lp_token", "user" ], "properties": { "asset": { "$ref": "#/definitions/AssetInfo" }, "lp_token": { "$ref": "#/definitions/Addr" }, "user": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Returns the reward that the creator of a reward schedule can claim since no token was bonded in a part of the reward period", "type": "object", "required": [ "creator_claimable_reward" ], "properties": { "creator_claimable_reward": { "type": "object", "required": [ "reward_schedule_id" ], "properties": { "reward_schedule_id": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false } }, "additionalProperties": false } ], "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" }, "AssetInfo": { "description": "This enum describes available Token types.", "oneOf": [ { "description": "Non-native Token", "type": "object", "required": [ "token" ], "properties": { "token": { "type": "object", "required": [ "contract_addr" ], "properties": { "contract_addr": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Native token", "type": "object", "required": [ "native_token" ], "properties": { "native_token": { "type": "object", "required": [ "denom" ], "properties": { "denom": { "type": "string" } }, "additionalProperties": false } }, "additionalProperties": false } ] }, "TokenLock": { "type": "object", "required": [ "amount", "unlock_time" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "unlock_time": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false }, "Uint128": { "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" } } }, "migrate": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "MigrateMsg", "oneOf": [ { "type": "object", "required": [ "v3_from_v2" ], "properties": { "v3_from_v2": { "type": "object", "required": [ "keeper_addr" ], "properties": { "keeper_addr": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "type": "object", "required": [ "v3_from_v2_2" ], "properties": { "v3_from_v2_2": { "type": "object", "additionalProperties": false } }, "additionalProperties": false }, { "description": "Removes the reward schedule proposal start delay config param Instant unbonding fee and keeper address are added", "type": "object", "required": [ "v3_from_v1" ], "properties": { "v3_from_v1": { "type": "object", "required": [ "fee_tier_interval", "instant_unbond_fee_bp", "instant_unbond_min_fee_bp", "keeper_addr" ], "properties": { "fee_tier_interval": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "instant_unbond_fee_bp": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "instant_unbond_min_fee_bp": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "keeper_addr": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false } ], "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" } } }, "sudo": null, "responses": { "allowed_l_p_tokens_for_reward": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "Array_of_Addr", "type": "array", "items": { "$ref": "#/definitions/Addr" }, "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" } } }, "bonded_lp_tokens": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "Uint128", "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" }, "config": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "Config", "type": "object", "required": [ "allowed_lp_tokens", "fee_tier_interval", "instant_unbond_fee_bp", "instant_unbond_min_fee_bp", "keeper", "owner", "unlock_period" ], "properties": { "allowed_lp_tokens": { "description": "LP Token addresses for which reward schedules can be added", "type": "array", "items": { "$ref": "#/definitions/Addr" } }, "fee_tier_interval": { "description": "This is the interval period in seconds on which we will have fee tier boundaries.", "type": "integer", "format": "uint64", "minimum": 0.0 }, "instant_unbond_fee_bp": { "description": "Instant LP unbonding fee. This is the percentage of the LP tokens that will be deducted as fee value between 0 and 1000 (0% to 10%) are allowed", "type": "integer", "format": "uint64", "minimum": 0.0 }, "instant_unbond_min_fee_bp": { "description": "This is the minimum fee charged for instant LP unlock when the unlock time is less than fee interval in future. Fee in between the unlock duration and fee tier intervals will be linearly interpolated at fee tier interval boundaries.", "type": "integer", "format": "uint64", "minimum": 0.0 }, "keeper": { "description": "Keeper address that acts as treasury of the Dexter protocol. All the fees are sent to this address.", "allOf": [ { "$ref": "#/definitions/Addr" } ] }, "owner": { "description": "owner has privilege to add/remove allowed lp tokens for reward", "allOf": [ { "$ref": "#/definitions/Addr" } ] }, "unlock_period": { "description": "Unlocking period in seconds This is the minimum time that must pass before a user can withdraw their staked tokens and rewards after they have called the unbond function", "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false, "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" } } }, "creator_claimable_reward": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "CreatorClaimableRewardState", "type": "object", "required": [ "amount", "claimed", "last_update" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "claimed": { "type": "boolean" }, "last_update": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false, "definitions": { "Uint128": { "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" } } }, "instant_unlock_fee": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "InstantLpUnlockFee", "type": "object", "required": [ "time_until_lock_expiry", "unlock_amount", "unlock_fee", "unlock_fee_bp" ], "properties": { "time_until_lock_expiry": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "unlock_amount": { "$ref": "#/definitions/Uint128" }, "unlock_fee": { "$ref": "#/definitions/Uint128" }, "unlock_fee_bp": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false, "definitions": { "Uint128": { "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" } } }, "instant_unlock_fee_tiers": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "Array_of_UnlockFeeTier", "type": "array", "items": { "$ref": "#/definitions/UnlockFeeTier" }, "definitions": { "UnlockFeeTier": { "type": "object", "required": [ "seconds_till_unlock_end", "seconds_till_unlock_start", "unlock_fee_bp" ], "properties": { "seconds_till_unlock_end": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "seconds_till_unlock_start": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "unlock_fee_bp": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false } } }, "owner": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "Addr", "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" }, "raw_token_locks": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "Array_of_TokenLock", "type": "array", "items": { "$ref": "#/definitions/TokenLock" }, "definitions": { "TokenLock": { "type": "object", "required": [ "amount", "unlock_time" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "unlock_time": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false }, "Uint128": { "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" } } }, "reward_schedules": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "Array_of_RewardScheduleResponse", "type": "array", "items": { "$ref": "#/definitions/RewardScheduleResponse" }, "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" }, "AssetInfo": { "description": "This enum describes available Token types.", "oneOf": [ { "description": "Non-native Token", "type": "object", "required": [ "token" ], "properties": { "token": { "type": "object", "required": [ "contract_addr" ], "properties": { "contract_addr": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Native token", "type": "object", "required": [ "native_token" ], "properties": { "native_token": { "type": "object", "required": [ "denom" ], "properties": { "denom": { "type": "string" } }, "additionalProperties": false } }, "additionalProperties": false } ] }, "RewardSchedule": { "type": "object", "required": [ "amount", "asset", "creator", "end_block_time", "staking_lp_token", "start_block_time", "title" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "asset": { "$ref": "#/definitions/AssetInfo" }, "creator": { "$ref": "#/definitions/Addr" }, "end_block_time": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "staking_lp_token": { "$ref": "#/definitions/Addr" }, "start_block_time": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "title": { "type": "string" } }, "additionalProperties": false }, "RewardScheduleResponse": { "type": "object", "required": [ "id", "reward_schedule" ], "properties": { "id": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "reward_schedule": { "$ref": "#/definitions/RewardSchedule" } }, "additionalProperties": false }, "Uint128": { "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" } } }, "reward_state": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "AssetRewardState", "type": "object", "required": [ "last_distributed", "reward_index" ], "properties": { "last_distributed": { "type": "integer", "format": "uint64", "minimum": 0.0 }, "reward_index": { "$ref": "#/definitions/Decimal" } }, "additionalProperties": false, "definitions": { "Decimal": { "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" } } }, "staker_info": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "AssetStakerInfo", "type": "object", "required": [ "asset", "pending_reward", "reward_index" ], "properties": { "asset": { "$ref": "#/definitions/AssetInfo" }, "pending_reward": { "$ref": "#/definitions/Uint128" }, "reward_index": { "$ref": "#/definitions/Decimal" } }, "additionalProperties": false, "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" }, "AssetInfo": { "description": "This enum describes available Token types.", "oneOf": [ { "description": "Non-native Token", "type": "object", "required": [ "token" ], "properties": { "token": { "type": "object", "required": [ "contract_addr" ], "properties": { "contract_addr": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Native token", "type": "object", "required": [ "native_token" ], "properties": { "native_token": { "type": "object", "required": [ "denom" ], "properties": { "denom": { "type": "string" } }, "additionalProperties": false } }, "additionalProperties": false } ] }, "Decimal": { "description": "A fixed-point decimal value with 18 fractional digits, i.e. Decimal(1_000_000_000_000_000_000) == 1.0\n\nThe greatest possible value that can be represented is 340282366920938463463.374607431768211455 (which is (2^128 - 1) / 10^18)", "type": "string" }, "Uint128": { "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" } } }, "token_locks": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "TokenLockInfo", "type": "object", "required": [ "locks", "unlocked_amount" ], "properties": { "locks": { "type": "array", "items": { "$ref": "#/definitions/TokenLock" } }, "unlocked_amount": { "$ref": "#/definitions/Uint128" } }, "additionalProperties": false, "definitions": { "TokenLock": { "type": "object", "required": [ "amount", "unlock_time" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "unlock_time": { "type": "integer", "format": "uint64", "minimum": 0.0 } }, "additionalProperties": false }, "Uint128": { "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" } } }, "unclaimed_rewards": { "$schema": "http://json-schema.org/draft-07/schema#", "title": "Array_of_UnclaimedReward", "type": "array", "items": { "$ref": "#/definitions/UnclaimedReward" }, "definitions": { "Addr": { "description": "A human readable address.\n\nIn Cosmos, this is typically bech32 encoded. But for multi-chain smart contracts no assumptions should be made other than being UTF-8 encoded and of reasonable length.\n\nThis type represents a validated address. It can be created in the following ways 1. Use `Addr::unchecked(input)` 2. Use `let checked: Addr = deps.api.addr_validate(input)?` 3. Use `let checked: Addr = deps.api.addr_humanize(canonical_addr)?` 4. Deserialize from JSON. This must only be done from JSON that was validated before such as a contract's state. `Addr` must not be used in messages sent by the user because this would result in unvalidated instances.\n\nThis type is immutable. If you really need to mutate it (Really? Are you sure?), create a mutable copy using `let mut mutable = Addr::to_string()` and operate on that `String` instance.", "type": "string" }, "AssetInfo": { "description": "This enum describes available Token types.", "oneOf": [ { "description": "Non-native Token", "type": "object", "required": [ "token" ], "properties": { "token": { "type": "object", "required": [ "contract_addr" ], "properties": { "contract_addr": { "$ref": "#/definitions/Addr" } }, "additionalProperties": false } }, "additionalProperties": false }, { "description": "Native token", "type": "object", "required": [ "native_token" ], "properties": { "native_token": { "type": "object", "required": [ "denom" ], "properties": { "denom": { "type": "string" } }, "additionalProperties": false } }, "additionalProperties": false } ] }, "Uint128": { "description": "A thin wrapper around u128 that is using strings for JSON encoding/decoding, such that the full u128 range can be used for clients that convert JSON numbers to floats, like JavaScript and jq.\n\n# Examples\n\nUse `from` to create instances of this and `u128` to get the value out:\n\n``` # use cosmwasm_std::Uint128; let a = Uint128::from(123u128); assert_eq!(a.u128(), 123);\n\nlet b = Uint128::from(42u64); assert_eq!(b.u128(), 42);\n\nlet c = Uint128::from(70u32); assert_eq!(c.u128(), 70); ```", "type": "string" }, "UnclaimedReward": { "type": "object", "required": [ "amount", "asset" ], "properties": { "amount": { "$ref": "#/definitions/Uint128" }, "asset": { "$ref": "#/definitions/AssetInfo" } }, "additionalProperties": false } } } } }