From 370ade71ffa9257c80214358420612dff016405d Mon Sep 17 00:00:00 2001 From: Bojan Angjelkoski Date: Mon, 21 Oct 2024 16:39:05 +0200 Subject: [PATCH] chore: add modules --- .gitbook/developers/modules.md | 2 - .gitbook/developers/modules/README.md | 22 + .gitbook/developers/modules/core/README.md | 14 + .../developers/modules/core/auth/README.md | 710 ++++ .../developers/modules/core/authz/README.md | 355 ++ .../developers/modules/core/bank/README.md | 1039 ++++++ .../developers/modules/core/circuit/README.md | 170 + .../modules/core/consensus/README.md | 7 + .../developers/modules/core/crisis/README.md | 110 + .../modules/core/distribution/README.md | 1049 ++++++ .../modules/core/evidence/README.md | 440 +++ .../modules/core/feegrant/README.md | 396 +++ .../developers/modules/core/genutil/README.md | 89 + .../developers/modules/core/gov/README.md | 2547 ++++++++++++++ .../developers/modules/core/group/README.md | 2166 ++++++++++++ .../developers/modules/core/mint/README.md | 383 +++ .../developers/modules/core/nft/README.md | 89 + .../developers/modules/core/params/README.md | 79 + .../modules/core/slashing/README.md | 813 +++++ .../developers/modules/core/staking/README.md | 3058 +++++++++++++++++ .../developers/modules/core/upgrade/README.md | 619 ++++ .../developers/modules/injective/README.md | 14 + .../modules/injective/auction/01_state.md | 60 + .../modules/injective/auction/02_messages.md | 32 + .../modules/injective/auction/03_end_block.md | 21 + .../modules/injective/auction/04_events.md | 28 + .../modules/injective/auction/05_params.md | 14 + .../modules/injective/auction/README.md | 15 + .../modules/injective/auction/img.png | Bin 0 -> 198989 bytes .../exchange/00_derivative_market_concepts.md | 244 ++ .../exchange/01_spot_market_concepts.md | 135 + .../exchange/02_binary_options_markets.md | 115 + .../injective/exchange/02_other_concepts.md | 69 + .../modules/injective/exchange/03_state.md | 594 ++++ .../exchange/04_state_transitions.md | 447 +++ .../modules/injective/exchange/05_messages.md | 443 +++ .../injective/exchange/06_proposals.md | 404 +++ .../injective/exchange/07_begin_block.md | 74 + .../injective/exchange/08_end_block.md | 78 + .../modules/injective/exchange/09_events.md | 169 + .../modules/injective/exchange/10_params.md | 35 + .../11_msg_privileged_execute_contract.md | 127 + .../modules/injective/exchange/README.md | 29 + .../modules/injective/insurance/01_state.md | 92 + .../insurance/02_state_transitions.md | 124 + .../injective/insurance/03_messages.md | 95 + .../injective/insurance/04_end_block.md | 8 + .../modules/injective/insurance/05_events.md | 39 + .../modules/injective/insurance/06_params.md | 13 + .../insurance/07_future_improvements.md | 11 + .../modules/injective/insurance/README.md | 19 + .../modules/injective/ocr/01_concepts.md | 60 + .../modules/injective/ocr/02_state.md | 218 ++ .../modules/injective/ocr/03_messages.md | 227 ++ .../modules/injective/ocr/04_proposals.md | 50 + .../modules/injective/ocr/05_begin_block.md | 13 + .../modules/injective/ocr/06_hooks.md | 17 + .../modules/injective/ocr/07_events.md | 102 + .../modules/injective/ocr/08_params.md | 14 + .../modules/injective/ocr/README.md | 21 + .../modules/injective/oracle/01_state.md | 275 ++ .../modules/injective/oracle/02_keeper.md | 120 + .../modules/injective/oracle/03_messages.md | 190 + .../modules/injective/oracle/04_proposals.md | 227 ++ .../modules/injective/oracle/05_events.md | 96 + .../oracle/06_future_improvements.md | 10 + .../modules/injective/oracle/README.md | 39 + .../modules/injective/peggy/01_definitions.md | 36 + .../modules/injective/peggy/02_workflow.md | 164 + .../modules/injective/peggy/03_state.md | 265 ++ .../modules/injective/peggy/04_messages.md | 199 ++ .../modules/injective/peggy/05_slashing.md | 91 + .../modules/injective/peggy/06_end_block.md | 51 + .../modules/injective/peggy/07_events.md | 143 + .../modules/injective/peggy/08_params.md | 112 + .../injective/peggy/09_relay_semantics.md | 53 + .../injective/peggy/10_future_improvements.md | 22 + .../modules/injective/peggy/README.md | 39 + .../injective/peggy/images/SendToCosmos.png | Bin 0 -> 302926 bytes .../injective/peggy/images/SendToEth.png | Bin 0 -> 486210 bytes .../injective/peggy/images/valsetupdate.png | Bin 0 -> 517707 bytes .../injective/permissions/01_concepts.md | 57 + .../modules/injective/permissions/02_state.md | 93 + .../permissions/03_state_transitions.md | 188 + .../modules/injective/permissions/README.md | 13 + .../injective/tokenfactory/01_concepts.md | 23 + .../injective/tokenfactory/02_state.md | 74 + .../injective/tokenfactory/03_messages.md | 145 + .../injective/tokenfactory/04_events.md | 54 + .../injective/tokenfactory/05_params.md | 19 + .../modules/injective/tokenfactory/README.md | 14 + .../modules/injective/wasmx/01_concepts.md | 53 + .../modules/injective/wasmx/02_data.md | 38 + .../modules/injective/wasmx/03_proposals.md | 130 + .../modules/injective/wasmx/04_messages.md | 90 + .../modules/injective/wasmx/05_params.md | 21 + .../modules/injective/wasmx/README.md | 17 + .gitignore | 1 + 98 files changed, 21587 insertions(+), 2 deletions(-) delete mode 100644 .gitbook/developers/modules.md create mode 100644 .gitbook/developers/modules/README.md create mode 100644 .gitbook/developers/modules/core/README.md create mode 100644 .gitbook/developers/modules/core/auth/README.md create mode 100644 .gitbook/developers/modules/core/authz/README.md create mode 100644 .gitbook/developers/modules/core/bank/README.md create mode 100644 .gitbook/developers/modules/core/circuit/README.md create mode 100644 .gitbook/developers/modules/core/consensus/README.md create mode 100644 .gitbook/developers/modules/core/crisis/README.md create mode 100644 .gitbook/developers/modules/core/distribution/README.md create mode 100644 .gitbook/developers/modules/core/evidence/README.md create mode 100644 .gitbook/developers/modules/core/feegrant/README.md create mode 100644 .gitbook/developers/modules/core/genutil/README.md create mode 100644 .gitbook/developers/modules/core/gov/README.md create mode 100644 .gitbook/developers/modules/core/group/README.md create mode 100644 .gitbook/developers/modules/core/mint/README.md create mode 100644 .gitbook/developers/modules/core/nft/README.md create mode 100644 .gitbook/developers/modules/core/params/README.md create mode 100644 .gitbook/developers/modules/core/slashing/README.md create mode 100644 .gitbook/developers/modules/core/staking/README.md create mode 100644 .gitbook/developers/modules/core/upgrade/README.md create mode 100644 .gitbook/developers/modules/injective/README.md create mode 100644 .gitbook/developers/modules/injective/auction/01_state.md create mode 100644 .gitbook/developers/modules/injective/auction/02_messages.md create mode 100644 .gitbook/developers/modules/injective/auction/03_end_block.md create mode 100644 .gitbook/developers/modules/injective/auction/04_events.md create mode 100644 .gitbook/developers/modules/injective/auction/05_params.md create mode 100644 .gitbook/developers/modules/injective/auction/README.md create mode 100644 .gitbook/developers/modules/injective/auction/img.png create mode 100644 .gitbook/developers/modules/injective/exchange/00_derivative_market_concepts.md create mode 100644 .gitbook/developers/modules/injective/exchange/01_spot_market_concepts.md create mode 100644 .gitbook/developers/modules/injective/exchange/02_binary_options_markets.md create mode 100644 .gitbook/developers/modules/injective/exchange/02_other_concepts.md create mode 100644 .gitbook/developers/modules/injective/exchange/03_state.md create mode 100644 .gitbook/developers/modules/injective/exchange/04_state_transitions.md create mode 100644 .gitbook/developers/modules/injective/exchange/05_messages.md create mode 100644 .gitbook/developers/modules/injective/exchange/06_proposals.md create mode 100644 .gitbook/developers/modules/injective/exchange/07_begin_block.md create mode 100644 .gitbook/developers/modules/injective/exchange/08_end_block.md create mode 100644 .gitbook/developers/modules/injective/exchange/09_events.md create mode 100644 .gitbook/developers/modules/injective/exchange/10_params.md create mode 100644 .gitbook/developers/modules/injective/exchange/11_msg_privileged_execute_contract.md create mode 100644 .gitbook/developers/modules/injective/exchange/README.md create mode 100644 .gitbook/developers/modules/injective/insurance/01_state.md create mode 100644 .gitbook/developers/modules/injective/insurance/02_state_transitions.md create mode 100644 .gitbook/developers/modules/injective/insurance/03_messages.md create mode 100644 .gitbook/developers/modules/injective/insurance/04_end_block.md create mode 100644 .gitbook/developers/modules/injective/insurance/05_events.md create mode 100644 .gitbook/developers/modules/injective/insurance/06_params.md create mode 100644 .gitbook/developers/modules/injective/insurance/07_future_improvements.md create mode 100644 .gitbook/developers/modules/injective/insurance/README.md create mode 100644 .gitbook/developers/modules/injective/ocr/01_concepts.md create mode 100644 .gitbook/developers/modules/injective/ocr/02_state.md create mode 100644 .gitbook/developers/modules/injective/ocr/03_messages.md create mode 100644 .gitbook/developers/modules/injective/ocr/04_proposals.md create mode 100644 .gitbook/developers/modules/injective/ocr/05_begin_block.md create mode 100644 .gitbook/developers/modules/injective/ocr/06_hooks.md create mode 100644 .gitbook/developers/modules/injective/ocr/07_events.md create mode 100644 .gitbook/developers/modules/injective/ocr/08_params.md create mode 100644 .gitbook/developers/modules/injective/ocr/README.md create mode 100644 .gitbook/developers/modules/injective/oracle/01_state.md create mode 100644 .gitbook/developers/modules/injective/oracle/02_keeper.md create mode 100644 .gitbook/developers/modules/injective/oracle/03_messages.md create mode 100644 .gitbook/developers/modules/injective/oracle/04_proposals.md create mode 100644 .gitbook/developers/modules/injective/oracle/05_events.md create mode 100644 .gitbook/developers/modules/injective/oracle/06_future_improvements.md create mode 100644 .gitbook/developers/modules/injective/oracle/README.md create mode 100644 .gitbook/developers/modules/injective/peggy/01_definitions.md create mode 100644 .gitbook/developers/modules/injective/peggy/02_workflow.md create mode 100644 .gitbook/developers/modules/injective/peggy/03_state.md create mode 100644 .gitbook/developers/modules/injective/peggy/04_messages.md create mode 100644 .gitbook/developers/modules/injective/peggy/05_slashing.md create mode 100644 .gitbook/developers/modules/injective/peggy/06_end_block.md create mode 100644 .gitbook/developers/modules/injective/peggy/07_events.md create mode 100644 .gitbook/developers/modules/injective/peggy/08_params.md create mode 100644 .gitbook/developers/modules/injective/peggy/09_relay_semantics.md create mode 100644 .gitbook/developers/modules/injective/peggy/10_future_improvements.md create mode 100644 .gitbook/developers/modules/injective/peggy/README.md create mode 100644 .gitbook/developers/modules/injective/peggy/images/SendToCosmos.png create mode 100644 .gitbook/developers/modules/injective/peggy/images/SendToEth.png create mode 100644 .gitbook/developers/modules/injective/peggy/images/valsetupdate.png create mode 100644 .gitbook/developers/modules/injective/permissions/01_concepts.md create mode 100644 .gitbook/developers/modules/injective/permissions/02_state.md create mode 100644 .gitbook/developers/modules/injective/permissions/03_state_transitions.md create mode 100644 .gitbook/developers/modules/injective/permissions/README.md create mode 100644 .gitbook/developers/modules/injective/tokenfactory/01_concepts.md create mode 100644 .gitbook/developers/modules/injective/tokenfactory/02_state.md create mode 100644 .gitbook/developers/modules/injective/tokenfactory/03_messages.md create mode 100644 .gitbook/developers/modules/injective/tokenfactory/04_events.md create mode 100644 .gitbook/developers/modules/injective/tokenfactory/05_params.md create mode 100644 .gitbook/developers/modules/injective/tokenfactory/README.md create mode 100644 .gitbook/developers/modules/injective/wasmx/01_concepts.md create mode 100644 .gitbook/developers/modules/injective/wasmx/02_data.md create mode 100644 .gitbook/developers/modules/injective/wasmx/03_proposals.md create mode 100644 .gitbook/developers/modules/injective/wasmx/04_messages.md create mode 100644 .gitbook/developers/modules/injective/wasmx/05_params.md create mode 100644 .gitbook/developers/modules/injective/wasmx/README.md diff --git a/.gitbook/developers/modules.md b/.gitbook/developers/modules.md deleted file mode 100644 index f0dc8066..00000000 --- a/.gitbook/developers/modules.md +++ /dev/null @@ -1,2 +0,0 @@ -# Modules - diff --git a/.gitbook/developers/modules/README.md b/.gitbook/developers/modules/README.md new file mode 100644 index 00000000..3a4a9ddf --- /dev/null +++ b/.gitbook/developers/modules/README.md @@ -0,0 +1,22 @@ +import { + HomepageCard as Card, + HomepageSection as Section, +} from "../../../src/components/HomepageComponents"; +import { DistributedIcon, CoreModulesIcon } from "../../../src/icons"; + +# Injective Modules + +
+ } + /> + } + /> +
diff --git a/.gitbook/developers/modules/core/README.md b/.gitbook/developers/modules/core/README.md new file mode 100644 index 00000000..b0790a93 --- /dev/null +++ b/.gitbook/developers/modules/core/README.md @@ -0,0 +1,14 @@ +import { + HomepageSection as Section +} from "../../../../src/components/HomepageComponents"; +import ComponentsGrid from "@theme/DocCardList"; + +# Core Modules + +
+ +
diff --git a/.gitbook/developers/modules/core/auth/README.md b/.gitbook/developers/modules/core/auth/README.md new file mode 100644 index 00000000..bd9f18a3 --- /dev/null +++ b/.gitbook/developers/modules/core/auth/README.md @@ -0,0 +1,710 @@ +--- +sidebar_position: 1 +--- + +# `x/auth` + +## Abstract + +This document specifies the auth module of the Cosmos SDK. + +The auth module is responsible for specifying the base transaction and account types +for an application, since the SDK itself is agnostic to these particulars. It contains +the middlewares, where all basic transaction validity checks (signatures, nonces, auxiliary fields) +are performed, and exposes the account keeper, which allows other modules to read, write, and modify accounts. + +This module is used in the Cosmos Hub. + +## Contents + +* [Concepts](#concepts) + * [Gas & Fees](#gas--fees) +* [State](#state) + * [Accounts](#accounts) +* [AnteHandlers](#antehandlers) +* [Keepers](#keepers) + * [Account Keeper](#account-keeper) +* [Parameters](#parameters) +* [Client](#client) + * [CLI](#cli) + * [gRPC](#grpc) + * [REST](#rest) + +## Concepts + +**Note:** The auth module is different from the [authz module](../authz/). + +The differences are: + +* `auth` - authentication of accounts and transactions for Cosmos SDK applications and is responsible for specifying the base transaction and account types. +* `authz` - authorization for accounts to perform actions on behalf of other accounts and enables a granter to grant authorizations to a grantee that allows the grantee to execute messages on behalf of the granter. + +### Gas & Fees + +Fees serve two purposes for an operator of the network. + +Fees limit the growth of the state stored by every full node and allow for +general purpose censorship of transactions of little economic value. Fees +are best suited as an anti-spam mechanism where validators are disinterested in +the use of the network and identities of users. + +Fees are determined by the gas limits and gas prices transactions provide, where +`fees = ceil(gasLimit * gasPrices)`. Txs incur gas costs for all state reads/writes, +signature verification, as well as costs proportional to the tx size. Operators +should set minimum gas prices when starting their nodes. They must set the unit +costs of gas in each token denomination they wish to support: + +`simd start ... --minimum-gas-prices=0.00001stake;0.05photinos` + +When adding transactions to mempool or gossipping transactions, validators check +if the transaction's gas prices, which are determined by the provided fees, meet +any of the validator's minimum gas prices. In other words, a transaction must +provide a fee of at least one denomination that matches a validator's minimum +gas price. + +CometBFT does not currently provide fee based mempool prioritization, and fee +based mempool filtering is local to node and not part of consensus. But with +minimum gas prices set, such a mechanism could be implemented by node operators. + +Because the market value for tokens will fluctuate, validators are expected to +dynamically adjust their minimum gas prices to a level that would encourage the +use of the network. + +## State + +### Accounts + +Accounts contain authentication information for a uniquely identified external user of an SDK blockchain, +including public key, address, and account number / sequence number for replay protection. For efficiency, +since account balances must also be fetched to pay fees, account structs also store the balance of a user +as `sdk.Coins`. + +Accounts are exposed externally as an interface, and stored internally as +either a base account or vesting account. Module clients wishing to add more +account types may do so. + +* `0x01 | Address -> ProtocolBuffer(account)` + +#### Account Interface + +The account interface exposes methods to read and write standard account information. +Note that all of these methods operate on an account struct conforming to the +interface - in order to write the account to the store, the account keeper will +need to be used. + +```go +// AccountI is an interface used to store coins at a given address within state. +// It presumes a notion of sequence numbers for replay protection, +// a notion of account numbers for replay protection for previously pruned accounts, +// and a pubkey for authentication purposes. +// +// Many complex conditions can be used in the concrete struct which implements AccountI. +type AccountI interface { + proto.Message + + GetAddress() sdk.AccAddress + SetAddress(sdk.AccAddress) error // errors if already set. + + GetPubKey() crypto.PubKey // can return nil. + SetPubKey(crypto.PubKey) error + + GetAccountNumber() uint64 + SetAccountNumber(uint64) error + + GetSequence() uint64 + SetSequence(uint64) error + + // Ensure that account implements stringer + String() string +} +``` + +##### Base Account + +A base account is the simplest and most common account type, which just stores all requisite +fields directly in a struct. + +```protobuf +// BaseAccount defines a base account type. It contains all the necessary fields +// for basic account functionality. Any custom account type should extend this +// type for additional functionality (e.g. vesting). +message BaseAccount { + string address = 1; + google.protobuf.Any pub_key = 2; + uint64 account_number = 3; + uint64 sequence = 4; +} +``` + +### Vesting Account + +See [Vesting](https://docs.cosmos.network/main/modules/auth/vesting/). + +## AnteHandlers + +The `x/auth` module presently has no transaction handlers of its own, but does expose the special `AnteHandler`, used for performing basic validity checks on a transaction, such that it could be thrown out of the mempool. +The `AnteHandler` can be seen as a set of decorators that check transactions within the current context, per [ADR 010](https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-010-modular-antehandler.md). + +Note that the `AnteHandler` is called on both `CheckTx` and `DeliverTx`, as CometBFT proposers presently have the ability to include in their proposed block transactions which fail `CheckTx`. + +### Decorators + +The auth module provides `AnteDecorator`s that are recursively chained together into a single `AnteHandler` in the following order: + +* `SetUpContextDecorator`: Sets the `GasMeter` in the `Context` and wraps the next `AnteHandler` with a defer clause to recover from any downstream `OutOfGas` panics in the `AnteHandler` chain to return an error with information on gas provided and gas used. + +* `RejectExtensionOptionsDecorator`: Rejects all extension options which can optionally be included in protobuf transactions. + +* `MempoolFeeDecorator`: Checks if the `tx` fee is above local mempool `minFee` parameter during `CheckTx`. + +* `ValidateBasicDecorator`: Calls `tx.ValidateBasic` and returns any non-nil error. + +* `TxTimeoutHeightDecorator`: Check for a `tx` height timeout. + +* `ValidateMemoDecorator`: Validates `tx` memo with application parameters and returns any non-nil error. + +* `ConsumeGasTxSizeDecorator`: Consumes gas proportional to the `tx` size based on application parameters. + +* `DeductFeeDecorator`: Deducts the `FeeAmount` from first signer of the `tx`. If the `x/feegrant` module is enabled and a fee granter is set, it deducts fees from the fee granter account. + +* `SetPubKeyDecorator`: Sets the pubkey from a `tx`'s signers that does not already have its corresponding pubkey saved in the state machine and in the current context. + +* `ValidateSigCountDecorator`: Validates the number of signatures in `tx` based on app-parameters. + +* `SigGasConsumeDecorator`: Consumes parameter-defined amount of gas for each signature. This requires pubkeys to be set in context for all signers as part of `SetPubKeyDecorator`. + +* `SigVerificationDecorator`: Verifies all signatures are valid. This requires pubkeys to be set in context for all signers as part of `SetPubKeyDecorator`. + +* `IncrementSequenceDecorator`: Increments the account sequence for each signer to prevent replay attacks. + +## Keepers + +The auth module only exposes one keeper, the account keeper, which can be used to read and write accounts. + +### Account Keeper + +Presently only one fully-permissioned account keeper is exposed, which has the ability to both read and write +all fields of all accounts, and to iterate over all stored accounts. + +```go +// AccountKeeperI is the interface contract that x/auth's keeper implements. +type AccountKeeperI interface { + // Return a new account with the next account number and the specified address. Does not save the new account to the store. + NewAccountWithAddress(sdk.Context, sdk.AccAddress) types.AccountI + + // Return a new account with the next account number. Does not save the new account to the store. + NewAccount(sdk.Context, types.AccountI) types.AccountI + + // Check if an account exists in the store. + HasAccount(sdk.Context, sdk.AccAddress) bool + + // Retrieve an account from the store. + GetAccount(sdk.Context, sdk.AccAddress) types.AccountI + + // Set an account in the store. + SetAccount(sdk.Context, types.AccountI) + + // Remove an account from the store. + RemoveAccount(sdk.Context, types.AccountI) + + // Iterate over all accounts, calling the provided function. Stop iteration when it returns true. + IterateAccounts(sdk.Context, func(types.AccountI) bool) + + // Fetch the public key of an account at a specified address + GetPubKey(sdk.Context, sdk.AccAddress) (crypto.PubKey, error) + + // Fetch the sequence of an account at a specified address. + GetSequence(sdk.Context, sdk.AccAddress) (uint64, error) + + // Fetch the next account number, and increment the internal counter. + NextAccountNumber(sdk.Context) uint64 +} +``` + +## Parameters + +The auth module contains the following parameters: + +| Key | Type | Example | +| ---------------------- | --------------- | ------- | +| MaxMemoCharacters | uint64 | 256 | +| TxSigLimit | uint64 | 7 | +| TxSizeCostPerByte | uint64 | 10 | +| SigVerifyCostED25519 | uint64 | 590 | +| SigVerifyCostSecp256k1 | uint64 | 1000 | + +## Client + +### CLI + +A user can query and interact with the `auth` module using the CLI. + +### Query + +The `query` commands allow users to query `auth` state. + +```bash +simd query auth --help +``` + +#### account + +The `account` command allow users to query for an account by it's address. + +```bash +simd query auth account [address] [flags] +``` + +Example: + +```bash +simd query auth account cosmos1... +``` + +Example Output: + +```bash +'@type': /cosmos.auth.v1beta1.BaseAccount +account_number: "0" +address: cosmos1zwg6tpl8aw4rawv8sgag9086lpw5hv33u5ctr2 +pub_key: + '@type': /cosmos.crypto.secp256k1.PubKey + key: ApDrE38zZdd7wLmFS9YmqO684y5DG6fjZ4rVeihF/AQD +sequence: "1" +``` + +#### accounts + +The `accounts` command allow users to query all the available accounts. + +```bash +simd query auth accounts [flags] +``` + +Example: + +```bash +simd query auth accounts +``` + +Example Output: + +```bash +accounts: +- '@type': /cosmos.auth.v1beta1.BaseAccount + account_number: "0" + address: cosmos1zwg6tpl8aw4rawv8sgag9086lpw5hv33u5ctr2 + pub_key: + '@type': /cosmos.crypto.secp256k1.PubKey + key: ApDrE38zZdd7wLmFS9YmqO684y5DG6fjZ4rVeihF/AQD + sequence: "1" +- '@type': /cosmos.auth.v1beta1.ModuleAccount + base_account: + account_number: "8" + address: cosmos1yl6hdjhmkf37639730gffanpzndzdpmhwlkfhr + pub_key: null + sequence: "0" + name: transfer + permissions: + - minter + - burner +- '@type': /cosmos.auth.v1beta1.ModuleAccount + base_account: + account_number: "4" + address: cosmos1fl48vsnmsdzcv85q5d2q4z5ajdha8yu34mf0eh + pub_key: null + sequence: "0" + name: bonded_tokens_pool + permissions: + - burner + - staking +- '@type': /cosmos.auth.v1beta1.ModuleAccount + base_account: + account_number: "5" + address: cosmos1tygms3xhhs3yv487phx3dw4a95jn7t7lpm470r + pub_key: null + sequence: "0" + name: not_bonded_tokens_pool + permissions: + - burner + - staking +- '@type': /cosmos.auth.v1beta1.ModuleAccount + base_account: + account_number: "6" + address: cosmos10d07y265gmmuvt4z0w9aw880jnsr700j6zn9kn + pub_key: null + sequence: "0" + name: gov + permissions: + - burner +- '@type': /cosmos.auth.v1beta1.ModuleAccount + base_account: + account_number: "3" + address: cosmos1jv65s3grqf6v6jl3dp4t6c9t9rk99cd88lyufl + pub_key: null + sequence: "0" + name: distribution + permissions: [] +- '@type': /cosmos.auth.v1beta1.BaseAccount + account_number: "1" + address: cosmos147k3r7v2tvwqhcmaxcfql7j8rmkrlsemxshd3j + pub_key: null + sequence: "0" +- '@type': /cosmos.auth.v1beta1.ModuleAccount + base_account: + account_number: "7" + address: cosmos1m3h30wlvsf8llruxtpukdvsy0km2kum8g38c8q + pub_key: null + sequence: "0" + name: mint + permissions: + - minter +- '@type': /cosmos.auth.v1beta1.ModuleAccount + base_account: + account_number: "2" + address: cosmos17xpfvakm2amg962yls6f84z3kell8c5lserqta + pub_key: null + sequence: "0" + name: fee_collector + permissions: [] +pagination: + next_key: null + total: "0" +``` + +#### params + +The `params` command allow users to query the current auth parameters. + +```bash +simd query auth params [flags] +``` + +Example: + +```bash +simd query auth params +``` + +Example Output: + +```bash +max_memo_characters: "256" +sig_verify_cost_ed25519: "590" +sig_verify_cost_secp256k1: "1000" +tx_sig_limit: "7" +tx_size_cost_per_byte: "10" +``` + +### Transactions + +The `auth` module supports transactions commands to help you with signing and more. Compared to other modules you can access directly the `auth` module transactions commands using the only `tx` command. + +Use directly the `--help` flag to get more information about the `tx` command. + +```bash +simd tx --help +``` + +#### `sign` + +The `sign` command allows users to sign transactions that was generated offline. + +```bash +simd tx sign tx.json --from $ALICE > tx.signed.json +``` + +The result is a signed transaction that can be broadcasted to the network thanks to the broadcast command. + +More information about the `sign` command can be found running `simd tx sign --help`. + +#### `sign-batch` + +The `sign-batch` command allows users to sign multiples offline generated transactions. +The transactions can be in one file, with one tx per line, or in multiple files. + +```bash +simd tx sign txs.json --from $ALICE > tx.signed.json +``` + +or + +```bash +simd tx sign tx1.json tx2.json tx3.json --from $ALICE > tx.signed.json +``` + +The result is multiples signed transactions. For combining the signed transactions into one transactions, use the `--append` flag. + +More information about the `sign-batch` command can be found running `simd tx sign-batch --help`. + +#### `multi-sign` + +The `multi-sign` command allows users to sign transactions that was generated offline by a multisig account. + +```bash +simd tx multisign transaction.json k1k2k3 k1sig.json k2sig.json k3sig.json +``` + +Where `k1k2k3` is the multisig account address, `k1sig.json` is the signature of the first signer, `k2sig.json` is the signature of the second signer, and `k3sig.json` is the signature of the third signer. + +##### Nested multisig transactions + +To allow transactions to be signed by nested multisigs, meaning that a participant of a multisig account can be another multisig account, the `--skip-signature-verification` flag must be used. + +```bash +# First aggregate signatures of the multisig participant +simd tx multi-sign transaction.json ms1 ms1p1sig.json ms1p2sig.json --signature-only --skip-signature-verification > ms1sig.json + +# Then use the aggregated signatures and the other signatures to sign the final transaction +simd tx multi-sign transaction.json k1ms1 k1sig.json ms1sig.json --skip-signature-verification +``` + +Where `ms1` is the nested multisig account address, `ms1p1sig.json` is the signature of the first participant of the nested multisig account, `ms1p2sig.json` is the signature of the second participant of the nested multisig account, and `ms1sig.json` is the aggregated signature of the nested multisig account. + +`k1ms1` is a multisig account comprised of an individual signer and another nested multisig account (`ms1`). `k1sig.json` is the signature of the first signer of the individual member. + +More information about the `multi-sign` command can be found running `simd tx multi-sign --help`. + +#### `multisign-batch` + +The `multisign-batch` works the same way as `sign-batch`, but for multisig accounts. +With the difference that the `multisign-batch` command requires all transactions to be in one file, and the `--append` flag does not exist. + +More information about the `multisign-batch` command can be found running `simd tx multisign-batch --help`. + +#### `validate-signatures` + +The `validate-signatures` command allows users to validate the signatures of a signed transaction. + +```bash +$ simd tx validate-signatures tx.signed.json +Signers: + 0: cosmos1l6vsqhh7rnwsyr2kyz3jjg3qduaz8gwgyl8275 + +Signatures: + 0: cosmos1l6vsqhh7rnwsyr2kyz3jjg3qduaz8gwgyl8275 [OK] +``` + +More information about the `validate-signatures` command can be found running `simd tx validate-signatures --help`. + +#### `broadcast` + +The `broadcast` command allows users to broadcast a signed transaction to the network. + +```bash +simd tx broadcast tx.signed.json +``` + +More information about the `broadcast` command can be found running `simd tx broadcast --help`. + + +### gRPC + +A user can query the `auth` module using gRPC endpoints. + +#### Account + +The `account` endpoint allow users to query for an account by it's address. + +```bash +cosmos.auth.v1beta1.Query/Account +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"address":"cosmos1.."}' \ + localhost:9090 \ + cosmos.auth.v1beta1.Query/Account +``` + +Example Output: + +```bash +{ + "account":{ + "@type":"/cosmos.auth.v1beta1.BaseAccount", + "address":"cosmos1zwg6tpl8aw4rawv8sgag9086lpw5hv33u5ctr2", + "pubKey":{ + "@type":"/cosmos.crypto.secp256k1.PubKey", + "key":"ApDrE38zZdd7wLmFS9YmqO684y5DG6fjZ4rVeihF/AQD" + }, + "sequence":"1" + } +} +``` + +#### Accounts + +The `accounts` endpoint allow users to query all the available accounts. + +```bash +cosmos.auth.v1beta1.Query/Accounts +``` + +Example: + +```bash +grpcurl -plaintext \ + localhost:9090 \ + cosmos.auth.v1beta1.Query/Accounts +``` + +Example Output: + +```bash +{ + "accounts":[ + { + "@type":"/cosmos.auth.v1beta1.BaseAccount", + "address":"cosmos1zwg6tpl8aw4rawv8sgag9086lpw5hv33u5ctr2", + "pubKey":{ + "@type":"/cosmos.crypto.secp256k1.PubKey", + "key":"ApDrE38zZdd7wLmFS9YmqO684y5DG6fjZ4rVeihF/AQD" + }, + "sequence":"1" + }, + { + "@type":"/cosmos.auth.v1beta1.ModuleAccount", + "baseAccount":{ + "address":"cosmos1yl6hdjhmkf37639730gffanpzndzdpmhwlkfhr", + "accountNumber":"8" + }, + "name":"transfer", + "permissions":[ + "minter", + "burner" + ] + }, + { + "@type":"/cosmos.auth.v1beta1.ModuleAccount", + "baseAccount":{ + "address":"cosmos1fl48vsnmsdzcv85q5d2q4z5ajdha8yu34mf0eh", + "accountNumber":"4" + }, + "name":"bonded_tokens_pool", + "permissions":[ + "burner", + "staking" + ] + }, + { + "@type":"/cosmos.auth.v1beta1.ModuleAccount", + "baseAccount":{ + "address":"cosmos1tygms3xhhs3yv487phx3dw4a95jn7t7lpm470r", + "accountNumber":"5" + }, + "name":"not_bonded_tokens_pool", + "permissions":[ + "burner", + "staking" + ] + }, + { + "@type":"/cosmos.auth.v1beta1.ModuleAccount", + "baseAccount":{ + "address":"cosmos10d07y265gmmuvt4z0w9aw880jnsr700j6zn9kn", + "accountNumber":"6" + }, + "name":"gov", + "permissions":[ + "burner" + ] + }, + { + "@type":"/cosmos.auth.v1beta1.ModuleAccount", + "baseAccount":{ + "address":"cosmos1jv65s3grqf6v6jl3dp4t6c9t9rk99cd88lyufl", + "accountNumber":"3" + }, + "name":"distribution" + }, + { + "@type":"/cosmos.auth.v1beta1.BaseAccount", + "accountNumber":"1", + "address":"cosmos147k3r7v2tvwqhcmaxcfql7j8rmkrlsemxshd3j" + }, + { + "@type":"/cosmos.auth.v1beta1.ModuleAccount", + "baseAccount":{ + "address":"cosmos1m3h30wlvsf8llruxtpukdvsy0km2kum8g38c8q", + "accountNumber":"7" + }, + "name":"mint", + "permissions":[ + "minter" + ] + }, + { + "@type":"/cosmos.auth.v1beta1.ModuleAccount", + "baseAccount":{ + "address":"cosmos17xpfvakm2amg962yls6f84z3kell8c5lserqta", + "accountNumber":"2" + }, + "name":"fee_collector" + } + ], + "pagination":{ + "total":"9" + } +} +``` + +#### Params + +The `params` endpoint allow users to query the current auth parameters. + +```bash +cosmos.auth.v1beta1.Query/Params +``` + +Example: + +```bash +grpcurl -plaintext \ + localhost:9090 \ + cosmos.auth.v1beta1.Query/Params +``` + +Example Output: + +```bash +{ + "params": { + "maxMemoCharacters": "256", + "txSigLimit": "7", + "txSizeCostPerByte": "10", + "sigVerifyCostEd25519": "590", + "sigVerifyCostSecp256k1": "1000" + } +} +``` + +### REST + +A user can query the `auth` module using REST endpoints. + +#### Account + +The `account` endpoint allow users to query for an account by it's address. + +```bash +/cosmos/auth/v1beta1/account?address={address} +``` + +#### Accounts + +The `accounts` endpoint allow users to query all the available accounts. + +```bash +/cosmos/auth/v1beta1/accounts +``` + +#### Params + +The `params` endpoint allow users to query the current auth parameters. + +```bash +/cosmos/auth/v1beta1/params +``` diff --git a/.gitbook/developers/modules/core/authz/README.md b/.gitbook/developers/modules/core/authz/README.md new file mode 100644 index 00000000..676654a2 --- /dev/null +++ b/.gitbook/developers/modules/core/authz/README.md @@ -0,0 +1,355 @@ +--- +sidebar_position: 1 +--- + +# `x/authz` + +## Abstract + +`x/authz` is an implementation of a Cosmos SDK module, per [ADR 30](https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-030-authz-module.md), that allows +granting arbitrary privileges from one account (the granter) to another account (the grantee). Authorizations must be granted for a particular Msg service method one by one using an implementation of the `Authorization` interface. + +## Contents + +* [Concepts](#concepts) + * [Authorization and Grant](#authorization-and-grant) + * [Built-in Authorizations](#built-in-authorizations) + * [Gas](#gas) +* [State](#state) + * [Grant](#grant) + * [GrantQueue](#grantqueue) +* [Messages](#messages) + * [MsgGrant](#msggrant) + * [MsgRevoke](#msgrevoke) + * [MsgExec](#msgexec) +* [Events](#events) +* [Client](#client) + * [CLI](#cli) + * [gRPC](#grpc) + * [REST](#rest) + +## Concepts + +### Authorization and Grant + +The `x/authz` module defines interfaces and messages grant authorizations to perform actions +on behalf of one account to other accounts. The design is defined in the [ADR 030](https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-030-authz-module.md). + +A *grant* is an allowance to execute a Msg by the grantee on behalf of the granter. +Authorization is an interface that must be implemented by a concrete authorization logic to validate and execute grants. Authorizations are extensible and can be defined for any Msg service method even outside of the module where the Msg method is defined. See the `SendAuthorization` example in the next section for more details. + +**Note:** The authz module is different from the [auth (authentication)](../auth/) module that is responsible for specifying the base transaction and account types. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/authz/authorizations.go#L11-L25 +``` + +### Built-in Authorizations + +The Cosmos SDK `x/authz` module comes with following authorization types: + +#### GenericAuthorization + +`GenericAuthorization` implements the `Authorization` interface that gives unrestricted permission to execute the provided Msg on behalf of granter's account. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/authz/v1beta1/authz.proto#L14-L22 +``` + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/authz/generic_authorization.go#L16-L29 +``` + +* `msg` stores Msg type URL. + +#### SendAuthorization + +`SendAuthorization` implements the `Authorization` interface for the `cosmos.bank.v1beta1.MsgSend` Msg. + +* It takes a (positive) `SpendLimit` that specifies the maximum amount of tokens the grantee can spend. The `SpendLimit` is updated as the tokens are spent. +* It takes an (optional) `AllowList` that specifies to which addresses a grantee can send token. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/bank/v1beta1/authz.proto#L11-L30 +``` + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/bank/types/send_authorization.go#L29-L62 +``` + +* `spend_limit` keeps track of how many coins are left in the authorization. +* `allow_list` specifies an optional list of addresses to whom the grantee can send tokens on behalf of the granter. + +#### StakeAuthorization + +`StakeAuthorization` implements the `Authorization` interface for messages in the [staking module](https://docs.cosmos.network/v0.44/modules/staking/). It takes an `AuthorizationType` to specify whether you want to authorise delegating, undelegating or redelegating (i.e. these have to be authorised seperately). It also takes a required `MaxTokens` that keeps track of a limit to the amount of tokens that can be delegated/undelegated/redelegated. If left empty, the amount is unlimited. Additionally, this Msg takes an `AllowList` or a `DenyList`, which allows you to select which validators you allow or deny grantees to stake with. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/authz.proto#L11-L35 +``` + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/staking/types/authz.go#L15-L35 +``` + +### Gas + +In order to prevent DoS attacks, granting `StakeAuthorization`s with `x/authz` incurs gas. `StakeAuthorization` allows you to authorize another account to delegate, undelegate, or redelegate to validators. The authorizer can define a list of validators they allow or deny delegations to. The Cosmos SDK iterates over these lists and charge 10 gas for each validator in both of the lists. + +Since the state maintaining a list for granter, grantee pair with same expiration, we are iterating over the list to remove the grant (incase of any revoke of paritcular `msgType`) from the list and we are charging 20 gas per iteration. + +## State + +### Grant + +Grants are identified by combining granter address (the address bytes of the granter), grantee address (the address bytes of the grantee) and Authorization type (its type URL). Hence we only allow one grant for the (granter, grantee, Authorization) triple. + +* Grant: `0x01 | granter_address_len (1 byte) | granter_address_bytes | grantee_address_len (1 byte) | grantee_address_bytes | msgType_bytes -> ProtocolBuffer(AuthorizationGrant)` + +The grant object encapsulates an `Authorization` type and an expiration timestamp: + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/authz/v1beta1/authz.proto#L24-L32 +``` + +### GrantQueue + +We are maintaining a queue for authz pruning. Whenever a grant is created, an item will be added to `GrantQueue` with a key of expiration, granter, grantee. + +In `EndBlock` (which runs for every block) we continuously check and prune the expired grants by forming a prefix key with current blocktime that passed the stored expiration in `GrantQueue`, we iterate through all the matched records from `GrantQueue` and delete them from the `GrantQueue` & `Grant`s store. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/5f4ddc6f80f9707320eec42182184207fff3833a/x/authz/keeper/keeper.go#L378-L403 +``` + +* GrantQueue: `0x02 | expiration_bytes | granter_address_len (1 byte) | granter_address_bytes | grantee_address_len (1 byte) | grantee_address_bytes -> ProtocalBuffer(GrantQueueItem)` + +The `expiration_bytes` are the expiration date in UTC with the format `"2006-01-02T15:04:05.000000000"`. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/authz/keeper/keys.go#L77-L93 +``` + +The `GrantQueueItem` object contains the list of type urls between granter and grantee that expire at the time indicated in the key. + +## Messages + +In this section we describe the processing of messages for the authz module. + +### MsgGrant + +An authorization grant is created using the `MsgGrant` message. +If there is already a grant for the `(granter, grantee, Authorization)` triple, then the new grant overwrites the previous one. To update or extend an existing grant, a new grant with the same `(granter, grantee, Authorization)` triple should be created. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/authz/v1beta1/tx.proto#L35-L45 +``` + +The message handling should fail if: + +* both granter and grantee have the same address. +* provided `Expiration` time is less than current unix timestamp (but a grant will be created if no `expiration` time is provided since `expiration` is optional). +* provided `Grant.Authorization` is not implemented. +* `Authorization.MsgTypeURL()` is not defined in the router (there is no defined handler in the app router to handle that Msg types). + +### MsgRevoke + +A grant can be removed with the `MsgRevoke` message. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/authz/v1beta1/tx.proto#L69-L78 +``` + +The message handling should fail if: + +* both granter and grantee have the same address. +* provided `MsgTypeUrl` is empty. + +NOTE: The `MsgExec` message removes a grant if the grant has expired. + +### MsgExec + +When a grantee wants to execute a transaction on behalf of a granter, they must send `MsgExec`. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/authz/v1beta1/tx.proto#L52-L63 +``` + +The message handling should fail if: + +* provided `Authorization` is not implemented. +* grantee doesn't have permission to run the transaction. +* if granted authorization is expired. + +## Events + +The authz module emits proto events defined in [the Protobuf reference](https://buf.build/cosmos/cosmos-sdk/docs/main/cosmos.authz.v1beta1#cosmos.authz.v1beta1.EventGrant). + +## Client + +### CLI + +A user can query and interact with the `authz` module using the CLI. + +#### Query + +The `query` commands allow users to query `authz` state. + +```bash +simd query authz --help +``` + +##### grants + +The `grants` command allows users to query grants for a granter-grantee pair. If the message type URL is set, it selects grants only for that message type. + +```bash +simd query authz grants [granter-addr] [grantee-addr] [msg-type-url]? [flags] +``` + +Example: + +```bash +simd query authz grants cosmos1.. cosmos1.. /cosmos.bank.v1beta1.MsgSend +``` + +Example Output: + +```bash +grants: +- authorization: + '@type': /cosmos.bank.v1beta1.SendAuthorization + spend_limit: + - amount: "100" + denom: stake + expiration: "2022-01-01T00:00:00Z" +pagination: null +``` + +#### Transactions + +The `tx` commands allow users to interact with the `authz` module. + +```bash +simd tx authz --help +``` + +##### exec + +The `exec` command allows a grantee to execute a transaction on behalf of granter. + +```bash + simd tx authz exec [tx-json-file] --from [grantee] [flags] +``` + +Example: + +```bash +simd tx authz exec tx.json --from=cosmos1.. +``` + +##### grant + +The `grant` command allows a granter to grant an authorization to a grantee. + +```bash +simd tx authz grant --from [flags] +``` + +Example: + +```bash +simd tx authz grant cosmos1.. send --spend-limit=100stake --from=cosmos1.. +``` + +##### revoke + +The `revoke` command allows a granter to revoke an authorization from a grantee. + +```bash +simd tx authz revoke [grantee] [msg-type-url] --from=[granter] [flags] +``` + +Example: + +```bash +simd tx authz revoke cosmos1.. /cosmos.bank.v1beta1.MsgSend --from=cosmos1.. +``` + +### gRPC + +A user can query the `authz` module using gRPC endpoints. + +#### Grants + +The `Grants` endpoint allows users to query grants for a granter-grantee pair. If the message type URL is set, it selects grants only for that message type. + +```bash +cosmos.authz.v1beta1.Query/Grants +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"granter":"cosmos1..","grantee":"cosmos1..","msg_type_url":"/cosmos.bank.v1beta1.MsgSend"}' \ + localhost:9090 \ + cosmos.authz.v1beta1.Query/Grants +``` + +Example Output: + +```bash +{ + "grants": [ + { + "authorization": { + "@type": "/cosmos.bank.v1beta1.SendAuthorization", + "spendLimit": [ + { + "denom":"stake", + "amount":"100" + } + ] + }, + "expiration": "2022-01-01T00:00:00Z" + } + ] +} +``` + +### REST + +A user can query the `authz` module using REST endpoints. + +```bash +/cosmos/authz/v1beta1/grants +``` + +Example: + +```bash +curl "localhost:1317/cosmos/authz/v1beta1/grants?granter=cosmos1..&grantee=cosmos1..&msg_type_url=/cosmos.bank.v1beta1.MsgSend" +``` + +Example Output: + +```bash +{ + "grants": [ + { + "authorization": { + "@type": "/cosmos.bank.v1beta1.SendAuthorization", + "spend_limit": [ + { + "denom": "stake", + "amount": "100" + } + ] + }, + "expiration": "2022-01-01T00:00:00Z" + } + ], + "pagination": null +} +``` diff --git a/.gitbook/developers/modules/core/bank/README.md b/.gitbook/developers/modules/core/bank/README.md new file mode 100644 index 00000000..a7eba4ae --- /dev/null +++ b/.gitbook/developers/modules/core/bank/README.md @@ -0,0 +1,1039 @@ +--- +sidebar_position: 1 +--- + +# `x/bank` + +## Abstract + +This document specifies the bank module of the Cosmos SDK. + +The bank module is responsible for handling multi-asset coin transfers between +accounts and tracking special-case pseudo-transfers which must work differently +with particular kinds of accounts (notably delegating/undelegating for vesting +accounts). It exposes several interfaces with varying capabilities for secure +interaction with other modules which must alter user balances. + +In addition, the bank module tracks and provides query support for the total +supply of all assets used in the application. + +This module is used in the Cosmos Hub. + +## Contents + +* [Supply](#supply) + * [Total Supply](#total-supply) +* [Module Accounts](#module-accounts) + * [Permissions](#permissions) +* [State](#state) +* [Params](#params) +* [Keepers](#keepers) +* [Messages](#messages) +* [Events](#events) + * [Message Events](#message-events) + * [Keeper Events](#keeper-events) +* [Parameters](#parameters) + * [SendEnabled](#sendenabled) + * [DefaultSendEnabled](#defaultsendenabled) +* [Client](#client) + * [CLI](#cli) + * [Query](#query) + * [Transactions](#transactions) +* [gRPC](#grpc) + +## Supply + +The `supply` functionality: + +* passively tracks the total supply of coins within a chain, +* provides a pattern for modules to hold/interact with `Coins`, and +* introduces the invariant check to verify a chain's total supply. + +### Total Supply + +The total `Supply` of the network is equal to the sum of all coins from the +account. The total supply is updated every time a `Coin` is minted (eg: as part +of the inflation mechanism) or burned (eg: due to slashing or if a governance +proposal is vetoed). + +## Module Accounts + +The supply functionality introduces a new type of `auth.Account` which can be used by +modules to allocate tokens and in special cases mint or burn tokens. At a base +level these module accounts are capable of sending/receiving tokens to and from +`auth.Account`s and other module accounts. This design replaces previous +alternative designs where, to hold tokens, modules would burn the incoming +tokens from the sender account, and then track those tokens internally. Later, +in order to send tokens, the module would need to effectively mint tokens +within a destination account. The new design removes duplicate logic between +modules to perform this accounting. + +The `ModuleAccount` interface is defined as follows: + +```go +type ModuleAccount interface { + auth.Account // same methods as the Account interface + + GetName() string // name of the module; used to obtain the address + GetPermissions() []string // permissions of module account + HasPermission(string) bool +} +``` + +> **WARNING!** +> Any module or message handler that allows either direct or indirect sending of funds must explicitly guarantee those funds cannot be sent to module accounts (unless allowed). + +The supply `Keeper` also introduces new wrapper functions for the auth `Keeper` +and the bank `Keeper` that are related to `ModuleAccount`s in order to be able +to: + +* Get and set `ModuleAccount`s by providing the `Name`. +* Send coins from and to other `ModuleAccount`s or standard `Account`s + (`BaseAccount` or `VestingAccount`) by passing only the `Name`. +* `Mint` or `Burn` coins for a `ModuleAccount` (restricted to its permissions). + +### Permissions + +Each `ModuleAccount` has a different set of permissions that provide different +object capabilities to perform certain actions. Permissions need to be +registered upon the creation of the supply `Keeper` so that every time a +`ModuleAccount` calls the allowed functions, the `Keeper` can lookup the +permissions to that specific account and perform or not perform the action. + +The available permissions are: + +* `Minter`: allows for a module to mint a specific amount of coins. +* `Burner`: allows for a module to burn a specific amount of coins. +* `Staking`: allows for a module to delegate and undelegate a specific amount of coins. + +## State + +The `x/bank` module keeps state of the following primary objects: + +1. Account balances +2. Denomination metadata +3. The total supply of all balances +4. Information on which denominations are allowed to be sent. + +In addition, the `x/bank` module keeps the following indexes to manage the +aforementioned state: + +* Supply Index: `0x0 | byte(denom) -> byte(amount)` +* Denom Metadata Index: `0x1 | byte(denom) -> ProtocolBuffer(Metadata)` +* Balances Index: `0x2 | byte(address length) | []byte(address) | []byte(balance.Denom) -> ProtocolBuffer(balance)` +* Reverse Denomination to Address Index: `0x03 | byte(denom) | 0x00 | []byte(address) -> 0` + +## Params + +The bank module stores it's params in state with the prefix of `0x05`, +it can be updated with governance or the address with authority. + +* Params: `0x05 | ProtocolBuffer(Params)` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/bank/v1beta1/bank.proto#L12-L23 +``` + +## Keepers + +The bank module provides these exported keeper interfaces that can be +passed to other modules that read or update account balances. Modules +should use the least-permissive interface that provides the functionality they +require. + +Best practices dictate careful review of `bank` module code to ensure that +permissions are limited in the way that you expect. + +### Denied Addresses + +The `x/bank` module accepts a map of addresses that are considered blocklisted +from directly and explicitly receiving funds through means such as `MsgSend` and +`MsgMultiSend` and direct API calls like `SendCoinsFromModuleToAccount`. + +Typically, these addresses are module accounts. If these addresses receive funds +outside the expected rules of the state machine, invariants are likely to be +broken and could result in a halted network. + +By providing the `x/bank` module with a blocklisted set of addresses, an error occurs for the operation if a user or client attempts to directly or indirectly send funds to a blocklisted account, for example, by using [IBC](https://ibc.cosmos.network). + +### Common Types + +#### Input + +An input of a multiparty transfer + +```protobuf +// Input models transaction input. +message Input { + string address = 1; + repeated cosmos.base.v1beta1.Coin coins = 2; +} +``` + +#### Output + +An output of a multiparty transfer. + +```protobuf +// Output models transaction outputs. +message Output { + string address = 1; + repeated cosmos.base.v1beta1.Coin coins = 2; +} +``` + +### BaseKeeper + +The base keeper provides full-permission access: the ability to arbitrary modify any account's balance and mint or burn coins. + +Restricted permission to mint per module could be achieved by using baseKeeper with `WithMintCoinsRestriction` to give specific restrictions to mint (e.g. only minting certain denom). + +```go +// Keeper defines a module interface that facilitates the transfer of coins +// between accounts. +type Keeper interface { + SendKeeper + WithMintCoinsRestriction(MintingRestrictionFn) BaseKeeper + + InitGenesis(context.Context, *types.GenesisState) + ExportGenesis(context.Context) *types.GenesisState + + GetSupply(ctx context.Context, denom string) sdk.Coin + HasSupply(ctx context.Context, denom string) bool + GetPaginatedTotalSupply(ctx context.Context, pagination *query.PageRequest) (sdk.Coins, *query.PageResponse, error) + IterateTotalSupply(ctx context.Context, cb func(sdk.Coin) bool) + GetDenomMetaData(ctx context.Context, denom string) (types.Metadata, bool) + HasDenomMetaData(ctx context.Context, denom string) bool + SetDenomMetaData(ctx context.Context, denomMetaData types.Metadata) + IterateAllDenomMetaData(ctx context.Context, cb func(types.Metadata) bool) + + SendCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error + SendCoinsFromModuleToModule(ctx context.Context, senderModule, recipientModule string, amt sdk.Coins) error + SendCoinsFromAccountToModule(ctx context.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error + DelegateCoinsFromAccountToModule(ctx context.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error + UndelegateCoinsFromModuleToAccount(ctx context.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error + MintCoins(ctx context.Context, moduleName string, amt sdk.Coins) error + BurnCoins(ctx context.Context, moduleName string, amt sdk.Coins) error + + DelegateCoins(ctx context.Context, delegatorAddr, moduleAccAddr sdk.AccAddress, amt sdk.Coins) error + UndelegateCoins(ctx context.Context, moduleAccAddr, delegatorAddr sdk.AccAddress, amt sdk.Coins) error + + // GetAuthority gets the address capable of executing governance proposal messages. Usually the gov module account. + GetAuthority() string + + types.QueryServer +} +``` + +### SendKeeper + +The send keeper provides access to account balances and the ability to transfer coins between +accounts. The send keeper does not alter the total supply (mint or burn coins). + +```go +// SendKeeper defines a module interface that facilitates the transfer of coins +// between accounts without the possibility of creating coins. +type SendKeeper interface { + ViewKeeper + + AppendSendRestriction(restriction SendRestrictionFn) + PrependSendRestriction(restriction SendRestrictionFn) + ClearSendRestriction() + + InputOutputCoins(ctx sdk.Context, input types.Input, outputs []types.Output) error + SendCoins(ctx sdk.Context, fromAddr, toAddr sdk.AccAddress, amt sdk.Coins) error + + GetParams(ctx context.Context) types.Params + SetParams(ctx context.Context, params types.Params) error + + IsSendEnabledDenom(ctx context.Context, denom string) bool + SetSendEnabled(ctx context.Context, denom string, value bool) + SetAllSendEnabled(ctx context.Context, sendEnableds []*types.SendEnabled) + DeleteSendEnabled(ctx context.Context, denom string) + IterateSendEnabledEntries(ctx context.Context, cb func(denom string, sendEnabled bool) (stop bool)) + GetAllSendEnabledEntries(ctx context.Context) []types.SendEnabled + + IsSendEnabledCoin(ctx context.Context, coin sdk.Coin) bool + IsSendEnabledCoins(ctx context.Context, coins ...sdk.Coin) error + + BlockedAddr(addr sdk.AccAddress) bool +} +``` + +#### Send Restrictions + +The `SendKeeper` applies a `SendRestrictionFn` before each transfer of funds. + +```golang +// A SendRestrictionFn can restrict sends and/or provide a new receiver address. +type SendRestrictionFn func(ctx context.Context, fromAddr, toAddr sdk.AccAddress, amt sdk.Coins) (newToAddr sdk.AccAddress, err error) +``` + +After the `SendKeeper` (or `BaseKeeper`) has been created, send restrictions can be added to it using the `AppendSendRestriction` or `PrependSendRestriction` functions. +Both functions compose the provided restriction with any previously provided restrictions. +`AppendSendRestriction` adds the provided restriction to be run after any previously provided send restrictions. +`PrependSendRestriction` adds the restriction to be run before any previously provided send restrictions. +The composition will short-circuit when an error is encountered. I.e. if the first one returns an error, the second is not run. + +During `SendCoins`, the send restriction is applied after coins are removed from the from address, but before adding them to the to address. +During `InputOutputCoins`, the send restriction is applied after the input coins are removed and once for each output before the funds are added. + +A send restriction function should make use of a custom value in the context to allow bypassing that specific restriction. + +Send Restrictions are not placed on `ModuleToAccount` or `ModuleToModule` transfers. This is done due to modules needing to move funds to user accounts and other module accounts. This is a design decision to allow for more flexibility in the state machine. The state machine should be able to move funds between module accounts and user accounts without restrictions. + +Secondly this limitation would limit the usage of the state machine even for itself. users would not be able to receive rewards, not be able to move funds between module accounts. In the case that a user sends funds from a user account to the community pool and then a governance proposal is used to get those tokens into the users account this would fall under the discretion of the app chain developer to what they would like to do here. We can not make strong assumptions here. +Thirdly, this issue could lead into a chain halt if a token is disabled and the token is moved in the begin/endblock. This is the last reason we see the current change and more damaging then beneficial for users. + +For example, in your module's keeper package, you'd define the send restriction function: + +```golang +var _ banktypes.SendRestrictionFn = Keeper{}.SendRestrictionFn + +func (k Keeper) SendRestrictionFn(ctx context.Context, fromAddr, toAddr sdk.AccAddress, amt sdk.Coins) (sdk.AccAddress, error) { + // Bypass if the context says to. + if mymodule.HasBypass(ctx) { + return toAddr, nil + } + + // Your custom send restriction logic goes here. + return nil, errors.New("not implemented") +} +``` + +The bank keeper should be provided to your keeper's constructor so the send restriction can be added to it: + +```golang +func NewKeeper(cdc codec.BinaryCodec, storeKey storetypes.StoreKey, bankKeeper mymodule.BankKeeper) Keeper { + rv := Keeper{/*...*/} + bankKeeper.AppendSendRestriction(rv.SendRestrictionFn) + return rv +} +``` + +Then, in the `mymodule` package, define the context helpers: + +```golang +const bypassKey = "bypass-mymodule-restriction" + +// WithBypass returns a new context that will cause the mymodule bank send restriction to be skipped. +func WithBypass(ctx context.Context) context.Context { + return sdk.UnwrapSDKContext(ctx).WithValue(bypassKey, true) +} + +// WithoutBypass returns a new context that will cause the mymodule bank send restriction to not be skipped. +func WithoutBypass(ctx context.Context) context.Context { + return sdk.UnwrapSDKContext(ctx).WithValue(bypassKey, false) +} + +// HasBypass checks the context to see if the mymodule bank send restriction should be skipped. +func HasBypass(ctx context.Context) bool { + bypassValue := ctx.Value(bypassKey) + if bypassValue == nil { + return false + } + bypass, isBool := bypassValue.(bool) + return isBool && bypass +} +``` + +Now, anywhere where you want to use `SendCoins` or `InputOutputCoins`, but you don't want your send restriction applied: + +```golang +func (k Keeper) DoThing(ctx context.Context, fromAddr, toAddr sdk.AccAddress, amt sdk.Coins) error { + return k.bankKeeper.SendCoins(mymodule.WithBypass(ctx), fromAddr, toAddr, amt) +} +``` + +### ViewKeeper + +The view keeper provides read-only access to account balances. The view keeper does not have balance alteration functionality. All balance lookups are `O(1)`. + +```go +// ViewKeeper defines a module interface that facilitates read only access to +// account balances. +type ViewKeeper interface { + ValidateBalance(ctx context.Context, addr sdk.AccAddress) error + HasBalance(ctx context.Context, addr sdk.AccAddress, amt sdk.Coin) bool + + GetAllBalances(ctx context.Context, addr sdk.AccAddress) sdk.Coins + GetAccountsBalances(ctx context.Context) []types.Balance + GetBalance(ctx context.Context, addr sdk.AccAddress, denom string) sdk.Coin + LockedCoins(ctx context.Context, addr sdk.AccAddress) sdk.Coins + SpendableCoins(ctx context.Context, addr sdk.AccAddress) sdk.Coins + SpendableCoin(ctx context.Context, addr sdk.AccAddress, denom string) sdk.Coin + + IterateAccountBalances(ctx context.Context, addr sdk.AccAddress, cb func(coin sdk.Coin) (stop bool)) + IterateAllBalances(ctx context.Context, cb func(address sdk.AccAddress, coin sdk.Coin) (stop bool)) +} +``` + +## Messages + +### MsgSend + +Send coins from one address to another. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/bank/v1beta1/tx.proto#L38-L53 +``` + +The message will fail under the following conditions: + +* The coins do not have sending enabled +* The `to` address is restricted + +### MsgMultiSend + +Send coins from one sender and to a series of different address. If any of the receiving addresses do not correspond to an existing account, a new account is created. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/bank/v1beta1/tx.proto#L58-L69 +``` + +The message will fail under the following conditions: + +* Any of the coins do not have sending enabled +* Any of the `to` addresses are restricted +* Any of the coins are locked +* The inputs and outputs do not correctly correspond to one another + +### MsgUpdateParams + +The `bank` module params can be updated through `MsgUpdateParams`, which can be done using governance proposal. The signer will always be the `gov` module account address. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/bank/v1beta1/tx.proto#L74-L88 +``` + +The message handling can fail if: + +* signer is not the gov module account address. + +### MsgSetSendEnabled + +Used with the x/gov module to set create/edit SendEnabled entries. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/bank/v1beta1/tx.proto#L96-L117 +``` + +The message will fail under the following conditions: + +* The authority is not a bech32 address. +* The authority is not x/gov module's address. +* There are multiple SendEnabled entries with the same Denom. +* One or more SendEnabled entries has an invalid Denom. + +## Events + +The bank module emits the following events: + +### Message Events + +#### MsgSend + +| Type | Attribute Key | Attribute Value | +| -------- | ------------- | ------------------ | +| transfer | recipient | {recipientAddress} | +| transfer | amount | {amount} | +| message | module | bank | +| message | action | send | +| message | sender | {senderAddress} | + +#### MsgMultiSend + +| Type | Attribute Key | Attribute Value | +| -------- | ------------- | ------------------ | +| transfer | recipient | {recipientAddress} | +| transfer | amount | {amount} | +| message | module | bank | +| message | action | multisend | +| message | sender | {senderAddress} | + +### Keeper Events + +In addition to message events, the bank keeper will produce events when the following methods are called (or any method which ends up calling them) + +#### MintCoins + +```json +{ + "type": "coinbase", + "attributes": [ + { + "key": "minter", + "value": "{{sdk.AccAddress of the module minting coins}}", + "index": true + }, + { + "key": "amount", + "value": "{{sdk.Coins being minted}}", + "index": true + } + ] +} +``` + +```json +{ + "type": "coin_received", + "attributes": [ + { + "key": "receiver", + "value": "{{sdk.AccAddress of the module minting coins}}", + "index": true + }, + { + "key": "amount", + "value": "{{sdk.Coins being received}}", + "index": true + } + ] +} +``` + +#### BurnCoins + +```json +{ + "type": "burn", + "attributes": [ + { + "key": "burner", + "value": "{{sdk.AccAddress of the module burning coins}}", + "index": true + }, + { + "key": "amount", + "value": "{{sdk.Coins being burned}}", + "index": true + } + ] +} +``` + +```json +{ + "type": "coin_spent", + "attributes": [ + { + "key": "spender", + "value": "{{sdk.AccAddress of the module burning coins}}", + "index": true + }, + { + "key": "amount", + "value": "{{sdk.Coins being burned}}", + "index": true + } + ] +} +``` + +#### addCoins + +```json +{ + "type": "coin_received", + "attributes": [ + { + "key": "receiver", + "value": "{{sdk.AccAddress of the address beneficiary of the coins}}", + "index": true + }, + { + "key": "amount", + "value": "{{sdk.Coins being received}}", + "index": true + } + ] +} +``` + +#### subUnlockedCoins/DelegateCoins + +```json +{ + "type": "coin_spent", + "attributes": [ + { + "key": "spender", + "value": "{{sdk.AccAddress of the address which is spending coins}}", + "index": true + }, + { + "key": "amount", + "value": "{{sdk.Coins being spent}}", + "index": true + } + ] +} +``` + +## Parameters + +The bank module contains the following parameters + +### SendEnabled + +The SendEnabled parameter is now deprecated and not to be use. It is replaced +with state store records. + + +### DefaultSendEnabled + +The default send enabled value controls send transfer capability for all +coin denominations unless specifically included in the array of `SendEnabled` +parameters. + +## Client + +### CLI + +A user can query and interact with the `bank` module using the CLI. + +#### Query + +The `query` commands allow users to query `bank` state. + +```shell +simd query bank --help +``` + +##### balances + +The `balances` command allows users to query account balances by address. + +```shell +simd query bank balances [address] [flags] +``` + +Example: + +```shell +simd query bank balances cosmos1.. +``` + +Example Output: + +```yml +balances: +- amount: "1000000000" + denom: stake +pagination: + next_key: null + total: "0" +``` + +##### denom-metadata + +The `denom-metadata` command allows users to query metadata for coin denominations. A user can query metadata for a single denomination using the `--denom` flag or all denominations without it. + +```shell +simd query bank denom-metadata [flags] +``` + +Example: + +```shell +simd query bank denom-metadata --denom stake +``` + +Example Output: + +```yml +metadata: + base: stake + denom_units: + - aliases: + - STAKE + denom: stake + description: native staking token of simulation app + display: stake + name: SimApp Token + symbol: STK +``` + +##### total + +The `total` command allows users to query the total supply of coins. A user can query the total supply for a single coin using the `--denom` flag or all coins without it. + +```shell +simd query bank total [flags] +``` + +Example: + +```shell +simd query bank total --denom stake +``` + +Example Output: + +```yml +amount: "10000000000" +denom: stake +``` + +##### send-enabled + +The `send-enabled` command allows users to query for all or some SendEnabled entries. + +```shell +simd query bank send-enabled [denom1 ...] [flags] +``` + +Example: + +```shell +simd query bank send-enabled +``` + +Example output: + +```yml +send_enabled: +- denom: foocoin + enabled: true +- denom: barcoin +pagination: + next-key: null + total: 2 +``` + +#### Transactions + +The `tx` commands allow users to interact with the `bank` module. + +```shell +simd tx bank --help +``` + +##### send + +The `send` command allows users to send funds from one account to another. + +```shell +simd tx bank send [from_key_or_address] [to_address] [amount] [flags] +``` + +Example: + +```shell +simd tx bank send cosmos1.. cosmos1.. 100stake +``` + +## gRPC + +A user can query the `bank` module using gRPC endpoints. + +### Balance + +The `Balance` endpoint allows users to query account balance by address for a given denomination. + +```shell +cosmos.bank.v1beta1.Query/Balance +``` + +Example: + +```shell +grpcurl -plaintext \ + -d '{"address":"cosmos1..","denom":"stake"}' \ + localhost:9090 \ + cosmos.bank.v1beta1.Query/Balance +``` + +Example Output: + +```json +{ + "balance": { + "denom": "stake", + "amount": "1000000000" + } +} +``` + +### AllBalances + +The `AllBalances` endpoint allows users to query account balance by address for all denominations. + +```shell +cosmos.bank.v1beta1.Query/AllBalances +``` + +Example: + +```shell +grpcurl -plaintext \ + -d '{"address":"cosmos1.."}' \ + localhost:9090 \ + cosmos.bank.v1beta1.Query/AllBalances +``` + +Example Output: + +```json +{ + "balances": [ + { + "denom": "stake", + "amount": "1000000000" + } + ], + "pagination": { + "total": "1" + } +} +``` + +### DenomMetadata + +The `DenomMetadata` endpoint allows users to query metadata for a single coin denomination. + +```shell +cosmos.bank.v1beta1.Query/DenomMetadata +``` + +Example: + +```shell +grpcurl -plaintext \ + -d '{"denom":"stake"}' \ + localhost:9090 \ + cosmos.bank.v1beta1.Query/DenomMetadata +``` + +Example Output: + +```json +{ + "metadata": { + "description": "native staking token of simulation app", + "denomUnits": [ + { + "denom": "stake", + "aliases": [ + "STAKE" + ] + } + ], + "base": "stake", + "display": "stake", + "name": "SimApp Token", + "symbol": "STK" + } +} +``` + +### DenomsMetadata + +The `DenomsMetadata` endpoint allows users to query metadata for all coin denominations. + +```shell +cosmos.bank.v1beta1.Query/DenomsMetadata +``` + +Example: + +```shell +grpcurl -plaintext \ + localhost:9090 \ + cosmos.bank.v1beta1.Query/DenomsMetadata +``` + +Example Output: + +```json +{ + "metadatas": [ + { + "description": "native staking token of simulation app", + "denomUnits": [ + { + "denom": "stake", + "aliases": [ + "STAKE" + ] + } + ], + "base": "stake", + "display": "stake", + "name": "SimApp Token", + "symbol": "STK" + } + ], + "pagination": { + "total": "1" + } +} +``` + +### DenomOwners + +The `DenomOwners` endpoint allows users to query metadata for a single coin denomination. + +```shell +cosmos.bank.v1beta1.Query/DenomOwners +``` + +Example: + +```shell +grpcurl -plaintext \ + -d '{"denom":"stake"}' \ + localhost:9090 \ + cosmos.bank.v1beta1.Query/DenomOwners +``` + +Example Output: + +```json +{ + "denomOwners": [ + { + "address": "cosmos1..", + "balance": { + "denom": "stake", + "amount": "5000000000" + } + }, + { + "address": "cosmos1..", + "balance": { + "denom": "stake", + "amount": "5000000000" + } + }, + ], + "pagination": { + "total": "2" + } +} +``` + +### TotalSupply + +The `TotalSupply` endpoint allows users to query the total supply of all coins. + +```shell +cosmos.bank.v1beta1.Query/TotalSupply +``` + +Example: + +```shell +grpcurl -plaintext \ + localhost:9090 \ + cosmos.bank.v1beta1.Query/TotalSupply +``` + +Example Output: + +```json +{ + "supply": [ + { + "denom": "stake", + "amount": "10000000000" + } + ], + "pagination": { + "total": "1" + } +} +``` + +### SupplyOf + +The `SupplyOf` endpoint allows users to query the total supply of a single coin. + +```shell +cosmos.bank.v1beta1.Query/SupplyOf +``` + +Example: + +```shell +grpcurl -plaintext \ + -d '{"denom":"stake"}' \ + localhost:9090 \ + cosmos.bank.v1beta1.Query/SupplyOf +``` + +Example Output: + +```json +{ + "amount": { + "denom": "stake", + "amount": "10000000000" + } +} +``` + +### Params + +The `Params` endpoint allows users to query the parameters of the `bank` module. + +```shell +cosmos.bank.v1beta1.Query/Params +``` + +Example: + +```shell +grpcurl -plaintext \ + localhost:9090 \ + cosmos.bank.v1beta1.Query/Params +``` + +Example Output: + +```json +{ + "params": { + "defaultSendEnabled": true + } +} +``` + +### SendEnabled + +The `SendEnabled` enpoints allows users to query the SendEnabled entries of the `bank` module. + +Any denominations NOT returned, use the `Params.DefaultSendEnabled` value. + +```shell +cosmos.bank.v1beta1.Query/SendEnabled +``` + +Example: + +```shell +grpcurl -plaintext \ + localhost:9090 \ + cosmos.bank.v1beta1.Query/SendEnabled +``` + +Example Output: + +```json +{ + "send_enabled": [ + { + "denom": "foocoin", + "enabled": true + }, + { + "denom": "barcoin" + } + ], + "pagination": { + "next-key": null, + "total": 2 + } +} +``` diff --git a/.gitbook/developers/modules/core/circuit/README.md b/.gitbook/developers/modules/core/circuit/README.md new file mode 100644 index 00000000..f3b75389 --- /dev/null +++ b/.gitbook/developers/modules/core/circuit/README.md @@ -0,0 +1,170 @@ +# `x/circuit` + +## Concepts + +Circuit Breaker is a module that is meant to avoid a chain needing to halt/shut down in the presence of a vulnerability, instead the module will allow specific messages or all messages to be disabled. When operating a chain, if it is app specific then a halt of the chain is less detrimental, but if there are applications built on top of the chain then halting is expensive due to the disturbance to applications. + +Circuit Breaker works with the idea that an address or set of addresses have the right to block messages from being executed and/or included in the mempool. Any address with a permission is able to reset the circuit breaker for the message. + +The transactions are checked and can be rejected at two points: + +* In `CircuitBreakerDecorator` [ante handler](https://docs.cosmos.network/main/learn/advanced/baseapp#antehandler): + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/x/circuit/v0.1.0/x/circuit/ante/circuit.go#L27-L41 +``` + +* With a [message router check](https://docs.cosmos.network/main/learn/advanced/baseapp#msg-service-router): + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.50.1/baseapp/msg_service_router.go#L104-L115 +``` + +:::note +The `CircuitBreakerDecorator` works for most use cases, but [does not check the inner messages of a transaction](https://docs.cosmos.network/main/learn/beginner/tx-lifecycle#antehandler). This some transactions (such as `x/authz` transactions or some `x/gov` transactions) may pass the ante handler. **This does not affect the circuit breaker** as the message router check will still fail the transaction. +This tradeoff is to avoid introducing more dependencies in the `x/circuit` module. Chains can re-define the `CircuitBreakerDecorator` to check for inner messages if they wish to do so. +::: + +## State + +### Accounts + +* AccountPermissions `0x1 | account_address -> ProtocolBuffer(CircuitBreakerPermissions)` + +```go +type level int32 + +const ( + // LEVEL_NONE_UNSPECIFIED indicates that the account will have no circuit + // breaker permissions. + LEVEL_NONE_UNSPECIFIED = iota + // LEVEL_SOME_MSGS indicates that the account will have permission to + // trip or reset the circuit breaker for some Msg type URLs. If this level + // is chosen, a non-empty list of Msg type URLs must be provided in + // limit_type_urls. + LEVEL_SOME_MSGS + // LEVEL_ALL_MSGS indicates that the account can trip or reset the circuit + // breaker for Msg's of all type URLs. + LEVEL_ALL_MSGS + // LEVEL_SUPER_ADMIN indicates that the account can take all circuit breaker + // actions and can grant permissions to other accounts. + LEVEL_SUPER_ADMIN +) + +type Access struct { + level int32 + msgs []string // if full permission, msgs can be empty +} +``` + + +### Disable List + +List of type urls that are disabled. + +* DisableList `0x2 | msg_type_url -> []byte{}` + +## State Transitions + +### Authorize + +Authorize, is called by the module authority (default governance module account) or any account with `LEVEL_SUPER_ADMIN` to give permission to disable/enable messages to another account. There are three levels of permissions that can be granted. `LEVEL_SOME_MSGS` limits the number of messages that can be disabled. `LEVEL_ALL_MSGS` permits all messages to be disabled. `LEVEL_SUPER_ADMIN` allows an account to take all circuit breaker actions including authorizing and deauthorizing other accounts. + +```protobuf + // AuthorizeCircuitBreaker allows a super-admin to grant (or revoke) another + // account's circuit breaker permissions. + rpc AuthorizeCircuitBreaker(MsgAuthorizeCircuitBreaker) returns (MsgAuthorizeCircuitBreakerResponse); +``` + +### Trip + +Trip, is called by an authorized account to disable message execution for a specific msgURL. If empty, all the msgs will be disabled. + +```protobuf + // TripCircuitBreaker pauses processing of Msg's in the state machine. + rpc TripCircuitBreaker(MsgTripCircuitBreaker) returns (MsgTripCircuitBreakerResponse); +``` + +### Reset + +Reset is called by an authorized account to enable execution for a specific msgURL of previously disabled message. If empty, all the disabled messages will be enabled. + +```protobuf + // ResetCircuitBreaker resumes processing of Msg's in the state machine that + // have been been paused using TripCircuitBreaker. + rpc ResetCircuitBreaker(MsgResetCircuitBreaker) returns (MsgResetCircuitBreakerResponse); +``` + +## Messages + +### MsgAuthorizeCircuitBreaker + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/main/proto/cosmos/circuit/v1/tx.proto#L25-L75 +``` + +This message is expected to fail if: + +* the granter is not an account with permission level `LEVEL_SUPER_ADMIN` or the module authority + +### MsgTripCircuitBreaker + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/main/proto/cosmos/circuit/v1/tx.proto#L77-L93 +``` + +This message is expected to fail if: + +* if the signer does not have a permission level with the ability to disable the specified type url message + +### MsgResetCircuitBreaker + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/main/proto/cosmos/circuit/v1/tx.proto#L95-109 +``` + +This message is expected to fail if: + +* if the type url is not disabled + +## Events - list and describe event tags + +The circuit module emits the following events: + +### Message Events + +#### MsgAuthorizeCircuitBreaker + +| Type | Attribute Key | Attribute Value | +|---------|---------------|---------------------------| +| string | granter | {granterAddress} | +| string | grantee | {granteeAddress} | +| string | permission | {granteePermissions} | +| message | module | circuit | +| message | action | authorize_circuit_breaker | + +#### MsgTripCircuitBreaker + +| Type | Attribute Key | Attribute Value | +|----------|---------------|--------------------| +| string | authority | {authorityAddress} | +| []string | msg_urls | []string{msg_urls} | +| message | module | circuit | +| message | action | trip_circuit_breaker | + +#### ResetCircuitBreaker + +| Type | Attribute Key | Attribute Value | +|----------|---------------|--------------------| +| string | authority | {authorityAddress} | +| []string | msg_urls | []string{msg_urls} | +| message | module | circuit | +| message | action | reset_circuit_breaker | + + +## Keys - list of key prefixes used by the circuit module + +* `AccountPermissionPrefix` - `0x01` +* `DisableListPrefix` - `0x02` + +## Client - list and describe CLI commands and gRPC and REST endpoints diff --git a/.gitbook/developers/modules/core/consensus/README.md b/.gitbook/developers/modules/core/consensus/README.md new file mode 100644 index 00000000..902280a6 --- /dev/null +++ b/.gitbook/developers/modules/core/consensus/README.md @@ -0,0 +1,7 @@ +--- +sidebar_position: 1 +--- + +# `x/consensus` + +Functionality to modify CometBFT's ABCI consensus params. diff --git a/.gitbook/developers/modules/core/crisis/README.md b/.gitbook/developers/modules/core/crisis/README.md new file mode 100644 index 00000000..e4e29d0a --- /dev/null +++ b/.gitbook/developers/modules/core/crisis/README.md @@ -0,0 +1,110 @@ +--- +sidebar_position: 1 +--- + +# `x/crisis` + +## Overview + +The crisis module halts the blockchain under the circumstance that a blockchain +invariant is broken. Invariants can be registered with the application during the +application initialization process. + +## Contents + +* [State](#state) +* [Messages](#messages) +* [Events](#events) +* [Parameters](#parameters) +* [Client](#client) + * [CLI](#cli) + +## State + +### ConstantFee + +Due to the anticipated large gas cost requirement to verify an invariant (and +potential to exceed the maximum allowable block gas limit) a constant fee is +used instead of the standard gas consumption method. The constant fee is +intended to be larger than the anticipated gas cost of running the invariant +with the standard gas consumption method. + +The ConstantFee param is stored in the module params state with the prefix of `0x01`, +it can be updated with governance or the address with authority. + +* Params: `mint/params -> legacy_amino(sdk.Coin)` + +## Messages + +In this section we describe the processing of the crisis messages and the +corresponding updates to the state. + +### MsgVerifyInvariant + +Blockchain invariants can be checked using the `MsgVerifyInvariant` message. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/crisis/v1beta1/tx.proto#L26-L42 +``` + +This message is expected to fail if: + +* the sender does not have enough coins for the constant fee +* the invariant route is not registered + +This message checks the invariant provided, and if the invariant is broken it +panics, halting the blockchain. If the invariant is broken, the constant fee is +never deducted as the transaction is never committed to a block (equivalent to +being refunded). However, if the invariant is not broken, the constant fee will +not be refunded. + +## Events + +The crisis module emits the following events: + +### Handlers + +#### MsgVerifyInvariance + +| Type | Attribute Key | Attribute Value | +|-----------|---------------|------------------| +| invariant | route | {invariantRoute} | +| message | module | crisis | +| message | action | verify_invariant | +| message | sender | {senderAddress} | + +## Parameters + +The crisis module contains the following parameters: + +| Key | Type | Example | +|-------------|---------------|-----------------------------------| +| ConstantFee | object (coin) | {"denom":"uatom","amount":"1000"} | + +## Client + +### CLI + +A user can query and interact with the `crisis` module using the CLI. + +#### Transactions + +The `tx` commands allow users to interact with the `crisis` module. + +```bash +simd tx crisis --help +``` + +##### invariant-broken + +The `invariant-broken` command submits proof when an invariant was broken to halt the chain + +```bash +simd tx crisis invariant-broken [module-name] [invariant-route] [flags] +``` + +Example: + +```bash +simd tx crisis invariant-broken bank total-supply --from=[keyname or address] +``` diff --git a/.gitbook/developers/modules/core/distribution/README.md b/.gitbook/developers/modules/core/distribution/README.md new file mode 100644 index 00000000..32858fd6 --- /dev/null +++ b/.gitbook/developers/modules/core/distribution/README.md @@ -0,0 +1,1049 @@ +--- +sidebar_position: 1 +--- + +# `x/distribution` + +## Overview + +This _simple_ distribution mechanism describes a functional way to passively +distribute rewards between validators and delegators. Note that this mechanism does +not distribute funds in as precisely as active reward distribution mechanisms and +will therefore be upgraded in the future. + +The mechanism operates as follows. Collected rewards are pooled globally and +divided out passively to validators and delegators. Each validator has the +opportunity to charge commission to the delegators on the rewards collected on +behalf of the delegators. Fees are collected directly into a global reward pool +and validator proposer-reward pool. Due to the nature of passive accounting, +whenever changes to parameters which affect the rate of reward distribution +occurs, withdrawal of rewards must also occur. + +* Whenever withdrawing, one must withdraw the maximum amount they are entitled + to, leaving nothing in the pool. +* Whenever bonding, unbonding, or re-delegating tokens to an existing account, a + full withdrawal of the rewards must occur (as the rules for lazy accounting + change). +* Whenever a validator chooses to change the commission on rewards, all accumulated + commission rewards must be simultaneously withdrawn. + +The above scenarios are covered in `hooks.md`. + +The distribution mechanism outlined herein is used to lazily distribute the +following rewards between validators and associated delegators: + +* multi-token fees to be socially distributed +* inflated staked asset provisions +* validator commission on all rewards earned by their delegators stake + +Fees are pooled within a global pool. The mechanisms used allow for validators +and delegators to independently and lazily withdraw their rewards. + +## Shortcomings + +As a part of the lazy computations, each delegator holds an accumulation term +specific to each validator which is used to estimate what their approximate +fair portion of tokens held in the global fee pool is owed to them. + +```text +entitlement = delegator-accumulation / all-delegators-accumulation +``` + +Under the circumstance that there was constant and equal flow of incoming +reward tokens every block, this distribution mechanism would be equal to the +active distribution (distribute individually to all delegators each block). +However, this is unrealistic so deviations from the active distribution will +occur based on fluctuations of incoming reward tokens as well as timing of +reward withdrawal by other delegators. + +If you happen to know that incoming rewards are about to significantly increase, +you are incentivized to not withdraw until after this event, increasing the +worth of your existing _accum_. See [#2764](https://github.com/cosmos/cosmos-sdk/issues/2764) +for further details. + +## Effect on Staking + +Charging commission on Atom provisions while also allowing for Atom-provisions +to be auto-bonded (distributed directly to the validators bonded stake) is +problematic within BPoS. Fundamentally, these two mechanisms are mutually +exclusive. If both commission and auto-bonding mechanisms are simultaneously +applied to the staking-token then the distribution of staking-tokens between +any validator and its delegators will change with each block. This then +necessitates a calculation for each delegation records for each block - +which is considered computationally expensive. + +In conclusion, we can only have Atom commission and unbonded atoms +provisions or bonded atom provisions with no Atom commission, and we elect to +implement the former. Stakeholders wishing to rebond their provisions may elect +to set up a script to periodically withdraw and rebond rewards. + +## Contents + +* [Concepts](#concepts) +* [State](#state) + * [FeePool](#feepool) + * [Validator Distribution](#validator-distribution) + * [Delegation Distribution](#delegation-distribution) + * [Params](#params) +* [Begin Block](#begin-block) +* [Messages](#messages) +* [Hooks](#hooks) +* [Events](#events) +* [Parameters](#parameters) +* [Client](#client) + * [CLI](#cli) + * [gRPC](#grpc) + +## Concepts + +In Proof of Stake (PoS) blockchains, rewards gained from transaction fees are paid to validators. The fee distribution module fairly distributes the rewards to the validators' constituent delegators. + +Rewards are calculated per period. The period is updated each time a validator's delegation changes, for example, when the validator receives a new delegation. +The rewards for a single validator can then be calculated by taking the total rewards for the period before the delegation started, minus the current total rewards. +To learn more, see the [F1 Fee Distribution paper](https://github.com/cosmos/cosmos-sdk/tree/main/docs/spec/fee_distribution/f1_fee_distr.pdf). + +The commission to the validator is paid when the validator is removed or when the validator requests a withdrawal. +The commission is calculated and incremented at every `BeginBlock` operation to update accumulated fee amounts. + +The rewards to a delegator are distributed when the delegation is changed or removed, or a withdrawal is requested. +Before rewards are distributed, all slashes to the validator that occurred during the current delegation are applied. + +### Reference Counting in F1 Fee Distribution + +In F1 fee distribution, the rewards a delegator receives are calculated when their delegation is withdrawn. This calculation must read the terms of the summation of rewards divided by the share of tokens from the period which they ended when they delegated, and the final period that was created for the withdrawal. + +Additionally, as slashes change the amount of tokens a delegation will have (but we calculate this lazily, +only when a delegator un-delegates), we must calculate rewards in separate periods before / after any slashes +which occurred in between when a delegator delegated and when they withdrew their rewards. Thus slashes, like +delegations, reference the period which was ended by the slash event. + +All stored historical rewards records for periods which are no longer referenced by any delegations +or any slashes can thus be safely removed, as they will never be read (future delegations and future +slashes will always reference future periods). This is implemented by tracking a `ReferenceCount` +along with each historical reward storage entry. Each time a new object (delegation or slash) +is created which might need to reference the historical record, the reference count is incremented. +Each time one object which previously needed to reference the historical record is deleted, the reference +count is decremented. If the reference count hits zero, the historical record is deleted. + +## State + +### FeePool + +All globally tracked parameters for distribution are stored within +`FeePool`. Rewards are collected and added to the reward pool and +distributed to validators/delegators from here. + +Note that the reward pool holds decimal coins (`DecCoins`) to allow +for fractions of coins to be received from operations like inflation. +When coins are distributed from the pool they are truncated back to +`sdk.Coins` which are non-decimal. + +* FeePool: `0x00 -> ProtocolBuffer(FeePool)` + +```go +// coins with decimal +type DecCoins []DecCoin + +type DecCoin struct { + Amount math.LegacyDec + Denom string +} +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/distribution/v1beta1/distribution.proto#L116-L123 +``` + +### Validator Distribution + +Validator distribution information for the relevant validator is updated each time: + +1. delegation amount to a validator is updated, +2. any delegator withdraws from a validator, or +3. the validator withdraws its commission. + +* ValidatorDistInfo: `0x02 | ValOperatorAddrLen (1 byte) | ValOperatorAddr -> ProtocolBuffer(validatorDistribution)` + +```go +type ValidatorDistInfo struct { + OperatorAddress sdk.AccAddress + SelfBondRewards sdkmath.DecCoins + ValidatorCommission types.ValidatorAccumulatedCommission +} +``` + +### Delegation Distribution + +Each delegation distribution only needs to record the height at which it last +withdrew fees. Because a delegation must withdraw fees each time it's +properties change (aka bonded tokens etc.) its properties will remain constant +and the delegator's _accumulation_ factor can be calculated passively knowing +only the height of the last withdrawal and its current properties. + +* DelegationDistInfo: `0x02 | DelegatorAddrLen (1 byte) | DelegatorAddr | ValOperatorAddrLen (1 byte) | ValOperatorAddr -> ProtocolBuffer(delegatorDist)` + +```go +type DelegationDistInfo struct { + WithdrawalHeight int64 // last time this delegation withdrew rewards +} +``` + +### Params + +The distribution module stores it's params in state with the prefix of `0x09`, +it can be updated with governance or the address with authority. + +* Params: `0x09 | ProtocolBuffer(Params)` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/distribution/v1beta1/distribution.proto#L12-L42 +``` + +## Begin Block + +At each `BeginBlock`, all fees received in the previous block are transferred to +the distribution `ModuleAccount` account. When a delegator or validator +withdraws their rewards, they are taken out of the `ModuleAccount`. During begin +block, the different claims on the fees collected are updated as follows: + +* The reserve community tax is charged. +* The remainder is distributed proportionally by voting power to all bonded validators + +### The Distribution Scheme + +See [params](#params) for description of parameters. + +Let `fees` be the total fees collected in the previous block, including +inflationary rewards to the stake. All fees are collected in a specific module +account during the block. During `BeginBlock`, they are sent to the +`"distribution"` `ModuleAccount`. No other sending of tokens occurs. Instead, the +rewards each account is entitled to are stored, and withdrawals can be triggered +through the messages `FundCommunityPool`, `WithdrawValidatorCommission` and +`WithdrawDelegatorReward`. + +#### Reward to the Community Pool + +The community pool gets `community_tax * fees`, plus any remaining dust after +validators get their rewards that are always rounded down to the nearest +integer value. + +#### Reward To the Validators + +The proposer receives no extra rewards. All fees are distributed among all the +bonded validators, including the proposer, in proportion to their consensus power. + +```text +powFrac = validator power / total bonded validator power +voteMul = 1 - community_tax +``` + +All validators receive `fees * voteMul * powFrac`. + +#### Rewards to Delegators + +Each validator's rewards are distributed to its delegators. The validator also +has a self-delegation that is treated like a regular delegation in +distribution calculations. + +The validator sets a commission rate. The commission rate is flexible, but each +validator sets a maximum rate and a maximum daily increase. These maximums cannot be exceeded and protect delegators from sudden increases of validator commission rates to prevent validators from taking all of the rewards. + +The outstanding rewards that the operator is entitled to are stored in +`ValidatorAccumulatedCommission`, while the rewards the delegators are entitled +to are stored in `ValidatorCurrentRewards`. The [F1 fee distribution scheme](#concepts) is used to calculate the rewards per delegator as they +withdraw or update their delegation, and is thus not handled in `BeginBlock`. + +#### Example Distribution + +For this example distribution, the underlying consensus engine selects block proposers in +proportion to their power relative to the entire bonded power. + +All validators are equally performant at including pre-commits in their proposed +blocks. Then hold `(pre_commits included) / (total bonded validator power)` +constant so that the amortized block reward for the validator is `( validator power / total bonded power) * (1 - community tax rate)` of +the total rewards. Consequently, the reward for a single delegator is: + +```text +(delegator proportion of the validator power / validator power) * (validator power / total bonded power) + * (1 - community tax rate) * (1 - validator commission rate) += (delegator proportion of the validator power / total bonded power) * (1 - +community tax rate) * (1 - validator commission rate) +``` + +## Messages + +### MsgSetWithdrawAddress + +By default, the withdraw address is the delegator address. To change its withdraw address, a delegator must send a `MsgSetWithdrawAddress` message. +Changing the withdraw address is possible only if the parameter `WithdrawAddrEnabled` is set to `true`. + +The withdraw address cannot be any of the module accounts. These accounts are blocked from being withdraw addresses by being added to the distribution keeper's `blockedAddrs` array at initialization. + +Response: + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/distribution/v1beta1/tx.proto#L49-L60 +``` + +```go +func (k Keeper) SetWithdrawAddr(ctx context.Context, delegatorAddr sdk.AccAddress, withdrawAddr sdk.AccAddress) error + if k.blockedAddrs[withdrawAddr.String()] { + fail with "`{withdrawAddr}` is not allowed to receive external funds" + } + + if !k.GetWithdrawAddrEnabled(ctx) { + fail with `ErrSetWithdrawAddrDisabled` + } + + k.SetDelegatorWithdrawAddr(ctx, delegatorAddr, withdrawAddr) +``` + +### MsgWithdrawDelegatorReward + +A delegator can withdraw its rewards. +Internally in the distribution module, this transaction simultaneously removes the previous delegation with associated rewards, the same as if the delegator simply started a new delegation of the same value. +The rewards are sent immediately from the distribution `ModuleAccount` to the withdraw address. +Any remainder (truncated decimals) are sent to the community pool. +The starting height of the delegation is set to the current validator period, and the reference count for the previous period is decremented. +The amount withdrawn is deducted from the `ValidatorOutstandingRewards` variable for the validator. + +In the F1 distribution, the total rewards are calculated per validator period, and a delegator receives a piece of those rewards in proportion to their stake in the validator. +In basic F1, the total rewards that all the delegators are entitled to between to periods is calculated the following way. +Let `R(X)` be the total accumulated rewards up to period `X` divided by the tokens staked at that time. The delegator allocation is `R(X) * delegator_stake`. +Then the rewards for all the delegators for staking between periods `A` and `B` are `(R(B) - R(A)) * total stake`. +However, these calculated rewards don't account for slashing. + +Taking the slashes into account requires iteration. +Let `F(X)` be the fraction a validator is to be slashed for a slashing event that happened at period `X`. +If the validator was slashed at periods `P1, ..., PN`, where `A < P1`, `PN < B`, the distribution module calculates the individual delegator's rewards, `T(A, B)`, as follows: + +```go +stake := initial stake +rewards := 0 +previous := A +for P in P1, ..., PN`: + rewards = (R(P) - previous) * stake + stake = stake * F(P) + previous = P +rewards = rewards + (R(B) - R(PN)) * stake +``` + +The historical rewards are calculated retroactively by playing back all the slashes and then attenuating the delegator's stake at each step. +The final calculated stake is equivalent to the actual staked coins in the delegation with a margin of error due to rounding errors. + +Response: + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/distribution/v1beta1/tx.proto#L66-L77 +``` + +### WithdrawValidatorCommission + +The validator can send the WithdrawValidatorCommission message to withdraw their accumulated commission. +The commission is calculated in every block during `BeginBlock`, so no iteration is required to withdraw. +The amount withdrawn is deducted from the `ValidatorOutstandingRewards` variable for the validator. +Only integer amounts can be sent. If the accumulated awards have decimals, the amount is truncated before the withdrawal is sent, and the remainder is left to be withdrawn later. + +### FundCommunityPool + +This message sends coins directly from the sender to the community pool. + +The transaction fails if the amount cannot be transferred from the sender to the distribution module account. + +```go +func (k Keeper) FundCommunityPool(ctx context.Context, amount sdk.Coins, sender sdk.AccAddress) error { + if err := k.bankKeeper.SendCoinsFromAccountToModule(ctx, sender, types.ModuleName, amount); err != nil { + return err + } + + feePool, err := k.FeePool.Get(ctx) + if err != nil { + return err + } + + feePool.CommunityPool = feePool.CommunityPool.Add(sdk.NewDecCoinsFromCoins(amount...)...) + + if err := k.FeePool.Set(ctx, feePool); err != nil { + return err + } + + return nil +} +``` + +### Common distribution operations + +These operations take place during many different messages. + +#### Initialize delegation + +Each time a delegation is changed, the rewards are withdrawn and the delegation is reinitialized. +Initializing a delegation increments the validator period and keeps track of the starting period of the delegation. + +```go +// initialize starting info for a new delegation +func (k Keeper) initializeDelegation(ctx context.Context, val sdk.ValAddress, del sdk.AccAddress) { + // period has already been incremented - we want to store the period ended by this delegation action + previousPeriod := k.GetValidatorCurrentRewards(ctx, val).Period - 1 + + // increment reference count for the period we're going to track + k.incrementReferenceCount(ctx, val, previousPeriod) + + validator := k.stakingKeeper.Validator(ctx, val) + delegation := k.stakingKeeper.Delegation(ctx, del, val) + + // calculate delegation stake in tokens + // we don't store directly, so multiply delegation shares * (tokens per share) + // note: necessary to truncate so we don't allow withdrawing more rewards than owed + stake := validator.TokensFromSharesTruncated(delegation.GetShares()) + k.SetDelegatorStartingInfo(ctx, val, del, types.NewDelegatorStartingInfo(previousPeriod, stake, uint64(ctx.BlockHeight()))) +} +``` + +### MsgUpdateParams + +Distribution module params can be updated through `MsgUpdateParams`, which can be done using governance proposal and the signer will always be gov module account address. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/distribution/v1beta1/tx.proto#L133-L147 +``` + +The message handling can fail if: + +* signer is not the gov module account address. + +## Hooks + +Available hooks that can be called by and from this module. + +### Create or modify delegation distribution + +* triggered-by: `staking.MsgDelegate`, `staking.MsgBeginRedelegate`, `staking.MsgUndelegate` + +#### Before + +* The delegation rewards are withdrawn to the withdraw address of the delegator. + The rewards include the current period and exclude the starting period. +* The validator period is incremented. + The validator period is incremented because the validator's power and share distribution might have changed. +* The reference count for the delegator's starting period is decremented. + +#### After + +The starting height of the delegation is set to the previous period. +Because of the `Before`-hook, this period is the last period for which the delegator was rewarded. + +### Validator created + +* triggered-by: `staking.MsgCreateValidator` + +When a validator is created, the following validator variables are initialized: + +* Historical rewards +* Current accumulated rewards +* Accumulated commission +* Total outstanding rewards +* Period + +By default, all values are set to a `0`, except period, which is set to `1`. + +### Validator removed + +* triggered-by: `staking.RemoveValidator` + +Outstanding commission is sent to the validator's self-delegation withdrawal address. +Remaining delegator rewards get sent to the community fee pool. + +Note: The validator gets removed only when it has no remaining delegations. +At that time, all outstanding delegator rewards will have been withdrawn. +Any remaining rewards are dust amounts. + +### Validator is slashed + +* triggered-by: `staking.Slash` +* The current validator period reference count is incremented. + The reference count is incremented because the slash event has created a reference to it. +* The validator period is incremented. +* The slash event is stored for later use. + The slash event will be referenced when calculating delegator rewards. + +## Events + +The distribution module emits the following events: + +### BeginBlocker + +| Type | Attribute Key | Attribute Value | +|-----------------|---------------|--------------------| +| proposer_reward | validator | {validatorAddress} | +| proposer_reward | reward | {proposerReward} | +| commission | amount | {commissionAmount} | +| commission | validator | {validatorAddress} | +| rewards | amount | {rewardAmount} | +| rewards | validator | {validatorAddress} | + +### Handlers + +#### MsgSetWithdrawAddress + +| Type | Attribute Key | Attribute Value | +|----------------------|------------------|----------------------| +| set_withdraw_address | withdraw_address | {withdrawAddress} | +| message | module | distribution | +| message | action | set_withdraw_address | +| message | sender | {senderAddress} | + +#### MsgWithdrawDelegatorReward + +| Type | Attribute Key | Attribute Value | +|---------|---------------|---------------------------| +| withdraw_rewards | amount | {rewardAmount} | +| withdraw_rewards | validator | {validatorAddress} | +| message | module | distribution | +| message | action | withdraw_delegator_reward | +| message | sender | {senderAddress} | + +#### MsgWithdrawValidatorCommission + +| Type | Attribute Key | Attribute Value | +|------------|---------------|-------------------------------| +| withdraw_commission | amount | {commissionAmount} | +| message | module | distribution | +| message | action | withdraw_validator_commission | +| message | sender | {senderAddress} | + +## Parameters + +The distribution module contains the following parameters: + +| Key | Type | Example | +| ------------------- | ------------ | -------------------------- | +| communitytax | string (dec) | "0.020000000000000000" [0] | +| withdrawaddrenabled | bool | true | + +* [0] `communitytax` must be positive and cannot exceed 1.00. +* `baseproposerreward` and `bonusproposerreward` were parameters that are deprecated in v0.47 and are not used. + +:::note +The reserve pool is the pool of collected funds for use by governance taken via the `CommunityTax`. +Currently with the Cosmos SDK, tokens collected by the CommunityTax are accounted for but unspendable. +::: + +## Client + +## CLI + +A user can query and interact with the `distribution` module using the CLI. + +#### Query + +The `query` commands allow users to query `distribution` state. + +```shell +simd query distribution --help +``` + +##### commission + +The `commission` command allows users to query validator commission rewards by address. + +```shell +simd query distribution commission [address] [flags] +``` + +Example: + +```shell +simd query distribution commission cosmosvaloper1... +``` + +Example Output: + +```yml +commission: +- amount: "1000000.000000000000000000" + denom: stake +``` + +##### community-pool + +The `community-pool` command allows users to query all coin balances within the community pool. + +```shell +simd query distribution community-pool [flags] +``` + +Example: + +```shell +simd query distribution community-pool +``` + +Example Output: + +```yml +pool: +- amount: "1000000.000000000000000000" + denom: stake +``` + +##### params + +The `params` command allows users to query the parameters of the `distribution` module. + +```shell +simd query distribution params [flags] +``` + +Example: + +```shell +simd query distribution params +``` + +Example Output: + +```yml +base_proposer_reward: "0.000000000000000000" +bonus_proposer_reward: "0.000000000000000000" +community_tax: "0.020000000000000000" +withdraw_addr_enabled: true +``` + +##### rewards + +The `rewards` command allows users to query delegator rewards. Users can optionally include the validator address to query rewards earned from a specific validator. + +```shell +simd query distribution rewards [delegator-addr] [validator-addr] [flags] +``` + +Example: + +```shell +simd query distribution rewards cosmos1... +``` + +Example Output: + +```yml +rewards: +- reward: + - amount: "1000000.000000000000000000" + denom: stake + validator_address: cosmosvaloper1.. +total: +- amount: "1000000.000000000000000000" + denom: stake +``` + +##### slashes + +The `slashes` command allows users to query all slashes for a given block range. + +```shell +simd query distribution slashes [validator] [start-height] [end-height] [flags] +``` + +Example: + +```shell +simd query distribution slashes cosmosvaloper1... 1 1000 +``` + +Example Output: + +```yml +pagination: + next_key: null + total: "0" +slashes: +- validator_period: 20, + fraction: "0.009999999999999999" +``` + +##### validator-outstanding-rewards + +The `validator-outstanding-rewards` command allows users to query all outstanding (un-withdrawn) rewards for a validator and all their delegations. + +```shell +simd query distribution validator-outstanding-rewards [validator] [flags] +``` + +Example: + +```shell +simd query distribution validator-outstanding-rewards cosmosvaloper1... +``` + +Example Output: + +```yml +rewards: +- amount: "1000000.000000000000000000" + denom: stake +``` + +##### validator-distribution-info + +The `validator-distribution-info` command allows users to query validator commission and self-delegation rewards for validator. + +````shell +simd query distribution validator-distribution-info cosmosvaloper1... +``` + +Example Output: + +```yml +commission: +- amount: "100000.000000000000000000" + denom: stake +operator_address: cosmosvaloper1... +self_bond_rewards: +- amount: "100000.000000000000000000" + denom: stake +``` + +#### Transactions + +The `tx` commands allow users to interact with the `distribution` module. + +```shell +simd tx distribution --help +``` + +##### fund-community-pool + +The `fund-community-pool` command allows users to send funds to the community pool. + +```shell +simd tx distribution fund-community-pool [amount] [flags] +``` + +Example: + +```shell +simd tx distribution fund-community-pool 100stake --from cosmos1... +``` + +##### set-withdraw-addr + +The `set-withdraw-addr` command allows users to set the withdraw address for rewards associated with a delegator address. + +```shell +simd tx distribution set-withdraw-addr [withdraw-addr] [flags] +``` + +Example: + +```shell +simd tx distribution set-withdraw-addr cosmos1... --from cosmos1... +``` + +##### withdraw-all-rewards + +The `withdraw-all-rewards` command allows users to withdraw all rewards for a delegator. + +```shell +simd tx distribution withdraw-all-rewards [flags] +``` + +Example: + +```shell +simd tx distribution withdraw-all-rewards --from cosmos1... +``` + +##### withdraw-rewards + +The `withdraw-rewards` command allows users to withdraw all rewards from a given delegation address, +and optionally withdraw validator commission if the delegation address given is a validator operator and the user proves the `--commission` flag. + +```shell +simd tx distribution withdraw-rewards [validator-addr] [flags] +``` + +Example: + +```shell +simd tx distribution withdraw-rewards cosmosvaloper1... --from cosmos1... --commission +``` + +### gRPC + +A user can query the `distribution` module using gRPC endpoints. + +#### Params + +The `Params` endpoint allows users to query parameters of the `distribution` module. + +Example: + +```shell +grpcurl -plaintext \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/Params +``` + +Example Output: + +```json +{ + "params": { + "communityTax": "20000000000000000", + "baseProposerReward": "00000000000000000", + "bonusProposerReward": "00000000000000000", + "withdrawAddrEnabled": true + } +} +``` + +#### ValidatorDistributionInfo + +The `ValidatorDistributionInfo` queries validator commission and self-delegation rewards for validator. + +Example: + +```shell +grpcurl -plaintext \ + -d '{"validator_address":"cosmosvalop1..."}' \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/ValidatorDistributionInfo +``` + +Example Output: + +```json +{ + "commission": { + "commission": [ + { + "denom": "stake", + "amount": "1000000000000000" + } + ] + }, + "self_bond_rewards": [ + { + "denom": "stake", + "amount": "1000000000000000" + } + ], + "validator_address": "cosmosvalop1..." +} +``` + +#### ValidatorOutstandingRewards + +The `ValidatorOutstandingRewards` endpoint allows users to query rewards of a validator address. + +Example: + +```shell +grpcurl -plaintext \ + -d '{"validator_address":"cosmosvalop1.."}' \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/ValidatorOutstandingRewards +``` + +Example Output: + +```json +{ + "rewards": { + "rewards": [ + { + "denom": "stake", + "amount": "1000000000000000" + } + ] + } +} +``` + +#### ValidatorCommission + +The `ValidatorCommission` endpoint allows users to query accumulated commission for a validator. + +Example: + +```shell +grpcurl -plaintext \ + -d '{"validator_address":"cosmosvalop1.."}' \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/ValidatorCommission +``` + +Example Output: + +```json +{ + "commission": { + "commission": [ + { + "denom": "stake", + "amount": "1000000000000000" + } + ] + } +} +``` + +#### ValidatorSlashes + +The `ValidatorSlashes` endpoint allows users to query slash events of a validator. + +Example: + +```shell +grpcurl -plaintext \ + -d '{"validator_address":"cosmosvalop1.."}' \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/ValidatorSlashes +``` + +Example Output: + +```json +{ + "slashes": [ + { + "validator_period": "20", + "fraction": "0.009999999999999999" + } + ], + "pagination": { + "total": "1" + } +} +``` + +#### DelegationRewards + +The `DelegationRewards` endpoint allows users to query the total rewards accrued by a delegation. + +Example: + +```shell +grpcurl -plaintext \ + -d '{"delegator_address":"cosmos1...","validator_address":"cosmosvalop1..."}' \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/DelegationRewards +``` + +Example Output: + +```json +{ + "rewards": [ + { + "denom": "stake", + "amount": "1000000000000000" + } + ] +} +``` + +#### DelegationTotalRewards + +The `DelegationTotalRewards` endpoint allows users to query the total rewards accrued by each validator. + +Example: + +```shell +grpcurl -plaintext \ + -d '{"delegator_address":"cosmos1..."}' \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/DelegationTotalRewards +``` + +Example Output: + +```json +{ + "rewards": [ + { + "validatorAddress": "cosmosvaloper1...", + "reward": [ + { + "denom": "stake", + "amount": "1000000000000000" + } + ] + } + ], + "total": [ + { + "denom": "stake", + "amount": "1000000000000000" + } + ] +} +``` + +#### DelegatorValidators + +The `DelegatorValidators` endpoint allows users to query all validators for given delegator. + +Example: + +```shell +grpcurl -plaintext \ + -d '{"delegator_address":"cosmos1..."}' \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/DelegatorValidators +``` + +Example Output: + +```json +{ + "validators": ["cosmosvaloper1..."] +} +``` + +#### DelegatorWithdrawAddress + +The `DelegatorWithdrawAddress` endpoint allows users to query the withdraw address of a delegator. + +Example: + +```shell +grpcurl -plaintext \ + -d '{"delegator_address":"cosmos1..."}' \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/DelegatorWithdrawAddress +``` + +Example Output: + +```json +{ + "withdrawAddress": "cosmos1..." +} +``` + +#### CommunityPool + +The `CommunityPool` endpoint allows users to query the community pool coins. + +Example: + +```shell +grpcurl -plaintext \ + localhost:9090 \ + cosmos.distribution.v1beta1.Query/CommunityPool +``` + +Example Output: + +```json +{ + "pool": [ + { + "denom": "stake", + "amount": "1000000000000000000" + } + ] +} +``` diff --git a/.gitbook/developers/modules/core/evidence/README.md b/.gitbook/developers/modules/core/evidence/README.md new file mode 100644 index 00000000..82cd03ba --- /dev/null +++ b/.gitbook/developers/modules/core/evidence/README.md @@ -0,0 +1,440 @@ +--- +sidebar_position: 1 +--- + +# `x/evidence` + +* [Concepts](#concepts) +* [State](#state) +* [Messages](#messages) +* [Events](#events) +* [Parameters](#parameters) +* [BeginBlock](#beginblock) +* [Client](#client) + * [CLI](#cli) + * [REST](#rest) + * [gRPC](#grpc) + +## Abstract + +`x/evidence` is an implementation of a Cosmos SDK module, per [ADR 009](https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-009-evidence-module.md), +that allows for the submission and handling of arbitrary evidence of misbehavior such +as equivocation and counterfactual signing. + +The evidence module differs from standard evidence handling which typically expects the +underlying consensus engine, e.g. CometBFT, to automatically submit evidence when +it is discovered by allowing clients and foreign chains to submit more complex evidence +directly. + +All concrete evidence types must implement the `Evidence` interface contract. Submitted +`Evidence` is first routed through the evidence module's `Router` in which it attempts +to find a corresponding registered `Handler` for that specific `Evidence` type. +Each `Evidence` type must have a `Handler` registered with the evidence module's +keeper in order for it to be successfully routed and executed. + +Each corresponding handler must also fulfill the `Handler` interface contract. The +`Handler` for a given `Evidence` type can perform any arbitrary state transitions +such as slashing, jailing, and tombstoning. + +## Concepts + +### Evidence + +Any concrete type of evidence submitted to the `x/evidence` module must fulfill the +`Evidence` contract outlined below. Not all concrete types of evidence will fulfill +this contract in the same way and some data may be entirely irrelevant to certain +types of evidence. An additional `ValidatorEvidence`, which extends `Evidence`, +has also been created to define a contract for evidence against malicious validators. + +```go +// Evidence defines the contract which concrete evidence types of misbehavior +// must implement. +type Evidence interface { + proto.Message + + Route() string + String() string + Hash() []byte + ValidateBasic() error + + // Height at which the infraction occurred + GetHeight() int64 +} + +// ValidatorEvidence extends Evidence interface to define contract +// for evidence against malicious validators +type ValidatorEvidence interface { + Evidence + + // The consensus address of the malicious validator at time of infraction + GetConsensusAddress() sdk.ConsAddress + + // The total power of the malicious validator at time of infraction + GetValidatorPower() int64 + + // The total validator set power at time of infraction + GetTotalPower() int64 +} +``` + +### Registration & Handling + +The `x/evidence` module must first know about all types of evidence it is expected +to handle. This is accomplished by registering the `Route` method in the `Evidence` +contract with what is known as a `Router` (defined below). The `Router` accepts +`Evidence` and attempts to find the corresponding `Handler` for the `Evidence` +via the `Route` method. + +```go +type Router interface { + AddRoute(r string, h Handler) Router + HasRoute(r string) bool + GetRoute(path string) Handler + Seal() + Sealed() bool +} +``` + +The `Handler` (defined below) is responsible for executing the entirety of the +business logic for handling `Evidence`. This typically includes validating the +evidence, both stateless checks via `ValidateBasic` and stateful checks via any +keepers provided to the `Handler`. In addition, the `Handler` may also perform +capabilities such as slashing and jailing a validator. All `Evidence` handled +by the `Handler` should be persisted. + +```go +// Handler defines an agnostic Evidence handler. The handler is responsible +// for executing all corresponding business logic necessary for verifying the +// evidence as valid. In addition, the Handler may execute any necessary +// slashing and potential jailing. +type Handler func(context.Context, Evidence) error +``` + + +## State + +Currently the `x/evidence` module only stores valid submitted `Evidence` in state. +The evidence state is also stored and exported in the `x/evidence` module's `GenesisState`. + +```protobuf +// GenesisState defines the evidence module's genesis state. +message GenesisState { + // evidence defines all the evidence at genesis. + repeated google.protobuf.Any evidence = 1; +} + +``` + +All `Evidence` is retrieved and stored via a prefix `KVStore` using prefix `0x00` (`KeyPrefixEvidence`). + + +## Messages + +### MsgSubmitEvidence + +Evidence is submitted through a `MsgSubmitEvidence` message: + +```protobuf +// MsgSubmitEvidence represents a message that supports submitting arbitrary +// Evidence of misbehavior such as equivocation or counterfactual signing. +message MsgSubmitEvidence { + string submitter = 1; + google.protobuf.Any evidence = 2; +} +``` + +Note, the `Evidence` of a `MsgSubmitEvidence` message must have a corresponding +`Handler` registered with the `x/evidence` module's `Router` in order to be processed +and routed correctly. + +Given the `Evidence` is registered with a corresponding `Handler`, it is processed +as follows: + +```go +func SubmitEvidence(ctx Context, evidence Evidence) error { + if _, err := GetEvidence(ctx, evidence.Hash()); err == nil { + return errorsmod.Wrap(types.ErrEvidenceExists, strings.ToUpper(hex.EncodeToString(evidence.Hash()))) + } + if !router.HasRoute(evidence.Route()) { + return errorsmod.Wrap(types.ErrNoEvidenceHandlerExists, evidence.Route()) + } + + handler := router.GetRoute(evidence.Route()) + if err := handler(ctx, evidence); err != nil { + return errorsmod.Wrap(types.ErrInvalidEvidence, err.Error()) + } + + ctx.EventManager().EmitEvent( + sdk.NewEvent( + types.EventTypeSubmitEvidence, + sdk.NewAttribute(types.AttributeKeyEvidenceHash, strings.ToUpper(hex.EncodeToString(evidence.Hash()))), + ), + ) + + SetEvidence(ctx, evidence) + return nil +} +``` + +First, there must not already exist valid submitted `Evidence` of the exact same +type. Secondly, the `Evidence` is routed to the `Handler` and executed. Finally, +if there is no error in handling the `Evidence`, an event is emitted and it is persisted to state. + + +## Events + +The `x/evidence` module emits the following events: + +### Handlers + +#### MsgSubmitEvidence + +| Type | Attribute Key | Attribute Value | +| --------------- | ------------- | --------------- | +| submit_evidence | evidence_hash | {evidenceHash} | +| message | module | evidence | +| message | sender | {senderAddress} | +| message | action | submit_evidence | + + +## Parameters + +The evidence module does not contain any parameters. + + +## BeginBlock + +### Evidence Handling + +CometBFT blocks can include +[Evidence](https://github.com/cometbft/cometbft/blob/main/spec/abci/abci%2B%2B_basic_concepts.md#evidence) that indicates if a validator committed malicious behavior. The relevant information is forwarded to the application as ABCI Evidence in `abci.RequestBeginBlock` so that the validator can be punished accordingly. + +#### Equivocation + +The Cosmos SDK handles two types of evidence inside the ABCI `BeginBlock`: + +* `DuplicateVoteEvidence`, +* `LightClientAttackEvidence`. + +The evidence module handles these two evidence types the same way. First, the Cosmos SDK converts the CometBFT concrete evidence type to an SDK `Evidence` interface using `Equivocation` as the concrete type. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/evidence/v1beta1/evidence.proto#L12-L32 +``` + +For some `Equivocation` submitted in `block` to be valid, it must satisfy: + +`Evidence.Timestamp >= block.Timestamp - MaxEvidenceAge` + +Where: + +* `Evidence.Timestamp` is the timestamp in the block at height `Evidence.Height` +* `block.Timestamp` is the current block timestamp. + +If valid `Equivocation` evidence is included in a block, the validator's stake is +reduced (slashed) by `SlashFractionDoubleSign` as defined by the `x/slashing` module +of what their stake was when the infraction occurred, rather than when the evidence was discovered. +We want to "follow the stake", i.e., the stake that contributed to the infraction +should be slashed, even if it has since been redelegated or started unbonding. + +In addition, the validator is permanently jailed and tombstoned to make it impossible for that +validator to ever re-enter the validator set. + +The `Equivocation` evidence is handled as follows: + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/evidence/keeper/infraction.go#L26-L140 +``` + +**Note:** The slashing, jailing, and tombstoning calls are delegated through the `x/slashing` module +that emits informative events and finally delegates calls to the `x/staking` module. See documentation +on slashing and jailing in [State Transitions](../staking/README.md#state-transitions). + +## Client + +### CLI + +A user can query and interact with the `evidence` module using the CLI. + +#### Query + +The `query` commands allows users to query `evidence` state. + +```bash +simd query evidence --help +``` + +#### evidence + +The `evidence` command allows users to list all evidence or evidence by hash. + +Usage: + +```bash +simd query evidence evidence [flags] +``` + +To query evidence by hash + +Example: + +```bash +simd query evidence evidence "DF0C23E8634E480F84B9D5674A7CDC9816466DEC28A3358F73260F68D28D7660" +``` + +Example Output: + +```bash +evidence: + consensus_address: cosmosvalcons1ntk8eualewuprz0gamh8hnvcem2nrcdsgz563h + height: 11 + power: 100 + time: "2021-10-20T16:08:38.194017624Z" +``` + +To get all evidence + +Example: + +```bash +simd query evidence list +``` + +Example Output: + +```bash +evidence: + consensus_address: cosmosvalcons1ntk8eualewuprz0gamh8hnvcem2nrcdsgz563h + height: 11 + power: 100 + time: "2021-10-20T16:08:38.194017624Z" +pagination: + next_key: null + total: "1" +``` + +### REST + +A user can query the `evidence` module using REST endpoints. + +#### Evidence + +Get evidence by hash + +```bash +/cosmos/evidence/v1beta1/evidence/{hash} +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/evidence/v1beta1/evidence/DF0C23E8634E480F84B9D5674A7CDC9816466DEC28A3358F73260F68D28D7660" +``` + +Example Output: + +```bash +{ + "evidence": { + "consensus_address": "cosmosvalcons1ntk8eualewuprz0gamh8hnvcem2nrcdsgz563h", + "height": "11", + "power": "100", + "time": "2021-10-20T16:08:38.194017624Z" + } +} +``` + +#### All evidence + +Get all evidence + +```bash +/cosmos/evidence/v1beta1/evidence +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/evidence/v1beta1/evidence" +``` + +Example Output: + +```bash +{ + "evidence": [ + { + "consensus_address": "cosmosvalcons1ntk8eualewuprz0gamh8hnvcem2nrcdsgz563h", + "height": "11", + "power": "100", + "time": "2021-10-20T16:08:38.194017624Z" + } + ], + "pagination": { + "total": "1" + } +} +``` + +### gRPC + +A user can query the `evidence` module using gRPC endpoints. + +#### Evidence + +Get evidence by hash + +```bash +cosmos.evidence.v1beta1.Query/Evidence +``` + +Example: + +```bash +grpcurl -plaintext -d '{"evidence_hash":"DF0C23E8634E480F84B9D5674A7CDC9816466DEC28A3358F73260F68D28D7660"}' localhost:9090 cosmos.evidence.v1beta1.Query/Evidence +``` + +Example Output: + +```bash +{ + "evidence": { + "consensus_address": "cosmosvalcons1ntk8eualewuprz0gamh8hnvcem2nrcdsgz563h", + "height": "11", + "power": "100", + "time": "2021-10-20T16:08:38.194017624Z" + } +} +``` + +#### All evidence + +Get all evidence + +```bash +cosmos.evidence.v1beta1.Query/AllEvidence +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 cosmos.evidence.v1beta1.Query/AllEvidence +``` + +Example Output: + +```bash +{ + "evidence": [ + { + "consensus_address": "cosmosvalcons1ntk8eualewuprz0gamh8hnvcem2nrcdsgz563h", + "height": "11", + "power": "100", + "time": "2021-10-20T16:08:38.194017624Z" + } + ], + "pagination": { + "total": "1" + } +} +``` diff --git a/.gitbook/developers/modules/core/feegrant/README.md b/.gitbook/developers/modules/core/feegrant/README.md new file mode 100644 index 00000000..07524449 --- /dev/null +++ b/.gitbook/developers/modules/core/feegrant/README.md @@ -0,0 +1,396 @@ +--- +sidebar_position: 1 +--- + +# `x/feegrant` + +## Abstract + +This document specifies the fee grant module. For the full ADR, please see [Fee Grant ADR-029](https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-029-fee-grant-module.md). + +This module allows accounts to grant fee allowances and to use fees from their accounts. Grantees can execute any transaction without the need to maintain sufficient fees. + +## Contents + +* [Concepts](#concepts) +* [State](#state) + * [FeeAllowance](#feeallowance) + * [FeeAllowanceQueue](#feeallowancequeue) +* [Messages](#messages) + * [Msg/GrantAllowance](#msggrantallowance) + * [Msg/RevokeAllowance](#msgrevokeallowance) +* [Events](#events) +* [Msg Server](#msg-server) + * [MsgGrantAllowance](#msggrantallowance-1) + * [MsgRevokeAllowance](#msgrevokeallowance-1) + * [Exec fee allowance](#exec-fee-allowance) +* [Client](#client) + * [CLI](#cli) + * [gRPC](#grpc) + +## Concepts + +### Grant + +`Grant` is stored in the KVStore to record a grant with full context. Every grant will contain `granter`, `grantee` and what kind of `allowance` is granted. `granter` is an account address who is giving permission to `grantee` (the beneficiary account address) to pay for some or all of `grantee`'s transaction fees. `allowance` defines what kind of fee allowance (`BasicAllowance` or `PeriodicAllowance`, see below) is granted to `grantee`. `allowance` accepts an interface which implements `FeeAllowanceI`, encoded as `Any` type. There can be only one existing fee grant allowed for a `grantee` and `granter`, self grants are not allowed. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/feegrant/v1beta1/feegrant.proto#L83-L93 +``` + +`FeeAllowanceI` looks like: + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/feegrant/fees.go#L9-L32 +``` + +### Fee Allowance types + +There are two types of fee allowances present at the moment: + +* `BasicAllowance` +* `PeriodicAllowance` +* `AllowedMsgAllowance` + +### BasicAllowance + +`BasicAllowance` is permission for `grantee` to use fee from a `granter`'s account. If any of the `spend_limit` or `expiration` reaches its limit, the grant will be removed from the state. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/feegrant/v1beta1/feegrant.proto#L15-L28 +``` + +* `spend_limit` is the limit of coins that are allowed to be used from the `granter` account. If it is empty, it assumes there's no spend limit, `grantee` can use any number of available coins from `granter` account address before the expiration. + +* `expiration` specifies an optional time when this allowance expires. If the value is left empty, there is no expiry for the grant. + +* When a grant is created with empty values for `spend_limit` and `expiration`, it is still a valid grant. It won't restrict the `grantee` to use any number of coins from `granter` and it won't have any expiration. The only way to restrict the `grantee` is by revoking the grant. + +### PeriodicAllowance + +`PeriodicAllowance` is a repeating fee allowance for the mentioned period, we can mention when the grant can expire as well as when a period can reset. We can also define the maximum number of coins that can be used in a mentioned period of time. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/feegrant/v1beta1/feegrant.proto#L34-L68 +``` + +* `basic` is the instance of `BasicAllowance` which is optional for periodic fee allowance. If empty, the grant will have no `expiration` and no `spend_limit`. + +* `period` is the specific period of time, after each period passes, `period_can_spend` will be reset. + +* `period_spend_limit` specifies the maximum number of coins that can be spent in the period. + +* `period_can_spend` is the number of coins left to be spent before the period_reset time. + +* `period_reset` keeps track of when a next period reset should happen. + +### AllowedMsgAllowance + +`AllowedMsgAllowance` is a fee allowance, it can be any of `BasicFeeAllowance`, `PeriodicAllowance` but restricted only to the allowed messages mentioned by the granter. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/feegrant/v1beta1/feegrant.proto#L70-L81 +``` + +* `allowance` is either `BasicAllowance` or `PeriodicAllowance`. + +* `allowed_messages` is array of messages allowed to execute the given allowance. + +### FeeGranter flag + +`feegrant` module introduces a `FeeGranter` flag for CLI for the sake of executing transactions with fee granter. When this flag is set, `clientCtx` will append the granter account address for transactions generated through CLI. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/client/cmd.go#L249-L260 +``` + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/client/tx/tx.go#L109-L109 +``` + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/auth/tx/builder.go#L275-L284 +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/tx/v1beta1/tx.proto#L203-L224 +``` + +Example cmd: + +```go +./simd tx gov submit-proposal --title="Test Proposal" --description="My awesome proposal" --type="Text" --from validator-key --fee-granter=cosmos1xh44hxt7spr67hqaa7nyx5gnutrz5fraw6grxn --chain-id=testnet --fees="10stake" +``` + +### Granted Fee Deductions + +Fees are deducted from grants in the `x/auth` ante handler. To learn more about how ante handlers work, read the [Auth Module AnteHandlers Guide](../auth/README.md#antehandlers). + +### Gas + +In order to prevent DoS attacks, using a filtered `x/feegrant` incurs gas. The SDK must assure that the `grantee`'s transactions all conform to the filter set by the `granter`. The SDK does this by iterating over the allowed messages in the filter and charging 10 gas per filtered message. The SDK will then iterate over the messages being sent by the `grantee` to ensure the messages adhere to the filter, also charging 10 gas per message. The SDK will stop iterating and fail the transaction if it finds a message that does not conform to the filter. + +**WARNING**: The gas is charged against the granted allowance. Ensure your messages conform to the filter, if any, before sending transactions using your allowance. + +### Pruning + +A queue in the state maintained with the prefix of expiration of the grants and checks them on EndBlock with the current block time for every block to prune. + +## State + +### FeeAllowance + +Fee Allowances are identified by combining `Grantee` (the account address of fee allowance grantee) with the `Granter` (the account address of fee allowance granter). + +Fee allowance grants are stored in the state as follows: + +* Grant: `0x00 | grantee_addr_len (1 byte) | grantee_addr_bytes | granter_addr_len (1 byte) | granter_addr_bytes -> ProtocolBuffer(Grant)` + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/feegrant/feegrant.pb.go#L222-L230 +``` + +### FeeAllowanceQueue + +Fee Allowances queue items are identified by combining the `FeeAllowancePrefixQueue` (i.e., 0x01), `expiration`, `grantee` (the account address of fee allowance grantee), `granter` (the account address of fee allowance granter). Endblocker checks `FeeAllowanceQueue` state for the expired grants and prunes them from `FeeAllowance` if there are any found. + +Fee allowance queue keys are stored in the state as follows: + +* Grant: `0x01 | expiration_bytes | grantee_addr_len (1 byte) | grantee_addr_bytes | granter_addr_len (1 byte) | granter_addr_bytes -> EmptyBytes` + +## Messages + +### Msg/GrantAllowance + +A fee allowance grant will be created with the `MsgGrantAllowance` message. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/feegrant/v1beta1/tx.proto#L25-L39 +``` + +### Msg/RevokeAllowance + +An allowed grant fee allowance can be removed with the `MsgRevokeAllowance` message. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/feegrant/v1beta1/tx.proto#L41-L54 +``` + +## Events + +The feegrant module emits the following events: + +## Msg Server + +### MsgGrantAllowance + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | ---------------- | +| message | action | set_feegrant | +| message | granter | {granterAddress} | +| message | grantee | {granteeAddress} | + +### MsgRevokeAllowance + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | ---------------- | +| message | action | revoke_feegrant | +| message | granter | {granterAddress} | +| message | grantee | {granteeAddress} | + +### Exec fee allowance + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | ---------------- | +| message | action | use_feegrant | +| message | granter | {granterAddress} | +| message | grantee | {granteeAddress} | + +### Prune fee allowances + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | ---------------- | +| message | action | prune_feegrant | +| message | pruner | {prunerAddress} | + + +## Client + +### CLI + +A user can query and interact with the `feegrant` module using the CLI. + +#### Query + +The `query` commands allow users to query `feegrant` state. + +```shell +simd query feegrant --help +``` + +##### grant + +The `grant` command allows users to query a grant for a given granter-grantee pair. + +```shell +simd query feegrant grant [granter] [grantee] [flags] +``` + +Example: + +```shell +simd query feegrant grant cosmos1.. cosmos1.. +``` + +Example Output: + +```yml +allowance: + '@type': /cosmos.feegrant.v1beta1.BasicAllowance + expiration: null + spend_limit: + - amount: "100" + denom: stake +grantee: cosmos1.. +granter: cosmos1.. +``` + +##### grants + +The `grants` command allows users to query all grants for a given grantee. + +```shell +simd query feegrant grants [grantee] [flags] +``` + +Example: + +```shell +simd query feegrant grants cosmos1.. +``` + +Example Output: + +```yml +allowances: +- allowance: + '@type': /cosmos.feegrant.v1beta1.BasicAllowance + expiration: null + spend_limit: + - amount: "100" + denom: stake + grantee: cosmos1.. + granter: cosmos1.. +pagination: + next_key: null + total: "0" +``` + +#### Transactions + +The `tx` commands allow users to interact with the `feegrant` module. + +```shell +simd tx feegrant --help +``` + +##### grant + +The `grant` command allows users to grant fee allowances to another account. The fee allowance can have an expiration date, a total spend limit, and/or a periodic spend limit. + +```shell +simd tx feegrant grant [granter] [grantee] [flags] +``` + +Example (one-time spend limit): + +```shell +simd tx feegrant grant cosmos1.. cosmos1.. --spend-limit 100stake +``` + +Example (periodic spend limit): + +```shell +simd tx feegrant grant cosmos1.. cosmos1.. --period 3600 --period-limit 10stake +``` + +##### revoke + +The `revoke` command allows users to revoke a granted fee allowance. + +```shell +simd tx feegrant revoke [granter] [grantee] [flags] +``` + +Example: + +```shell +simd tx feegrant revoke cosmos1.. cosmos1.. +``` + +### gRPC + +A user can query the `feegrant` module using gRPC endpoints. + +#### Allowance + +The `Allowance` endpoint allows users to query a granted fee allowance. + +```shell +cosmos.feegrant.v1beta1.Query/Allowance +``` + +Example: + +```shell +grpcurl -plaintext \ + -d '{"grantee":"cosmos1..","granter":"cosmos1.."}' \ + localhost:9090 \ + cosmos.feegrant.v1beta1.Query/Allowance +``` + +Example Output: + +```json +{ + "allowance": { + "granter": "cosmos1..", + "grantee": "cosmos1..", + "allowance": {"@type":"/cosmos.feegrant.v1beta1.BasicAllowance","spendLimit":[{"denom":"stake","amount":"100"}]} + } +} +``` + +#### Allowances + +The `Allowances` endpoint allows users to query all granted fee allowances for a given grantee. + +```shell +cosmos.feegrant.v1beta1.Query/Allowances +``` + +Example: + +```shell +grpcurl -plaintext \ + -d '{"address":"cosmos1.."}' \ + localhost:9090 \ + cosmos.feegrant.v1beta1.Query/Allowances +``` + +Example Output: + +```json +{ + "allowances": [ + { + "granter": "cosmos1..", + "grantee": "cosmos1..", + "allowance": {"@type":"/cosmos.feegrant.v1beta1.BasicAllowance","spendLimit":[{"denom":"stake","amount":"100"}]} + } + ], + "pagination": { + "total": "1" + } +} +``` diff --git a/.gitbook/developers/modules/core/genutil/README.md b/.gitbook/developers/modules/core/genutil/README.md new file mode 100644 index 00000000..45cb4535 --- /dev/null +++ b/.gitbook/developers/modules/core/genutil/README.md @@ -0,0 +1,89 @@ +# `x/genutil` + +## Concepts + +The `genutil` package contains a variety of genesis utility functionalities for usage within a blockchain application. Namely: + +* Genesis transactions related (gentx) +* Commands for collection and creation of gentxs +* `InitChain` processing of gentxs +* Genesis file creation +* Genesis file validation +* Genesis file migration +* CometBFT related initialization + * Translation of an app genesis to a CometBFT genesis + +## Genesis + +Genutil contains the data structure that defines an application genesis. +An application genesis consist of a consensus genesis (g.e. CometBFT genesis) and application related genesis data. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-rc.0/x/genutil/types/genesis.go#L24-L34 +``` + +The application genesis can then be translated to the consensus engine to the right format: + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-rc.0/x/genutil/types/genesis.go#L126-L136 +``` + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.50.0-rc.0/server/start.go#L397-L407 +``` + +## Client + +### CLI + +The genutil commands are available under the `genesis` subcommand. + +#### add-genesis-account + +Add a genesis account to `genesis.json`. Learn more [here](https://docs.cosmos.network/main/run-node/run-node#adding-genesis-accounts). + +#### collect-gentxs + +Collect genesis txs and output a `genesis.json` file. + +```shell +simd genesis collect-gentxs +``` + +This will create a new `genesis.json` file that includes data from all the validators (we sometimes call it the "super genesis file" to distinguish it from single-validator genesis files). + +#### gentx + +Generate a genesis tx carrying a self delegation. + +```shell +simd genesis gentx [key_name] [amount] --chain-id [chain-id] +``` + +This will create the genesis transaction for your new chain. Here `amount` should be at least `1000000000stake`. +If you provide too much or too little, you will encounter an error when starting a node. + +#### migrate + +Migrate genesis to a specified target (SDK) version. + +```shell +simd genesis migrate [target-version] +``` + +:::tip +The `migrate` command is extensible and takes a `MigrationMap`. This map is a mapping of target versions to genesis migrations functions. +When not using the default `MigrationMap`, it is recommended to still call the default `MigrationMap` corresponding the SDK version of the chain and prepend/append your own genesis migrations. +::: + +#### validate-genesis + +Validates the genesis file at the default location or at the location passed as an argument. + +```shell +simd genesis validate-genesis +``` + +:::warning +Validate genesis only validates if the genesis is valid at the **current application binary**. For validating a genesis from a previous version of the application, use the `migrate` command to migrate the genesis to the current version. +::: diff --git a/.gitbook/developers/modules/core/gov/README.md b/.gitbook/developers/modules/core/gov/README.md new file mode 100644 index 00000000..87b2fc5f --- /dev/null +++ b/.gitbook/developers/modules/core/gov/README.md @@ -0,0 +1,2547 @@ +--- +sidebar_position: 1 +--- + +# `x/gov` + +## Abstract + +This paper specifies the Governance module of the Cosmos SDK, which was first +described in the [Cosmos Whitepaper](https://cosmos.network/about/whitepaper) in +June 2016. + +The module enables Cosmos SDK based blockchain to support an on-chain governance +system. In this system, holders of the native staking token of the chain can vote +on proposals on a 1 token 1 vote basis. Next is a list of features the module +currently supports: + +* **Proposal submission:** Users can submit proposals with a deposit. Once the +minimum deposit is reached, the proposal enters voting period. The minimum deposit can be reached by collecting deposits from different users (including proposer) within deposit period. +* **Vote:** Participants can vote on proposals that reached MinDeposit and entered voting period. +* **Inheritance and penalties:** Delegators inherit their validator's vote if +they don't vote themselves. +* **Claiming deposit:** Users that deposited on proposals can recover their +deposits if the proposal was accepted or rejected. If the proposal was vetoed, or never entered voting period (minimum deposit not reached within deposit period), the deposit is burned. + +This module is in use on the Cosmos Hub (a.k.a [gaia](https://github.com/cosmos/gaia)). +Features that may be added in the future are described in [Future Improvements](#future-improvements). + +## Contents + +The following specification uses *ATOM* as the native staking token. The module +can be adapted to any Proof-Of-Stake blockchain by replacing *ATOM* with the native +staking token of the chain. + +* [Concepts](#concepts) + * [Proposal submission](#proposal-submission) + * [Deposit](#deposit) + * [Vote](#vote) + * [Software Upgrade](#software-upgrade) +* [State](#state) + * [Proposals](#proposals) + * [Parameters and base types](#parameters-and-base-types) + * [Deposit](#deposit-1) + * [ValidatorGovInfo](#validatorgovinfo) + * [Stores](#stores) + * [Proposal Processing Queue](#proposal-processing-queue) + * [Legacy Proposal](#legacy-proposal) +* [Messages](#messages) + * [Proposal Submission](#proposal-submission-1) + * [Deposit](#deposit-2) + * [Vote](#vote-1) +* [Events](#events) + * [EndBlocker](#endblocker) + * [Handlers](#handlers) +* [Parameters](#parameters) +* [Client](#client) + * [CLI](#cli) + * [gRPC](#grpc) + * [REST](#rest) +* [Metadata](#metadata) + * [Proposal](#proposal-3) + * [Vote](#vote-5) +* [Future Improvements](#future-improvements) + +## Concepts + +*Disclaimer: This is work in progress. Mechanisms are susceptible to change.* + +The governance process is divided in a few steps that are outlined below: + +* **Proposal submission:** Proposal is submitted to the blockchain with a + deposit. +* **Vote:** Once deposit reaches a certain value (`MinDeposit`), proposal is + confirmed and vote opens. Bonded Atom holders can then send `TxGovVote` + transactions to vote on the proposal. +* **Execution** After a period of time, the votes are tallied and depending + on the result, the messages in the proposal will be executed. + +### Proposal submission + +#### Right to submit a proposal + +Every account can submit proposals by sending a `MsgSubmitProposal` transaction. +Once a proposal is submitted, it is identified by its unique `proposalID`. + +#### Proposal Messages + +A proposal includes an array of `sdk.Msg`s which are executed automatically if the +proposal passes. The messages are executed by the governance `ModuleAccount` itself. Modules +such as `x/upgrade`, that want to allow certain messages to be executed by governance +only should add a whitelist within the respective msg server, granting the governance +module the right to execute the message once a quorum has been reached. The governance +module uses the `MsgServiceRouter` to check that these messages are correctly constructed +and have a respective path to execute on but do not perform a full validity check. + +### Deposit + +To prevent spam, proposals must be submitted with a deposit in the coins defined by +the `MinDeposit` param. + +When a proposal is submitted, it has to be accompanied with a deposit that must be +strictly positive, but can be inferior to `MinDeposit`. The submitter doesn't need +to pay for the entire deposit on their own. The newly created proposal is stored in +an *inactive proposal queue* and stays there until its deposit passes the `MinDeposit`. +Other token holders can increase the proposal's deposit by sending a `Deposit` +transaction. If a proposal doesn't pass the `MinDeposit` before the deposit end time +(the time when deposits are no longer accepted), the proposal will be destroyed: the +proposal will be removed from state and the deposit will be burned (see x/gov `EndBlocker`). +When a proposal deposit passes the `MinDeposit` threshold (even during the proposal +submission) before the deposit end time, the proposal will be moved into the +*active proposal queue* and the voting period will begin. + +The deposit is kept in escrow and held by the governance `ModuleAccount` until the +proposal is finalized (passed or rejected). + +#### Deposit refund and burn + +When a proposal is finalized, the coins from the deposit are either refunded or burned +according to the final tally of the proposal: + +* If the proposal is approved or rejected but *not* vetoed, each deposit will be + automatically refunded to its respective depositor (transferred from the governance + `ModuleAccount`). +* When the proposal is vetoed with greater than 1/3, deposits will be burned from the + governance `ModuleAccount` and the proposal information along with its deposit + information will be removed from state. +* All refunded or burned deposits are removed from the state. Events are issued when + burning or refunding a deposit. + +### Vote + +#### Participants + +*Participants* are users that have the right to vote on proposals. On the +Cosmos Hub, participants are bonded Atom holders. Unbonded Atom holders and +other users do not get the right to participate in governance. However, they +can submit and deposit on proposals. + +Note that when *participants* have bonded and unbonded Atoms, their voting power is calculated from their bonded Atom holdings only. + +#### Voting period + +Once a proposal reaches `MinDeposit`, it immediately enters `Voting period`. We +define `Voting period` as the interval between the moment the vote opens and +the moment the vote closes. The initial value of `Voting period` is 2 weeks. + +#### Option set + +The option set of a proposal refers to the set of choices a participant can +choose from when casting its vote. + +The initial option set includes the following options: + +* `Yes` +* `No` +* `NoWithVeto` +* `Abstain` + +`NoWithVeto` counts as `No` but also adds a `Veto` vote. `Abstain` option +allows voters to signal that they do not intend to vote in favor or against the +proposal but accept the result of the vote. + +*Note: from the UI, for urgent proposals we should maybe add a ‘Not Urgent’ option that casts a `NoWithVeto` vote.* + +#### Weighted Votes + +[ADR-037](https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-037-gov-split-vote.md) introduces the weighted vote feature which allows a staker to split their votes into several voting options. For example, it could use 70% of its voting power to vote Yes and 30% of its voting power to vote No. + +Often times the entity owning that address might not be a single individual. For example, a company might have different stakeholders who want to vote differently, and so it makes sense to allow them to split their voting power. Currently, it is not possible for them to do "passthrough voting" and giving their users voting rights over their tokens. However, with this system, exchanges can poll their users for voting preferences, and then vote on-chain proportionally to the results of the poll. + +To represent weighted vote on chain, we use the following Protobuf message. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1beta1/gov.proto#L34-L47 +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1beta1/gov.proto#L181-L201 +``` + +For a weighted vote to be valid, the `options` field must not contain duplicate vote options, and the sum of weights of all options must be equal to 1. + +### Quorum + +Quorum is defined as the minimum percentage of voting power that needs to be +cast on a proposal for the result to be valid. + +### Expedited Proposals + +A proposal can be expedited, making the proposal use shorter voting duration and a higher tally threshold by its default. If an expedited proposal fails to meet the threshold within the scope of shorter voting duration, the expedited proposal is then converted to a regular proposal and restarts voting under regular voting conditions. + +#### Threshold + +Threshold is defined as the minimum proportion of `Yes` votes (excluding +`Abstain` votes) for the proposal to be accepted. + +Initially, the threshold is set at 50% of `Yes` votes, excluding `Abstain` +votes. A possibility to veto exists if more than 1/3rd of all votes are +`NoWithVeto` votes. Note, both of these values are derived from the `TallyParams` +on-chain parameter, which is modifiable by governance. +This means that proposals are accepted iff: + +* There exist bonded tokens. +* Quorum has been achieved. +* The proportion of `Abstain` votes is inferior to 1/1. +* The proportion of `NoWithVeto` votes is inferior to 1/3, including + `Abstain` votes. +* The proportion of `Yes` votes, excluding `Abstain` votes, at the end of + the voting period is superior to 1/2. + +For expedited proposals, by default, the threshold is higher than with a *normal proposal*, namely, 66.7%. + +#### Inheritance + +If a delegator does not vote, it will inherit its validator vote. + +* If the delegator votes before its validator, it will not inherit from the + validator's vote. +* If the delegator votes after its validator, it will override its validator + vote with its own. If the proposal is urgent, it is possible + that the vote will close before delegators have a chance to react and + override their validator's vote. This is not a problem, as proposals require more than 2/3rd of the total voting power to pass, when tallied at the end of the voting period. Because as little as 1/3 + 1 validation power could collude to censor transactions, non-collusion is already assumed for ranges exceeding this threshold. + +#### Validator’s punishment for non-voting + +At present, validators are not punished for failing to vote. + +#### Governance address + +Later, we may add permissioned keys that could only sign txs from certain modules. For the MVP, the `Governance address` will be the main validator address generated at account creation. This address corresponds to a different PrivKey than the CometBFT PrivKey which is responsible for signing consensus messages. Validators thus do not have to sign governance transactions with the sensitive CometBFT PrivKey. + +#### Burnable Params + +There are three parameters that define if the deposit of a proposal should be burned or returned to the depositors. + +* `BurnVoteVeto` burns the proposal deposit if the proposal gets vetoed. +* `BurnVoteQuorum` burns the proposal deposit if the proposal deposit if the vote does not reach quorum. +* `BurnProposalDepositPrevote` burns the proposal deposit if it does not enter the voting phase. + +> Note: These parameters are modifiable via governance. + +## State + +### Constitution + +`Constitution` is found in the genesis state. It is a string field intended to be used to descibe the purpose of a particular blockchain, and its expected norms. A few examples of how the constitution field can be used: + +* define the purpose of the chain, laying a foundation for its future development +* set expectations for delegators +* set expectations for validators +* define the chain's relationship to "meatspace" entities, like a foundation or corporation + +Since this is more of a social feature than a technical feature, we'll now get into some items that may have been useful to have in a genesis constitution: + +* What limitations on governance exist, if any? + * is it okay for the community to slash the wallet of a whale that they no longer feel that they want around? (viz: Juno Proposal 4 and 16) + * can governance "socially slash" a validator who is using unapproved MEV? (viz: commonwealth.im/osmosis) + * In the event of an economic emergency, what should validators do? + * Terra crash of May, 2022, saw validators choose to run a new binary with code that had not been approved by governance, because the governance token had been inflated to nothing. +* What is the purpose of the chain, specifically? + * best example of this is the Cosmos hub, where different founding groups, have different interpertations of the purpose of the network. + +This genesis entry, "constitution" hasn't been designed for existing chains, who should likely just ratify a constitution using their governance system. Instead, this is for new chains. It will allow for validators to have a much clearer idea of purpose and the expecations placed on them while operating thier nodes. Likewise, for community members, the constitution will give them some idea of what to expect from both the "chain team" and the validators, respectively. + +This constitution is designed to be immutable, and placed only in genesis, though that could change over time by a pull request to the cosmos-sdk that allows for the constitution to be changed by governance. Communities whishing to make amendments to their original constitution should use the governance mechanism and a "signaling proposal" to do exactly that. + +**Ideal use scenario for a cosmos chain constitution** + +As a chain developer, you decide that you'd like to provide clarity to your key user groups: + +* validators +* token holders +* developers (yourself) + +You use the constitution to immutably store some Markdown in genesis, so that when difficult questions come up, the constutituon can provide guidance to the community. + +### Proposals + +`Proposal` objects are used to tally votes and generally track the proposal's state. +They contain an array of arbitrary `sdk.Msg`'s which the governance module will attempt +to resolve and then execute if the proposal passes. `Proposal`'s are identified by a +unique id and contains a series of timestamps: `submit_time`, `deposit_end_time`, +`voting_start_time`, `voting_end_time` which track the lifecycle of a proposal + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1/gov.proto#L51-L99 +``` + +A proposal will generally require more than just a set of messages to explain its +purpose but need some greater justification and allow a means for interested participants +to discuss and debate the proposal. +In most cases, **it is encouraged to have an off-chain system that supports the on-chain governance process**. +To accommodate for this, a proposal contains a special **`metadata`** field, a string, +which can be used to add context to the proposal. The `metadata` field allows custom use for networks, +however, it is expected that the field contains a URL or some form of CID using a system such as +[IPFS](https://docs.ipfs.io/concepts/content-addressing/). To support the case of +interoperability across networks, the SDK recommends that the `metadata` represents +the following `JSON` template: + +```json +{ + "title": "...", + "description": "...", + "forum": "...", // a link to the discussion platform (i.e. Discord) + "other": "..." // any extra data that doesn't correspond to the other fields +} +``` + +This makes it far easier for clients to support multiple networks. + +The metadata has a maximum length that is chosen by the app developer, and +passed into the gov keeper as a config. The default maximum length in the SDK is 255 characters. + +#### Writing a module that uses governance + +There are many aspects of a chain, or of the individual modules that you may want to +use governance to perform such as changing various parameters. This is very simple +to do. First, write out your message types and `MsgServer` implementation. Add an +`authority` field to the keeper which will be populated in the constructor with the +governance module account: `govKeeper.GetGovernanceAccount().GetAddress()`. Then for +the methods in the `msg_server.go`, perform a check on the message that the signer +matches `authority`. This will prevent any user from executing that message. + +### Parameters and base types + +`Parameters` define the rules according to which votes are run. There can only +be one active parameter set at any given time. If governance wants to change a +parameter set, either to modify a value or add/remove a parameter field, a new +parameter set has to be created and the previous one rendered inactive. + +#### DepositParams + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1/gov.proto#L152-L162 +``` + +#### VotingParams + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1/gov.proto#L164-L168 +``` + +#### TallyParams + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1/gov.proto#L170-L182 +``` + +Parameters are stored in a global `GlobalParams` KVStore. + +Additionally, we introduce some basic types: + +```go +type Vote byte + +const ( + VoteYes = 0x1 + VoteNo = 0x2 + VoteNoWithVeto = 0x3 + VoteAbstain = 0x4 +) + +type ProposalType string + +const ( + ProposalTypePlainText = "Text" + ProposalTypeSoftwareUpgrade = "SoftwareUpgrade" +) + +type ProposalStatus byte + + +const ( + StatusNil ProposalStatus = 0x00 + StatusDepositPeriod ProposalStatus = 0x01 // Proposal is submitted. Participants can deposit on it but not vote + StatusVotingPeriod ProposalStatus = 0x02 // MinDeposit is reached, participants can vote + StatusPassed ProposalStatus = 0x03 // Proposal passed and successfully executed + StatusRejected ProposalStatus = 0x04 // Proposal has been rejected + StatusFailed ProposalStatus = 0x05 // Proposal passed but failed execution +) +``` + +### Deposit + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1/gov.proto#L38-L49 +``` + +### ValidatorGovInfo + +This type is used in a temp map when tallying + +```go + type ValidatorGovInfo struct { + Minus sdk.Dec + Vote Vote + } +``` + +## Stores + +:::note +Stores are KVStores in the multi-store. The key to find the store is the first parameter in the list +::: + +We will use one KVStore `Governance` to store four mappings: + +* A mapping from `proposalID|'proposal'` to `Proposal`. +* A mapping from `proposalID|'addresses'|address` to `Vote`. This mapping allows + us to query all addresses that voted on the proposal along with their vote by + doing a range query on `proposalID:addresses`. +* A mapping from `ParamsKey|'Params'` to `Params`. This map allows to query all + x/gov params. +* A mapping from `VotingPeriodProposalKeyPrefix|proposalID` to a single byte. This allows + us to know if a proposal is in the voting period or not with very low gas cost. + +For pseudocode purposes, here are the two function we will use to read or write in stores: + +* `load(StoreKey, Key)`: Retrieve item stored at key `Key` in store found at key `StoreKey` in the multistore +* `store(StoreKey, Key, value)`: Write value `Value` at key `Key` in store found at key `StoreKey` in the multistore + +### Proposal Processing Queue + +**Store:** + +* `ProposalProcessingQueue`: A queue `queue[proposalID]` containing all the + `ProposalIDs` of proposals that reached `MinDeposit`. During each `EndBlock`, + all the proposals that have reached the end of their voting period are processed. + To process a finished proposal, the application tallies the votes, computes the + votes of each validator and checks if every validator in the validator set has + voted. If the proposal is accepted, deposits are refunded. Finally, the proposal + content `Handler` is executed. + +And the pseudocode for the `ProposalProcessingQueue`: + +```go + in EndBlock do + + for finishedProposalID in GetAllFinishedProposalIDs(block.Time) + proposal = load(Governance, ) // proposal is a const key + + validators = Keeper.getAllValidators() + tmpValMap := map(sdk.AccAddress)ValidatorGovInfo + + // Initiate mapping at 0. This is the amount of shares of the validator's vote that will be overridden by their delegator's votes + for each validator in validators + tmpValMap(validator.OperatorAddr).Minus = 0 + + // Tally + voterIterator = rangeQuery(Governance, ) //return all the addresses that voted on the proposal + for each (voterAddress, vote) in voterIterator + delegations = stakingKeeper.getDelegations(voterAddress) // get all delegations for current voter + + for each delegation in delegations + // make sure delegation.Shares does NOT include shares being unbonded + tmpValMap(delegation.ValidatorAddr).Minus += delegation.Shares + proposal.updateTally(vote, delegation.Shares) + + _, isVal = stakingKeeper.getValidator(voterAddress) + if (isVal) + tmpValMap(voterAddress).Vote = vote + + tallyingParam = load(GlobalParams, 'TallyingParam') + + // Update tally if validator voted + for each validator in validators + if tmpValMap(validator).HasVoted + proposal.updateTally(tmpValMap(validator).Vote, (validator.TotalShares - tmpValMap(validator).Minus)) + + + + // Check if proposal is accepted or rejected + totalNonAbstain := proposal.YesVotes + proposal.NoVotes + proposal.NoWithVetoVotes + if (proposal.Votes.YesVotes/totalNonAbstain > tallyingParam.Threshold AND proposal.Votes.NoWithVetoVotes/totalNonAbstain < tallyingParam.Veto) + // proposal was accepted at the end of the voting period + // refund deposits (non-voters already punished) + for each (amount, depositor) in proposal.Deposits + depositor.AtomBalance += amount + + stateWriter, err := proposal.Handler() + if err != nil + // proposal passed but failed during state execution + proposal.CurrentStatus = ProposalStatusFailed + else + // proposal pass and state is persisted + proposal.CurrentStatus = ProposalStatusAccepted + stateWriter.save() + else + // proposal was rejected + proposal.CurrentStatus = ProposalStatusRejected + + store(Governance, , proposal) +``` + +### Legacy Proposal + +:::warning +Legacy proposals are deprecated. Use the new proposal flow by granting the governance module the right to execute the message. +::: + +A legacy proposal is the old implementation of governance proposal. +Contrary to proposal that can contain any messages, a legacy proposal allows to submit a set of pre-defined proposals. +These proposals are defined by their types and handled by handlers that are registered in the gov v1beta1 router. + +More information on how to submit proposals in the [client section](#client). + +## Messages + +### Proposal Submission + +Proposals can be submitted by any account via a `MsgSubmitProposal` transaction. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1/tx.proto#L42-L69 +``` + +All `sdk.Msgs` passed into the `messages` field of a `MsgSubmitProposal` message +must be registered in the app's `MsgServiceRouter`. Each of these messages must +have one signer, namely the gov module account. And finally, the metadata length +must not be larger than the `maxMetadataLen` config passed into the gov keeper. +The `initialDeposit` must be strictly positive and conform to the accepted denom of the `MinDeposit` param. + +**State modifications:** + +* Generate new `proposalID` +* Create new `Proposal` +* Initialise `Proposal`'s attributes +* Decrease balance of sender by `InitialDeposit` +* If `MinDeposit` is reached: + * Push `proposalID` in `ProposalProcessingQueue` +* Transfer `InitialDeposit` from the `Proposer` to the governance `ModuleAccount` + +### Deposit + +Once a proposal is submitted, if `Proposal.TotalDeposit < ActiveParam.MinDeposit`, Atom holders can send +`MsgDeposit` transactions to increase the proposal's deposit. + +A deposit is accepted iff: + +* The proposal exists +* The proposal is not in the voting period +* The deposited coins are conform to the accepted denom from the `MinDeposit` param + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1/tx.proto#L134-L147 +``` + +**State modifications:** + +* Decrease balance of sender by `deposit` +* Add `deposit` of sender in `proposal.Deposits` +* Increase `proposal.TotalDeposit` by sender's `deposit` +* If `MinDeposit` is reached: + * Push `proposalID` in `ProposalProcessingQueueEnd` +* Transfer `Deposit` from the `proposer` to the governance `ModuleAccount` + +### Vote + +Once `ActiveParam.MinDeposit` is reached, voting period starts. From there, +bonded Atom holders are able to send `MsgVote` transactions to cast their +vote on the proposal. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/gov/v1/tx.proto#L92-L108 +``` + +**State modifications:** + +* Record `Vote` of sender + +:::note +Gas cost for this message has to take into account the future tallying of the vote in EndBlocker. +::: + +## Events + +The governance module emits the following events: + +### EndBlocker + +| Type | Attribute Key | Attribute Value | +|-------------------|-----------------|------------------| +| inactive_proposal | proposal_id | {proposalID} | +| inactive_proposal | proposal_result | {proposalResult} | +| active_proposal | proposal_id | {proposalID} | +| active_proposal | proposal_result | {proposalResult} | + +### Handlers + +#### MsgSubmitProposal + +| Type | Attribute Key | Attribute Value | +|---------------------|---------------------|-----------------| +| submit_proposal | proposal_id | {proposalID} | +| submit_proposal [0] | voting_period_start | {proposalID} | +| proposal_deposit | amount | {depositAmount} | +| proposal_deposit | proposal_id | {proposalID} | +| message | module | governance | +| message | action | submit_proposal | +| message | sender | {senderAddress} | + +* [0] Event only emitted if the voting period starts during the submission. + +#### MsgVote + +| Type | Attribute Key | Attribute Value | +|---------------|---------------|-----------------| +| proposal_vote | option | {voteOption} | +| proposal_vote | proposal_id | {proposalID} | +| message | module | governance | +| message | action | vote | +| message | sender | {senderAddress} | + +#### MsgVoteWeighted + +| Type | Attribute Key | Attribute Value | +|---------------|---------------|-----------------------| +| proposal_vote | option | {weightedVoteOptions} | +| proposal_vote | proposal_id | {proposalID} | +| message | module | governance | +| message | action | vote | +| message | sender | {senderAddress} | + +#### MsgDeposit + +| Type | Attribute Key | Attribute Value | +|----------------------|---------------------|-----------------| +| proposal_deposit | amount | {depositAmount} | +| proposal_deposit | proposal_id | {proposalID} | +| proposal_deposit [0] | voting_period_start | {proposalID} | +| message | module | governance | +| message | action | deposit | +| message | sender | {senderAddress} | + +* [0] Event only emitted if the voting period starts during the submission. + +## Parameters + +The governance module contains the following parameters: + +| Key | Type | Example | +|-------------------------------|------------------|-----------------------------------------| +| min_deposit | array (coins) | [{"denom":"uatom","amount":"10000000"}] | +| max_deposit_period | string (time ns) | "172800000000000" (17280s) | +| voting_period | string (time ns) | "172800000000000" (17280s) | +| quorum | string (dec) | "0.334000000000000000" | +| threshold | string (dec) | "0.500000000000000000" | +| veto | string (dec) | "0.334000000000000000" | +| expedited_threshold | string (time ns) | "0.667000000000000000" | +| expedited_voting_period | string (time ns) | "86400000000000" (8600s) | +| expedited_min_deposit | array (coins) | [{"denom":"uatom","amount":"50000000"}] | +| burn_proposal_deposit_prevote | bool | false | +| burn_vote_quorum | bool | false | +| burn_vote_veto | bool | true | +| min_initial_deposit_ratio | string | "0.1" | + + +**NOTE**: The governance module contains parameters that are objects unlike other +modules. If only a subset of parameters are desired to be changed, only they need +to be included and not the entire parameter object structure. + +## Client + +### CLI + +A user can query and interact with the `gov` module using the CLI. + +#### Query + +The `query` commands allow users to query `gov` state. + +```bash +simd query gov --help +``` + +##### deposit + +The `deposit` command allows users to query a deposit for a given proposal from a given depositor. + +```bash +simd query gov deposit [proposal-id] [depositer-addr] [flags] +``` + +Example: + +```bash +simd query gov deposit 1 cosmos1.. +``` + +Example Output: + +```bash +amount: +- amount: "100" + denom: stake +depositor: cosmos1.. +proposal_id: "1" +``` + +##### deposits + +The `deposits` command allows users to query all deposits for a given proposal. + +```bash +simd query gov deposits [proposal-id] [flags] +``` + +Example: + +```bash +simd query gov deposits 1 +``` + +Example Output: + +```bash +deposits: +- amount: + - amount: "100" + denom: stake + depositor: cosmos1.. + proposal_id: "1" +pagination: + next_key: null + total: "0" +``` + +##### param + +The `param` command allows users to query a given parameter for the `gov` module. + +```bash +simd query gov param [param-type] [flags] +``` + +Example: + +```bash +simd query gov param voting +``` + +Example Output: + +```bash +voting_period: "172800000000000" +``` + +##### params + +The `params` command allows users to query all parameters for the `gov` module. + +```bash +simd query gov params [flags] +``` + +Example: + +```bash +simd query gov params +``` + +Example Output: + +```bash +deposit_params: + max_deposit_period: 172800s + min_deposit: + - amount: "10000000" + denom: stake +params: + expedited_min_deposit: + - amount: "50000000" + denom: stake + expedited_threshold: "0.670000000000000000" + expedited_voting_period: 86400s + max_deposit_period: 172800s + min_deposit: + - amount: "10000000" + denom: stake + min_initial_deposit_ratio: "0.000000000000000000" + proposal_cancel_burn_rate: "0.500000000000000000" + quorum: "0.334000000000000000" + threshold: "0.500000000000000000" + veto_threshold: "0.334000000000000000" + voting_period: 172800s +tally_params: + quorum: "0.334000000000000000" + threshold: "0.500000000000000000" + veto_threshold: "0.334000000000000000" +voting_params: + voting_period: 172800s +``` + +##### proposal + +The `proposal` command allows users to query a given proposal. + +```bash +simd query gov proposal [proposal-id] [flags] +``` + +Example: + +```bash +simd query gov proposal 1 +``` + +Example Output: + +```bash +deposit_end_time: "2022-03-30T11:50:20.819676256Z" +final_tally_result: + abstain_count: "0" + no_count: "0" + no_with_veto_count: "0" + yes_count: "0" +id: "1" +messages: +- '@type': /cosmos.bank.v1beta1.MsgSend + amount: + - amount: "10" + denom: stake + from_address: cosmos1.. + to_address: cosmos1.. +metadata: AQ== +status: PROPOSAL_STATUS_DEPOSIT_PERIOD +submit_time: "2022-03-28T11:50:20.819676256Z" +total_deposit: +- amount: "10" + denom: stake +voting_end_time: null +voting_start_time: null +``` + +##### proposals + +The `proposals` command allows users to query all proposals with optional filters. + +```bash +simd query gov proposals [flags] +``` + +Example: + +```bash +simd query gov proposals +``` + +Example Output: + +```bash +pagination: + next_key: null + total: "0" +proposals: +- deposit_end_time: "2022-03-30T11:50:20.819676256Z" + final_tally_result: + abstain_count: "0" + no_count: "0" + no_with_veto_count: "0" + yes_count: "0" + id: "1" + messages: + - '@type': /cosmos.bank.v1beta1.MsgSend + amount: + - amount: "10" + denom: stake + from_address: cosmos1.. + to_address: cosmos1.. + metadata: AQ== + status: PROPOSAL_STATUS_DEPOSIT_PERIOD + submit_time: "2022-03-28T11:50:20.819676256Z" + total_deposit: + - amount: "10" + denom: stake + voting_end_time: null + voting_start_time: null +- deposit_end_time: "2022-03-30T14:02:41.165025015Z" + final_tally_result: + abstain_count: "0" + no_count: "0" + no_with_veto_count: "0" + yes_count: "0" + id: "2" + messages: + - '@type': /cosmos.bank.v1beta1.MsgSend + amount: + - amount: "10" + denom: stake + from_address: cosmos1.. + to_address: cosmos1.. + metadata: AQ== + status: PROPOSAL_STATUS_DEPOSIT_PERIOD + submit_time: "2022-03-28T14:02:41.165025015Z" + total_deposit: + - amount: "10" + denom: stake + voting_end_time: null + voting_start_time: null +``` + +##### proposer + +The `proposer` command allows users to query the proposer for a given proposal. + +```bash +simd query gov proposer [proposal-id] [flags] +``` + +Example: + +```bash +simd query gov proposer 1 +``` + +Example Output: + +```bash +proposal_id: "1" +proposer: cosmos1.. +``` + +##### tally + +The `tally` command allows users to query the tally of a given proposal vote. + +```bash +simd query gov tally [proposal-id] [flags] +``` + +Example: + +```bash +simd query gov tally 1 +``` + +Example Output: + +```bash +abstain: "0" +"no": "0" +no_with_veto: "0" +"yes": "1" +``` + +##### vote + +The `vote` command allows users to query a vote for a given proposal. + +```bash +simd query gov vote [proposal-id] [voter-addr] [flags] +``` + +Example: + +```bash +simd query gov vote 1 cosmos1.. +``` + +Example Output: + +```bash +option: VOTE_OPTION_YES +options: +- option: VOTE_OPTION_YES + weight: "1.000000000000000000" +proposal_id: "1" +voter: cosmos1.. +``` + +##### votes + +The `votes` command allows users to query all votes for a given proposal. + +```bash +simd query gov votes [proposal-id] [flags] +``` + +Example: + +```bash +simd query gov votes 1 +``` + +Example Output: + +```bash +pagination: + next_key: null + total: "0" +votes: +- option: VOTE_OPTION_YES + options: + - option: VOTE_OPTION_YES + weight: "1.000000000000000000" + proposal_id: "1" + voter: cosmos1.. +``` + +#### Transactions + +The `tx` commands allow users to interact with the `gov` module. + +```bash +simd tx gov --help +``` + +##### deposit + +The `deposit` command allows users to deposit tokens for a given proposal. + +```bash +simd tx gov deposit [proposal-id] [deposit] [flags] +``` + +Example: + +```bash +simd tx gov deposit 1 10000000stake --from cosmos1.. +``` + +##### draft-proposal + +The `draft-proposal` command allows users to draft any type of proposal. +The command returns a `draft_proposal.json`, to be used by `submit-proposal` after being completed. +The `draft_metadata.json` is meant to be uploaded to [IPFS](#metadata). + +```bash +simd tx gov draft-proposal +``` + +##### submit-proposal + +The `submit-proposal` command allows users to submit a governance proposal along with some messages and metadata. +Messages, metadata and deposit are defined in a JSON file. + +```bash +simd tx gov submit-proposal [path-to-proposal-json] [flags] +``` + +Example: + +```bash +simd tx gov submit-proposal /path/to/proposal.json --from cosmos1.. +``` + +where `proposal.json` contains: + +```json +{ + "messages": [ + { + "@type": "/cosmos.bank.v1beta1.MsgSend", + "from_address": "cosmos1...", // The gov module module address + "to_address": "cosmos1...", + "amount":[{"denom": "stake","amount": "10"}] + } + ], + "metadata": "AQ==", + "deposit": "10stake", + "title": "Proposal Title", + "summary": "Proposal Summary" +} +``` + +:::note +By default the metadata, summary and title are both limited by 255 characters, this can be overridden by the application developer. +::: + +:::tip +When metadata is not specified, the title is limited to 255 characters and the summary 40x the title length. +::: + +##### submit-legacy-proposal + +The `submit-legacy-proposal` command allows users to submit a governance legacy proposal along with an initial deposit. + +```bash +simd tx gov submit-legacy-proposal [command] [flags] +``` + +Example: + +```bash +simd tx gov submit-legacy-proposal --title="Test Proposal" --description="testing" --type="Text" --deposit="100000000stake" --from cosmos1.. +``` + +Example (`param-change`): + +```bash +simd tx gov submit-legacy-proposal param-change proposal.json --from cosmos1.. +``` + +```json +{ + "title": "Test Proposal", + "description": "testing, testing, 1, 2, 3", + "changes": [ + { + "subspace": "staking", + "key": "MaxValidators", + "value": 100 + } + ], + "deposit": "10000000stake" +} +``` + +#### cancel-proposal + +Once proposal is canceled, from the deposits of proposal `deposits * proposal_cancel_ratio` will be burned or sent to `ProposalCancelDest` address , if `ProposalCancelDest` is empty then deposits will be burned. The `remaining deposits` will be sent to depositers. + +```bash +simd tx gov cancel-proposal [proposal-id] [flags] +``` + +Example: + +```bash +simd tx gov cancel-proposal 1 --from cosmos1... +``` + +##### vote + +The `vote` command allows users to submit a vote for a given governance proposal. + +```bash +simd tx gov vote [command] [flags] +``` + +Example: + +```bash +simd tx gov vote 1 yes --from cosmos1.. +``` + +##### weighted-vote + +The `weighted-vote` command allows users to submit a weighted vote for a given governance proposal. + +```bash +simd tx gov weighted-vote [proposal-id] [weighted-options] [flags] +``` + +Example: + +```bash +simd tx gov weighted-vote 1 yes=0.5,no=0.5 --from cosmos1.. +``` + +### gRPC + +A user can query the `gov` module using gRPC endpoints. + +#### Proposal + +The `Proposal` endpoint allows users to query a given proposal. + +Using legacy v1beta1: + +```bash +cosmos.gov.v1beta1.Query/Proposal +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' \ + localhost:9090 \ + cosmos.gov.v1beta1.Query/Proposal +``` + +Example Output: + +```bash +{ + "proposal": { + "proposalId": "1", + "content": {"@type":"/cosmos.gov.v1beta1.TextProposal","description":"testing, testing, 1, 2, 3","title":"Test Proposal"}, + "status": "PROPOSAL_STATUS_VOTING_PERIOD", + "finalTallyResult": { + "yes": "0", + "abstain": "0", + "no": "0", + "noWithVeto": "0" + }, + "submitTime": "2021-09-16T19:40:08.712440474Z", + "depositEndTime": "2021-09-18T19:40:08.712440474Z", + "totalDeposit": [ + { + "denom": "stake", + "amount": "10000000" + } + ], + "votingStartTime": "2021-09-16T19:40:08.712440474Z", + "votingEndTime": "2021-09-18T19:40:08.712440474Z", + "title": "Test Proposal", + "summary": "testing, testing, 1, 2, 3" + } +} +``` + +Using v1: + +```bash +cosmos.gov.v1.Query/Proposal +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' \ + localhost:9090 \ + cosmos.gov.v1.Query/Proposal +``` + +Example Output: + +```bash +{ + "proposal": { + "id": "1", + "messages": [ + {"@type":"/cosmos.bank.v1beta1.MsgSend","amount":[{"denom":"stake","amount":"10"}],"fromAddress":"cosmos1..","toAddress":"cosmos1.."} + ], + "status": "PROPOSAL_STATUS_VOTING_PERIOD", + "finalTallyResult": { + "yesCount": "0", + "abstainCount": "0", + "noCount": "0", + "noWithVetoCount": "0" + }, + "submitTime": "2022-03-28T11:50:20.819676256Z", + "depositEndTime": "2022-03-30T11:50:20.819676256Z", + "totalDeposit": [ + { + "denom": "stake", + "amount": "10000000" + } + ], + "votingStartTime": "2022-03-28T14:25:26.644857113Z", + "votingEndTime": "2022-03-30T14:25:26.644857113Z", + "metadata": "AQ==", + "title": "Test Proposal", + "summary": "testing, testing, 1, 2, 3" + } +} +``` + +#### Proposals + +The `Proposals` endpoint allows users to query all proposals with optional filters. + +Using legacy v1beta1: + +```bash +cosmos.gov.v1beta1.Query/Proposals +``` + +Example: + +```bash +grpcurl -plaintext \ + localhost:9090 \ + cosmos.gov.v1beta1.Query/Proposals +``` + +Example Output: + +```bash +{ + "proposals": [ + { + "proposalId": "1", + "status": "PROPOSAL_STATUS_VOTING_PERIOD", + "finalTallyResult": { + "yes": "0", + "abstain": "0", + "no": "0", + "noWithVeto": "0" + }, + "submitTime": "2022-03-28T11:50:20.819676256Z", + "depositEndTime": "2022-03-30T11:50:20.819676256Z", + "totalDeposit": [ + { + "denom": "stake", + "amount": "10000000010" + } + ], + "votingStartTime": "2022-03-28T14:25:26.644857113Z", + "votingEndTime": "2022-03-30T14:25:26.644857113Z" + }, + { + "proposalId": "2", + "status": "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "finalTallyResult": { + "yes": "0", + "abstain": "0", + "no": "0", + "noWithVeto": "0" + }, + "submitTime": "2022-03-28T14:02:41.165025015Z", + "depositEndTime": "2022-03-30T14:02:41.165025015Z", + "totalDeposit": [ + { + "denom": "stake", + "amount": "10" + } + ], + "votingStartTime": "0001-01-01T00:00:00Z", + "votingEndTime": "0001-01-01T00:00:00Z" + } + ], + "pagination": { + "total": "2" + } +} + +``` + +Using v1: + +```bash +cosmos.gov.v1.Query/Proposals +``` + +Example: + +```bash +grpcurl -plaintext \ + localhost:9090 \ + cosmos.gov.v1.Query/Proposals +``` + +Example Output: + +```bash +{ + "proposals": [ + { + "id": "1", + "messages": [ + {"@type":"/cosmos.bank.v1beta1.MsgSend","amount":[{"denom":"stake","amount":"10"}],"fromAddress":"cosmos1..","toAddress":"cosmos1.."} + ], + "status": "PROPOSAL_STATUS_VOTING_PERIOD", + "finalTallyResult": { + "yesCount": "0", + "abstainCount": "0", + "noCount": "0", + "noWithVetoCount": "0" + }, + "submitTime": "2022-03-28T11:50:20.819676256Z", + "depositEndTime": "2022-03-30T11:50:20.819676256Z", + "totalDeposit": [ + { + "denom": "stake", + "amount": "10000000010" + } + ], + "votingStartTime": "2022-03-28T14:25:26.644857113Z", + "votingEndTime": "2022-03-30T14:25:26.644857113Z", + "metadata": "AQ==", + "title": "Proposal Title", + "summary": "Proposal Summary" + }, + { + "id": "2", + "messages": [ + {"@type":"/cosmos.bank.v1beta1.MsgSend","amount":[{"denom":"stake","amount":"10"}],"fromAddress":"cosmos1..","toAddress":"cosmos1.."} + ], + "status": "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "finalTallyResult": { + "yesCount": "0", + "abstainCount": "0", + "noCount": "0", + "noWithVetoCount": "0" + }, + "submitTime": "2022-03-28T14:02:41.165025015Z", + "depositEndTime": "2022-03-30T14:02:41.165025015Z", + "totalDeposit": [ + { + "denom": "stake", + "amount": "10" + } + ], + "metadata": "AQ==", + "title": "Proposal Title", + "summary": "Proposal Summary" + } + ], + "pagination": { + "total": "2" + } +} +``` + +#### Vote + +The `Vote` endpoint allows users to query a vote for a given proposal. + +Using legacy v1beta1: + +```bash +cosmos.gov.v1beta1.Query/Vote +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1","voter":"cosmos1.."}' \ + localhost:9090 \ + cosmos.gov.v1beta1.Query/Vote +``` + +Example Output: + +```bash +{ + "vote": { + "proposalId": "1", + "voter": "cosmos1..", + "option": "VOTE_OPTION_YES", + "options": [ + { + "option": "VOTE_OPTION_YES", + "weight": "1000000000000000000" + } + ] + } +} +``` + +Using v1: + +```bash +cosmos.gov.v1.Query/Vote +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1","voter":"cosmos1.."}' \ + localhost:9090 \ + cosmos.gov.v1.Query/Vote +``` + +Example Output: + +```bash +{ + "vote": { + "proposalId": "1", + "voter": "cosmos1..", + "option": "VOTE_OPTION_YES", + "options": [ + { + "option": "VOTE_OPTION_YES", + "weight": "1.000000000000000000" + } + ] + } +} +``` + +#### Votes + +The `Votes` endpoint allows users to query all votes for a given proposal. + +Using legacy v1beta1: + +```bash +cosmos.gov.v1beta1.Query/Votes +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' \ + localhost:9090 \ + cosmos.gov.v1beta1.Query/Votes +``` + +Example Output: + +```bash +{ + "votes": [ + { + "proposalId": "1", + "voter": "cosmos1..", + "options": [ + { + "option": "VOTE_OPTION_YES", + "weight": "1000000000000000000" + } + ] + } + ], + "pagination": { + "total": "1" + } +} +``` + +Using v1: + +```bash +cosmos.gov.v1.Query/Votes +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' \ + localhost:9090 \ + cosmos.gov.v1.Query/Votes +``` + +Example Output: + +```bash +{ + "votes": [ + { + "proposalId": "1", + "voter": "cosmos1..", + "options": [ + { + "option": "VOTE_OPTION_YES", + "weight": "1.000000000000000000" + } + ] + } + ], + "pagination": { + "total": "1" + } +} +``` + +#### Params + +The `Params` endpoint allows users to query all parameters for the `gov` module. + + + +Using legacy v1beta1: + +```bash +cosmos.gov.v1beta1.Query/Params +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"params_type":"voting"}' \ + localhost:9090 \ + cosmos.gov.v1beta1.Query/Params +``` + +Example Output: + +```bash +{ + "votingParams": { + "votingPeriod": "172800s" + }, + "depositParams": { + "maxDepositPeriod": "0s" + }, + "tallyParams": { + "quorum": "MA==", + "threshold": "MA==", + "vetoThreshold": "MA==" + } +} +``` + +Using v1: + +```bash +cosmos.gov.v1.Query/Params +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"params_type":"voting"}' \ + localhost:9090 \ + cosmos.gov.v1.Query/Params +``` + +Example Output: + +```bash +{ + "votingParams": { + "votingPeriod": "172800s" + } +} +``` + +#### Deposit + +The `Deposit` endpoint allows users to query a deposit for a given proposal from a given depositor. + +Using legacy v1beta1: + +```bash +cosmos.gov.v1beta1.Query/Deposit +``` + +Example: + +```bash +grpcurl -plaintext \ + '{"proposal_id":"1","depositor":"cosmos1.."}' \ + localhost:9090 \ + cosmos.gov.v1beta1.Query/Deposit +``` + +Example Output: + +```bash +{ + "deposit": { + "proposalId": "1", + "depositor": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10000000" + } + ] + } +} +``` + +Using v1: + +```bash +cosmos.gov.v1.Query/Deposit +``` + +Example: + +```bash +grpcurl -plaintext \ + '{"proposal_id":"1","depositor":"cosmos1.."}' \ + localhost:9090 \ + cosmos.gov.v1.Query/Deposit +``` + +Example Output: + +```bash +{ + "deposit": { + "proposalId": "1", + "depositor": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10000000" + } + ] + } +} +``` + +#### deposits + +The `Deposits` endpoint allows users to query all deposits for a given proposal. + +Using legacy v1beta1: + +```bash +cosmos.gov.v1beta1.Query/Deposits +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' \ + localhost:9090 \ + cosmos.gov.v1beta1.Query/Deposits +``` + +Example Output: + +```bash +{ + "deposits": [ + { + "proposalId": "1", + "depositor": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10000000" + } + ] + } + ], + "pagination": { + "total": "1" + } +} +``` + +Using v1: + +```bash +cosmos.gov.v1.Query/Deposits +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' \ + localhost:9090 \ + cosmos.gov.v1.Query/Deposits +``` + +Example Output: + +```bash +{ + "deposits": [ + { + "proposalId": "1", + "depositor": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10000000" + } + ] + } + ], + "pagination": { + "total": "1" + } +} +``` + +#### TallyResult + +The `TallyResult` endpoint allows users to query the tally of a given proposal. + +Using legacy v1beta1: + +```bash +cosmos.gov.v1beta1.Query/TallyResult +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' \ + localhost:9090 \ + cosmos.gov.v1beta1.Query/TallyResult +``` + +Example Output: + +```bash +{ + "tally": { + "yes": "1000000", + "abstain": "0", + "no": "0", + "noWithVeto": "0" + } +} +``` + +Using v1: + +```bash +cosmos.gov.v1.Query/TallyResult +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' \ + localhost:9090 \ + cosmos.gov.v1.Query/TallyResult +``` + +Example Output: + +```bash +{ + "tally": { + "yes": "1000000", + "abstain": "0", + "no": "0", + "noWithVeto": "0" + } +} +``` + +### REST + +A user can query the `gov` module using REST endpoints. + +#### proposal + +The `proposals` endpoint allows users to query a given proposal. + +Using legacy v1beta1: + +```bash +/cosmos/gov/v1beta1/proposals/{proposal_id} +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1beta1/proposals/1 +``` + +Example Output: + +```bash +{ + "proposal": { + "proposal_id": "1", + "content": null, + "status": "PROPOSAL_STATUS_VOTING_PERIOD", + "final_tally_result": { + "yes": "0", + "abstain": "0", + "no": "0", + "no_with_veto": "0" + }, + "submit_time": "2022-03-28T11:50:20.819676256Z", + "deposit_end_time": "2022-03-30T11:50:20.819676256Z", + "total_deposit": [ + { + "denom": "stake", + "amount": "10000000010" + } + ], + "voting_start_time": "2022-03-28T14:25:26.644857113Z", + "voting_end_time": "2022-03-30T14:25:26.644857113Z" + } +} +``` + +Using v1: + +```bash +/cosmos/gov/v1/proposals/{proposal_id} +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1/proposals/1 +``` + +Example Output: + +```bash +{ + "proposal": { + "id": "1", + "messages": [ + { + "@type": "/cosmos.bank.v1beta1.MsgSend", + "from_address": "cosmos1..", + "to_address": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10" + } + ] + } + ], + "status": "PROPOSAL_STATUS_VOTING_PERIOD", + "final_tally_result": { + "yes_count": "0", + "abstain_count": "0", + "no_count": "0", + "no_with_veto_count": "0" + }, + "submit_time": "2022-03-28T11:50:20.819676256Z", + "deposit_end_time": "2022-03-30T11:50:20.819676256Z", + "total_deposit": [ + { + "denom": "stake", + "amount": "10000000" + } + ], + "voting_start_time": "2022-03-28T14:25:26.644857113Z", + "voting_end_time": "2022-03-30T14:25:26.644857113Z", + "metadata": "AQ==", + "title": "Proposal Title", + "summary": "Proposal Summary" + } +} +``` + +#### proposals + +The `proposals` endpoint also allows users to query all proposals with optional filters. + +Using legacy v1beta1: + +```bash +/cosmos/gov/v1beta1/proposals +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1beta1/proposals +``` + +Example Output: + +```bash +{ + "proposals": [ + { + "proposal_id": "1", + "content": null, + "status": "PROPOSAL_STATUS_VOTING_PERIOD", + "final_tally_result": { + "yes": "0", + "abstain": "0", + "no": "0", + "no_with_veto": "0" + }, + "submit_time": "2022-03-28T11:50:20.819676256Z", + "deposit_end_time": "2022-03-30T11:50:20.819676256Z", + "total_deposit": [ + { + "denom": "stake", + "amount": "10000000" + } + ], + "voting_start_time": "2022-03-28T14:25:26.644857113Z", + "voting_end_time": "2022-03-30T14:25:26.644857113Z" + }, + { + "proposal_id": "2", + "content": null, + "status": "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "final_tally_result": { + "yes": "0", + "abstain": "0", + "no": "0", + "no_with_veto": "0" + }, + "submit_time": "2022-03-28T14:02:41.165025015Z", + "deposit_end_time": "2022-03-30T14:02:41.165025015Z", + "total_deposit": [ + { + "denom": "stake", + "amount": "10" + } + ], + "voting_start_time": "0001-01-01T00:00:00Z", + "voting_end_time": "0001-01-01T00:00:00Z" + } + ], + "pagination": { + "next_key": null, + "total": "2" + } +} +``` + +Using v1: + +```bash +/cosmos/gov/v1/proposals +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1/proposals +``` + +Example Output: + +```bash +{ + "proposals": [ + { + "id": "1", + "messages": [ + { + "@type": "/cosmos.bank.v1beta1.MsgSend", + "from_address": "cosmos1..", + "to_address": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10" + } + ] + } + ], + "status": "PROPOSAL_STATUS_VOTING_PERIOD", + "final_tally_result": { + "yes_count": "0", + "abstain_count": "0", + "no_count": "0", + "no_with_veto_count": "0" + }, + "submit_time": "2022-03-28T11:50:20.819676256Z", + "deposit_end_time": "2022-03-30T11:50:20.819676256Z", + "total_deposit": [ + { + "denom": "stake", + "amount": "10000000010" + } + ], + "voting_start_time": "2022-03-28T14:25:26.644857113Z", + "voting_end_time": "2022-03-30T14:25:26.644857113Z", + "metadata": "AQ==", + "title": "Proposal Title", + "summary": "Proposal Summary" + }, + { + "id": "2", + "messages": [ + { + "@type": "/cosmos.bank.v1beta1.MsgSend", + "from_address": "cosmos1..", + "to_address": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10" + } + ] + } + ], + "status": "PROPOSAL_STATUS_DEPOSIT_PERIOD", + "final_tally_result": { + "yes_count": "0", + "abstain_count": "0", + "no_count": "0", + "no_with_veto_count": "0" + }, + "submit_time": "2022-03-28T14:02:41.165025015Z", + "deposit_end_time": "2022-03-30T14:02:41.165025015Z", + "total_deposit": [ + { + "denom": "stake", + "amount": "10" + } + ], + "voting_start_time": null, + "voting_end_time": null, + "metadata": "AQ==", + "title": "Proposal Title", + "summary": "Proposal Summary" + } + ], + "pagination": { + "next_key": null, + "total": "2" + } +} +``` + +#### voter vote + +The `votes` endpoint allows users to query a vote for a given proposal. + +Using legacy v1beta1: + +```bash +/cosmos/gov/v1beta1/proposals/{proposal_id}/votes/{voter} +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1beta1/proposals/1/votes/cosmos1.. +``` + +Example Output: + +```bash +{ + "vote": { + "proposal_id": "1", + "voter": "cosmos1..", + "option": "VOTE_OPTION_YES", + "options": [ + { + "option": "VOTE_OPTION_YES", + "weight": "1.000000000000000000" + } + ] + } +} +``` + +Using v1: + +```bash +/cosmos/gov/v1/proposals/{proposal_id}/votes/{voter} +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1/proposals/1/votes/cosmos1.. +``` + +Example Output: + +```bash +{ + "vote": { + "proposal_id": "1", + "voter": "cosmos1..", + "options": [ + { + "option": "VOTE_OPTION_YES", + "weight": "1.000000000000000000" + } + ], + "metadata": "" + } +} +``` + +#### votes + +The `votes` endpoint allows users to query all votes for a given proposal. + +Using legacy v1beta1: + +```bash +/cosmos/gov/v1beta1/proposals/{proposal_id}/votes +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1beta1/proposals/1/votes +``` + +Example Output: + +```bash +{ + "votes": [ + { + "proposal_id": "1", + "voter": "cosmos1..", + "option": "VOTE_OPTION_YES", + "options": [ + { + "option": "VOTE_OPTION_YES", + "weight": "1.000000000000000000" + } + ] + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +Using v1: + +```bash +/cosmos/gov/v1/proposals/{proposal_id}/votes +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1/proposals/1/votes +``` + +Example Output: + +```bash +{ + "votes": [ + { + "proposal_id": "1", + "voter": "cosmos1..", + "options": [ + { + "option": "VOTE_OPTION_YES", + "weight": "1.000000000000000000" + } + ], + "metadata": "" + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +#### params + +The `params` endpoint allows users to query all parameters for the `gov` module. + + + +Using legacy v1beta1: + +```bash +/cosmos/gov/v1beta1/params/{params_type} +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1beta1/params/voting +``` + +Example Output: + +```bash +{ + "voting_params": { + "voting_period": "172800s" + }, + "deposit_params": { + "min_deposit": [ + ], + "max_deposit_period": "0s" + }, + "tally_params": { + "quorum": "0.000000000000000000", + "threshold": "0.000000000000000000", + "veto_threshold": "0.000000000000000000" + } +} +``` + +Using v1: + +```bash +/cosmos/gov/v1/params/{params_type} +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1/params/voting +``` + +Example Output: + +```bash +{ + "voting_params": { + "voting_period": "172800s" + }, + "deposit_params": { + "min_deposit": [ + ], + "max_deposit_period": "0s" + }, + "tally_params": { + "quorum": "0.000000000000000000", + "threshold": "0.000000000000000000", + "veto_threshold": "0.000000000000000000" + } +} +``` + +#### deposits + +The `deposits` endpoint allows users to query a deposit for a given proposal from a given depositor. + +Using legacy v1beta1: + +```bash +/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits/{depositor} +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1beta1/proposals/1/deposits/cosmos1.. +``` + +Example Output: + +```bash +{ + "deposit": { + "proposal_id": "1", + "depositor": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10000000" + } + ] + } +} +``` + +Using v1: + +```bash +/cosmos/gov/v1/proposals/{proposal_id}/deposits/{depositor} +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1/proposals/1/deposits/cosmos1.. +``` + +Example Output: + +```bash +{ + "deposit": { + "proposal_id": "1", + "depositor": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10000000" + } + ] + } +} +``` + +#### proposal deposits + +The `deposits` endpoint allows users to query all deposits for a given proposal. + +Using legacy v1beta1: + +```bash +/cosmos/gov/v1beta1/proposals/{proposal_id}/deposits +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1beta1/proposals/1/deposits +``` + +Example Output: + +```bash +{ + "deposits": [ + { + "proposal_id": "1", + "depositor": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10000000" + } + ] + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +Using v1: + +```bash +/cosmos/gov/v1/proposals/{proposal_id}/deposits +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1/proposals/1/deposits +``` + +Example Output: + +```bash +{ + "deposits": [ + { + "proposal_id": "1", + "depositor": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "10000000" + } + ] + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +#### tally + +The `tally` endpoint allows users to query the tally of a given proposal. + +Using legacy v1beta1: + +```bash +/cosmos/gov/v1beta1/proposals/{proposal_id}/tally +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1beta1/proposals/1/tally +``` + +Example Output: + +```bash +{ + "tally": { + "yes": "1000000", + "abstain": "0", + "no": "0", + "no_with_veto": "0" + } +} +``` + +Using v1: + +```bash +/cosmos/gov/v1/proposals/{proposal_id}/tally +``` + +Example: + +```bash +curl localhost:1317/cosmos/gov/v1/proposals/1/tally +``` + +Example Output: + +```bash +{ + "tally": { + "yes": "1000000", + "abstain": "0", + "no": "0", + "no_with_veto": "0" + } +} +``` + +## Metadata + +The gov module has two locations for metadata where users can provide further context about the on-chain actions they are taking. By default all metadata fields have a 255 character length field where metadata can be stored in json format, either on-chain or off-chain depending on the amount of data required. Here we provide a recommendation for the json structure and where the data should be stored. There are two important factors in making these recommendations. First, that the gov and group modules are consistent with one another, note the number of proposals made by all groups may be quite large. Second, that client applications such as block explorers and governance interfaces have confidence in the consistency of metadata structure accross chains. + +### Proposal + +Location: off-chain as json object stored on IPFS (mirrors [group proposal](../group/README.md#metadata)) + +```json +{ + "title": "", + "authors": [""], + "summary": "", + "details": "", + "proposal_forum_url": "", + "vote_option_context": "", +} +``` + +:::note +The `authors` field is an array of strings, this is to allow for multiple authors to be listed in the metadata. +In v0.46, the `authors` field is a comma-separated string. Frontends are encouraged to support both formats for backwards compatibility. +::: + +### Vote + +Location: on-chain as json within 255 character limit (mirrors [group vote](../group/README.md#metadata)) + +```json +{ + "justification": "", +} +``` + +## Future Improvements + +The current documentation only describes the minimum viable product for the +governance module. Future improvements may include: + +* **`BountyProposals`:** If accepted, a `BountyProposal` creates an open + bounty. The `BountyProposal` specifies how many Atoms will be given upon + completion. These Atoms will be taken from the `reserve pool`. After a + `BountyProposal` is accepted by governance, anybody can submit a + `SoftwareUpgradeProposal` with the code to claim the bounty. Note that once a + `BountyProposal` is accepted, the corresponding funds in the `reserve pool` + are locked so that payment can always be honored. In order to link a + `SoftwareUpgradeProposal` to an open bounty, the submitter of the + `SoftwareUpgradeProposal` will use the `Proposal.LinkedProposal` attribute. + If a `SoftwareUpgradeProposal` linked to an open bounty is accepted by + governance, the funds that were reserved are automatically transferred to the + submitter. +* **Complex delegation:** Delegators could choose other representatives than + their validators. Ultimately, the chain of representatives would always end + up to a validator, but delegators could inherit the vote of their chosen + representative before they inherit the vote of their validator. In other + words, they would only inherit the vote of their validator if their other + appointed representative did not vote. +* **Better process for proposal review:** There would be two parts to + `proposal.Deposit`, one for anti-spam (same as in MVP) and an other one to + reward third party auditors. diff --git a/.gitbook/developers/modules/core/group/README.md b/.gitbook/developers/modules/core/group/README.md new file mode 100644 index 00000000..71d91ccb --- /dev/null +++ b/.gitbook/developers/modules/core/group/README.md @@ -0,0 +1,2166 @@ +--- +sidebar_position: 1 +--- + +# `x/group` + +## Abstract + +The following documents specify the group module. + +This module allows the creation and management of on-chain multisig accounts and enables voting for message execution based on configurable decision policies. + +## Contents + +* [Concepts](#concepts) + * [Group](#group) + * [Group Policy](#group-policy) + * [Decision Policy](#decision-policy) + * [Proposal](#proposal) + * [Pruning](#pruning) +* [State](#state) + * [Group Table](#group-table) + * [Group Member Table](#group-member-table) + * [Group Policy Table](#group-policy-table) + * [Proposal Table](#proposal-table) + * [Vote Table](#vote-table) +* [Msg Service](#msg-service) + * [Msg/CreateGroup](#msgcreategroup) + * [Msg/UpdateGroupMembers](#msgupdategroupmembers) + * [Msg/UpdateGroupAdmin](#msgupdategroupadmin) + * [Msg/UpdateGroupMetadata](#msgupdategroupmetadata) + * [Msg/CreateGroupPolicy](#msgcreategrouppolicy) + * [Msg/CreateGroupWithPolicy](#msgcreategroupwithpolicy) + * [Msg/UpdateGroupPolicyAdmin](#msgupdategrouppolicyadmin) + * [Msg/UpdateGroupPolicyDecisionPolicy](#msgupdategrouppolicydecisionpolicy) + * [Msg/UpdateGroupPolicyMetadata](#msgupdategrouppolicymetadata) + * [Msg/SubmitProposal](#msgsubmitproposal) + * [Msg/WithdrawProposal](#msgwithdrawproposal) + * [Msg/Vote](#msgvote) + * [Msg/Exec](#msgexec) + * [Msg/LeaveGroup](#msgleavegroup) +* [Events](#events) + * [EventCreateGroup](#eventcreategroup) + * [EventUpdateGroup](#eventupdategroup) + * [EventCreateGroupPolicy](#eventcreategrouppolicy) + * [EventUpdateGroupPolicy](#eventupdategrouppolicy) + * [EventCreateProposal](#eventcreateproposal) + * [EventWithdrawProposal](#eventwithdrawproposal) + * [EventVote](#eventvote) + * [EventExec](#eventexec) + * [EventLeaveGroup](#eventleavegroup) + * [EventProposalPruned](#eventproposalpruned) +* [Client](#client) + * [CLI](#cli) + * [gRPC](#grpc) + * [REST](#rest) +* [Metadata](#metadata) + +## Concepts + +### Group + +A group is simply an aggregation of accounts with associated weights. It is not +an account and doesn't have a balance. It doesn't in and of itself have any +sort of voting or decision weight. It does have an "administrator" which has +the ability to add, remove and update members in the group. Note that a +group policy account could be an administrator of a group, and that the +administrator doesn't necessarily have to be a member of the group. + +### Group Policy + +A group policy is an account associated with a group and a decision policy. +Group policies are abstracted from groups because a single group may have +multiple decision policies for different types of actions. Managing group +membership separately from decision policies results in the least overhead +and keeps membership consistent across different policies. The pattern that +is recommended is to have a single master group policy for a given group, +and then to create separate group policies with different decision policies +and delegate the desired permissions from the master account to +those "sub-accounts" using the `x/authz` module. + +### Decision Policy + +A decision policy is the mechanism by which members of a group can vote on +proposals, as well as the rules that dictate whether a proposal should pass +or not based on its tally outcome. + +All decision policies generally would have a mininum execution period and a +maximum voting window. The minimum execution period is the minimum amount of time +that must pass after submission in order for a proposal to potentially be executed, and it may +be set to 0. The maximum voting window is the maximum time after submission that a proposal may +be voted on before it is tallied. + +The chain developer also defines an app-wide maximum execution period, which is +the maximum amount of time after a proposal's voting period end where users are +allowed to execute a proposal. + +The current group module comes shipped with two decision policies: threshold +and percentage. Any chain developer can extend upon these two, by creating +custom decision policies, as long as they adhere to the `DecisionPolicy` +interface: + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/x/group/types.go#L27-L45 +``` + +#### Threshold decision policy + +A threshold decision policy defines a threshold of yes votes (based on a tally +of voter weights) that must be achieved in order for a proposal to pass. For +this decision policy, abstain and veto are simply treated as no's. + +This decision policy also has a VotingPeriod window and a MinExecutionPeriod +window. The former defines the duration after proposal submission where members +are allowed to vote, after which tallying is performed. The latter specifies +the minimum duration after proposal submission where the proposal can be +executed. If set to 0, then the proposal is allowed to be executed immediately +on submission (using the `TRY_EXEC` option). Obviously, MinExecutionPeriod +cannot be greater than VotingPeriod+MaxExecutionPeriod (where MaxExecution is +the app-defined duration that specifies the window after voting ended where a +proposal can be executed). + +#### Percentage decision policy + +A percentage decision policy is similar to a threshold decision policy, except +that the threshold is not defined as a constant weight, but as a percentage. +It's more suited for groups where the group members' weights can be updated, as +the percentage threshold stays the same, and doesn't depend on how those member +weights get updated. + +Same as the Threshold decision policy, the percentage decision policy has the +two VotingPeriod and MinExecutionPeriod parameters. + +### Proposal + +Any member(s) of a group can submit a proposal for a group policy account to decide upon. +A proposal consists of a set of messages that will be executed if the proposal +passes as well as any metadata associated with the proposal. + +#### Voting + +There are four choices to choose while voting - yes, no, abstain and veto. Not +all decision policies will take the four choices into account. Votes can contain some optional metadata. +In the current implementation, the voting window begins as soon as a proposal +is submitted, and the end is defined by the group policy's decision policy. + +#### Withdrawing Proposals + +Proposals can be withdrawn any time before the voting period end, either by the +admin of the group policy or by one of the proposers. Once withdrawn, it is +marked as `PROPOSAL_STATUS_WITHDRAWN`, and no more voting or execution is +allowed on it. + +#### Aborted Proposals + +If the group policy is updated during the voting period of the proposal, then +the proposal is marked as `PROPOSAL_STATUS_ABORTED`, and no more voting or +execution is allowed on it. This is because the group policy defines the rules +of proposal voting and execution, so if those rules change during the lifecycle +of a proposal, then the proposal should be marked as stale. + +#### Tallying + +Tallying is the counting of all votes on a proposal. It happens only once in +the lifecycle of a proposal, but can be triggered by two factors, whichever +happens first: + +* either someone tries to execute the proposal (see next section), which can + happen on a `Msg/Exec` transaction, or a `Msg/{SubmitProposal,Vote}` + transaction with the `Exec` field set. When a proposal execution is attempted, + a tally is done first to make sure the proposal passes. +* or on `EndBlock` when the proposal's voting period end just passed. + +If the tally result passes the decision policy's rules, then the proposal is +marked as `PROPOSAL_STATUS_ACCEPTED`, or else it is marked as +`PROPOSAL_STATUS_REJECTED`. In any case, no more voting is allowed anymore, and the tally +result is persisted to state in the proposal's `FinalTallyResult`. + +#### Executing Proposals + +Proposals are executed only when the tallying is done, and the group account's +decision policy allows the proposal to pass based on the tally outcome. They +are marked by the status `PROPOSAL_STATUS_ACCEPTED`. Execution must happen +before a duration of `MaxExecutionPeriod` (set by the chain developer) after +each proposal's voting period end. + +Proposals will not be automatically executed by the chain in this current design, +but rather a user must submit a `Msg/Exec` transaction to attempt to execute the +proposal based on the current votes and decision policy. Any user (not only the +group members) can execute proposals that have been accepted, and execution fees are +paid by the proposal executor. +It's also possible to try to execute a proposal immediately on creation or on +new votes using the `Exec` field of `Msg/SubmitProposal` and `Msg/Vote` requests. +In the former case, proposers signatures are considered as yes votes. +In these cases, if the proposal can't be executed (i.e. it didn't pass the +decision policy's rules), it will still be opened for new votes and +could be tallied and executed later on. + +A successful proposal execution will have its `ExecutorResult` marked as +`PROPOSAL_EXECUTOR_RESULT_SUCCESS`. The proposal will be automatically pruned +after execution. On the other hand, a failed proposal execution will be marked +as `PROPOSAL_EXECUTOR_RESULT_FAILURE`. Such a proposal can be re-executed +multiple times, until it expires after `MaxExecutionPeriod` after voting period +end. + +### Pruning + +Proposals and votes are automatically pruned to avoid state bloat. + +Votes are pruned: + +* either after a successful tally, i.e. a tally whose result passes the decision + policy's rules, which can be trigged by a `Msg/Exec` or a + `Msg/{SubmitProposal,Vote}` with the `Exec` field set, +* or on `EndBlock` right after the proposal's voting period end. This applies to proposals with status `aborted` or `withdrawn` too. + +whichever happens first. + +Proposals are pruned: + +* on `EndBlock` whose proposal status is `withdrawn` or `aborted` on proposal's voting period end before tallying, +* and either after a successful proposal execution, +* or on `EndBlock` right after the proposal's `voting_period_end` + + `max_execution_period` (defined as an app-wide configuration) is passed, + +whichever happens first. + +## State + +The `group` module uses the `orm` package which provides table storage with support for +primary keys and secondary indexes. `orm` also defines `Sequence` which is a persistent unique key generator based on a counter that can be used along with `Table`s. + +Here's the list of tables and associated sequences and indexes stored as part of the `group` module. + +### Group Table + +The `groupTable` stores `GroupInfo`: `0x0 | BigEndian(GroupId) -> ProtocolBuffer(GroupInfo)`. + +#### groupSeq + +The value of `groupSeq` is incremented when creating a new group and corresponds to the new `GroupId`: `0x1 | 0x1 -> BigEndian`. + +The second `0x1` corresponds to the ORM `sequenceStorageKey`. + +#### groupByAdminIndex + +`groupByAdminIndex` allows to retrieve groups by admin address: +`0x2 | len([]byte(group.Admin)) | []byte(group.Admin) | BigEndian(GroupId) -> []byte()`. + +### Group Member Table + +The `groupMemberTable` stores `GroupMember`s: `0x10 | BigEndian(GroupId) | []byte(member.Address) -> ProtocolBuffer(GroupMember)`. + +The `groupMemberTable` is a primary key table and its `PrimaryKey` is given by +`BigEndian(GroupId) | []byte(member.Address)` which is used by the following indexes. + +#### groupMemberByGroupIndex + +`groupMemberByGroupIndex` allows to retrieve group members by group id: +`0x11 | BigEndian(GroupId) | PrimaryKey -> []byte()`. + +#### groupMemberByMemberIndex + +`groupMemberByMemberIndex` allows to retrieve group members by member address: +`0x12 | len([]byte(member.Address)) | []byte(member.Address) | PrimaryKey -> []byte()`. + +### Group Policy Table + +The `groupPolicyTable` stores `GroupPolicyInfo`: `0x20 | len([]byte(Address)) | []byte(Address) -> ProtocolBuffer(GroupPolicyInfo)`. + +The `groupPolicyTable` is a primary key table and its `PrimaryKey` is given by +`len([]byte(Address)) | []byte(Address)` which is used by the following indexes. + +#### groupPolicySeq + +The value of `groupPolicySeq` is incremented when creating a new group policy and is used to generate the new group policy account `Address`: +`0x21 | 0x1 -> BigEndian`. + +The second `0x1` corresponds to the ORM `sequenceStorageKey`. + +#### groupPolicyByGroupIndex + +`groupPolicyByGroupIndex` allows to retrieve group policies by group id: +`0x22 | BigEndian(GroupId) | PrimaryKey -> []byte()`. + +#### groupPolicyByAdminIndex + +`groupPolicyByAdminIndex` allows to retrieve group policies by admin address: +`0x23 | len([]byte(Address)) | []byte(Address) | PrimaryKey -> []byte()`. + +### Proposal Table + +The `proposalTable` stores `Proposal`s: `0x30 | BigEndian(ProposalId) -> ProtocolBuffer(Proposal)`. + +#### proposalSeq + +The value of `proposalSeq` is incremented when creating a new proposal and corresponds to the new `ProposalId`: `0x31 | 0x1 -> BigEndian`. + +The second `0x1` corresponds to the ORM `sequenceStorageKey`. + +#### proposalByGroupPolicyIndex + +`proposalByGroupPolicyIndex` allows to retrieve proposals by group policy account address: +`0x32 | len([]byte(account.Address)) | []byte(account.Address) | BigEndian(ProposalId) -> []byte()`. + +#### ProposalsByVotingPeriodEndIndex + +`proposalsByVotingPeriodEndIndex` allows to retrieve proposals sorted by chronological `voting_period_end`: +`0x33 | sdk.FormatTimeBytes(proposal.VotingPeriodEnd) | BigEndian(ProposalId) -> []byte()`. + +This index is used when tallying the proposal votes at the end of the voting period, and for pruning proposals at `VotingPeriodEnd + MaxExecutionPeriod`. + +### Vote Table + +The `voteTable` stores `Vote`s: `0x40 | BigEndian(ProposalId) | []byte(voter.Address) -> ProtocolBuffer(Vote)`. + +The `voteTable` is a primary key table and its `PrimaryKey` is given by +`BigEndian(ProposalId) | []byte(voter.Address)` which is used by the following indexes. + +#### voteByProposalIndex + +`voteByProposalIndex` allows to retrieve votes by proposal id: +`0x41 | BigEndian(ProposalId) | PrimaryKey -> []byte()`. + +#### voteByVoterIndex + +`voteByVoterIndex` allows to retrieve votes by voter address: +`0x42 | len([]byte(voter.Address)) | []byte(voter.Address) | PrimaryKey -> []byte()`. + +## Msg Service + +### Msg/CreateGroup + +A new group can be created with the `MsgCreateGroup`, which has an admin address, a list of members and some optional metadata. + +The metadata has a maximum length that is chosen by the app developer, and +passed into the group keeper as a config. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L67-L80 +``` + +It's expected to fail if + +* metadata length is greater than `MaxMetadataLen` config +* members are not correctly set (e.g. wrong address format, duplicates, or with 0 weight). + +### Msg/UpdateGroupMembers + +Group members can be updated with the `UpdateGroupMembers`. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L88-L102 +``` + +In the list of `MemberUpdates`, an existing member can be removed by setting its weight to 0. + +It's expected to fail if: + +* the signer is not the admin of the group. +* for any one of the associated group policies, if its decision policy's `Validate()` method fails against the updated group. + +### Msg/UpdateGroupAdmin + +The `UpdateGroupAdmin` can be used to update a group admin. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L107-L120 +``` + +It's expected to fail if the signer is not the admin of the group. + +### Msg/UpdateGroupMetadata + +The `UpdateGroupMetadata` can be used to update a group metadata. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L125-L138 +``` + +It's expected to fail if: + +* new metadata length is greater than `MaxMetadataLen` config. +* the signer is not the admin of the group. + +### Msg/CreateGroupPolicy + +A new group policy can be created with the `MsgCreateGroupPolicy`, which has an admin address, a group id, a decision policy and some optional metadata. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L147-L165 +``` + +It's expected to fail if: + +* the signer is not the admin of the group. +* metadata length is greater than `MaxMetadataLen` config. +* the decision policy's `Validate()` method doesn't pass against the group. + +### Msg/CreateGroupWithPolicy + +A new group with policy can be created with the `MsgCreateGroupWithPolicy`, which has an admin address, a list of members, a decision policy, a `group_policy_as_admin` field to optionally set group and group policy admin with group policy address and some optional metadata for group and group policy. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L191-L215 +``` + +It's expected to fail for the same reasons as `Msg/CreateGroup` and `Msg/CreateGroupPolicy`. + +### Msg/UpdateGroupPolicyAdmin + +The `UpdateGroupPolicyAdmin` can be used to update a group policy admin. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L173-L186 +``` + +It's expected to fail if the signer is not the admin of the group policy. + +### Msg/UpdateGroupPolicyDecisionPolicy + +The `UpdateGroupPolicyDecisionPolicy` can be used to update a decision policy. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L226-L241 +``` + +It's expected to fail if: + +* the signer is not the admin of the group policy. +* the new decision policy's `Validate()` method doesn't pass against the group. + +### Msg/UpdateGroupPolicyMetadata + +The `UpdateGroupPolicyMetadata` can be used to update a group policy metadata. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L246-L259 +``` + +It's expected to fail if: + +* new metadata length is greater than `MaxMetadataLen` config. +* the signer is not the admin of the group. + +### Msg/SubmitProposal + +A new proposal can be created with the `MsgSubmitProposal`, which has a group policy account address, a list of proposers addresses, a list of messages to execute if the proposal is accepted and some optional metadata. +An optional `Exec` value can be provided to try to execute the proposal immediately after proposal creation. Proposers signatures are considered as yes votes in this case. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L281-L315 +``` + +It's expected to fail if: + +* metadata, title, or summary length is greater than `MaxMetadataLen` config. +* if any of the proposers is not a group member. + +### Msg/WithdrawProposal + +A proposal can be withdrawn using `MsgWithdrawProposal` which has an `address` (can be either a proposer or the group policy admin) and a `proposal_id` (which has to be withdrawn). + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L323-L333 +``` + +It's expected to fail if: + +* the signer is neither the group policy admin nor proposer of the proposal. +* the proposal is already closed or aborted. + +### Msg/Vote + +A new vote can be created with the `MsgVote`, given a proposal id, a voter address, a choice (yes, no, veto or abstain) and some optional metadata. +An optional `Exec` value can be provided to try to execute the proposal immediately after voting. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L338-L358 +``` + +It's expected to fail if: + +* metadata length is greater than `MaxMetadataLen` config. +* the proposal is not in voting period anymore. + +### Msg/Exec + +A proposal can be executed with the `MsgExec`. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L363-L373 +``` + +The messages that are part of this proposal won't be executed if: + +* the proposal has not been accepted by the group policy. +* the proposal has already been successfully executed. + +### Msg/LeaveGroup + +The `MsgLeaveGroup` allows group member to leave a group. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/group/v1/tx.proto#L381-L391 +``` + +It's expected to fail if: + +* the group member is not part of the group. +* for any one of the associated group policies, if its decision policy's `Validate()` method fails against the updated group. + +## Events + +The group module emits the following events: + +### EventCreateGroup + +| Type | Attribute Key | Attribute Value | +| -------------------------------- | ------------- | -------------------------------- | +| message | action | /cosmos.group.v1.Msg/CreateGroup | +| cosmos.group.v1.EventCreateGroup | group_id | {groupId} | + +### EventUpdateGroup + +| Type | Attribute Key | Attribute Value | +| -------------------------------- | ------------- | ---------------------------------------------------------- | +| message | action | /cosmos.group.v1.Msg/UpdateGroup{Admin\|Metadata\|Members} | +| cosmos.group.v1.EventUpdateGroup | group_id | {groupId} | + +### EventCreateGroupPolicy + +| Type | Attribute Key | Attribute Value | +| -------------------------------------- | ------------- | -------------------------------------- | +| message | action | /cosmos.group.v1.Msg/CreateGroupPolicy | +| cosmos.group.v1.EventCreateGroupPolicy | address | {groupPolicyAddress} | + +### EventUpdateGroupPolicy + +| Type | Attribute Key | Attribute Value | +| -------------------------------------- | ------------- | ----------------------------------------------------------------------- | +| message | action | /cosmos.group.v1.Msg/UpdateGroupPolicy{Admin\|Metadata\|DecisionPolicy} | +| cosmos.group.v1.EventUpdateGroupPolicy | address | {groupPolicyAddress} | + +### EventCreateProposal + +| Type | Attribute Key | Attribute Value | +| ----------------------------------- | ------------- | ----------------------------------- | +| message | action | /cosmos.group.v1.Msg/CreateProposal | +| cosmos.group.v1.EventCreateProposal | proposal_id | {proposalId} | + +### EventWithdrawProposal + +| Type | Attribute Key | Attribute Value | +| ------------------------------------- | ------------- | ------------------------------------- | +| message | action | /cosmos.group.v1.Msg/WithdrawProposal | +| cosmos.group.v1.EventWithdrawProposal | proposal_id | {proposalId} | + +### EventVote + +| Type | Attribute Key | Attribute Value | +| ------------------------- | ------------- | ------------------------- | +| message | action | /cosmos.group.v1.Msg/Vote | +| cosmos.group.v1.EventVote | proposal_id | {proposalId} | + +## EventExec + +| Type | Attribute Key | Attribute Value | +| ------------------------- | ------------- | ------------------------- | +| message | action | /cosmos.group.v1.Msg/Exec | +| cosmos.group.v1.EventExec | proposal_id | {proposalId} | +| cosmos.group.v1.EventExec | logs | {logs_string} | + +### EventLeaveGroup + +| Type | Attribute Key | Attribute Value | +| ------------------------------- | ------------- | ------------------------------- | +| message | action | /cosmos.group.v1.Msg/LeaveGroup | +| cosmos.group.v1.EventLeaveGroup | proposal_id | {proposalId} | +| cosmos.group.v1.EventLeaveGroup | address | {address} | + +### EventProposalPruned + +| Type | Attribute Key | Attribute Value | +|-------------------------------------|---------------|---------------------------------| +| message | action | /cosmos.group.v1.Msg/LeaveGroup | +| cosmos.group.v1.EventProposalPruned | proposal_id | {proposalId} | +| cosmos.group.v1.EventProposalPruned | status | {ProposalStatus} | +| cosmos.group.v1.EventProposalPruned | tally_result | {TallyResult} | + + +## Client + +### CLI + +A user can query and interact with the `group` module using the CLI. + +#### Query + +The `query` commands allow users to query `group` state. + +```bash +simd query group --help +``` + +##### group-info + +The `group-info` command allows users to query for group info by given group id. + +```bash +simd query group group-info [id] [flags] +``` + +Example: + +```bash +simd query group group-info 1 +``` + +Example Output: + +```bash +admin: cosmos1.. +group_id: "1" +metadata: AQ== +total_weight: "3" +version: "1" +``` + +##### group-policy-info + +The `group-policy-info` command allows users to query for group policy info by account address of group policy . + +```bash +simd query group group-policy-info [group-policy-account] [flags] +``` + +Example: + +```bash +simd query group group-policy-info cosmos1.. +``` + +Example Output: + +```bash +address: cosmos1.. +admin: cosmos1.. +decision_policy: + '@type': /cosmos.group.v1.ThresholdDecisionPolicy + threshold: "1" + windows: + min_execution_period: 0s + voting_period: 432000s +group_id: "1" +metadata: AQ== +version: "1" +``` + +##### group-members + +The `group-members` command allows users to query for group members by group id with pagination flags. + +```bash +simd query group group-members [id] [flags] +``` + +Example: + +```bash +simd query group group-members 1 +``` + +Example Output: + +```bash +members: +- group_id: "1" + member: + address: cosmos1.. + metadata: AQ== + weight: "2" +- group_id: "1" + member: + address: cosmos1.. + metadata: AQ== + weight: "1" +pagination: + next_key: null + total: "2" +``` + +##### groups-by-admin + +The `groups-by-admin` command allows users to query for groups by admin account address with pagination flags. + +```bash +simd query group groups-by-admin [admin] [flags] +``` + +Example: + +```bash +simd query group groups-by-admin cosmos1.. +``` + +Example Output: + +```bash +groups: +- admin: cosmos1.. + group_id: "1" + metadata: AQ== + total_weight: "3" + version: "1" +- admin: cosmos1.. + group_id: "2" + metadata: AQ== + total_weight: "3" + version: "1" +pagination: + next_key: null + total: "2" +``` + +##### group-policies-by-group + +The `group-policies-by-group` command allows users to query for group policies by group id with pagination flags. + +```bash +simd query group group-policies-by-group [group-id] [flags] +``` + +Example: + +```bash +simd query group group-policies-by-group 1 +``` + +Example Output: + +```bash +group_policies: +- address: cosmos1.. + admin: cosmos1.. + decision_policy: + '@type': /cosmos.group.v1.ThresholdDecisionPolicy + threshold: "1" + windows: + min_execution_period: 0s + voting_period: 432000s + group_id: "1" + metadata: AQ== + version: "1" +- address: cosmos1.. + admin: cosmos1.. + decision_policy: + '@type': /cosmos.group.v1.ThresholdDecisionPolicy + threshold: "1" + windows: + min_execution_period: 0s + voting_period: 432000s + group_id: "1" + metadata: AQ== + version: "1" +pagination: + next_key: null + total: "2" +``` + +##### group-policies-by-admin + +The `group-policies-by-admin` command allows users to query for group policies by admin account address with pagination flags. + +```bash +simd query group group-policies-by-admin [admin] [flags] +``` + +Example: + +```bash +simd query group group-policies-by-admin cosmos1.. +``` + +Example Output: + +```bash +group_policies: +- address: cosmos1.. + admin: cosmos1.. + decision_policy: + '@type': /cosmos.group.v1.ThresholdDecisionPolicy + threshold: "1" + windows: + min_execution_period: 0s + voting_period: 432000s + group_id: "1" + metadata: AQ== + version: "1" +- address: cosmos1.. + admin: cosmos1.. + decision_policy: + '@type': /cosmos.group.v1.ThresholdDecisionPolicy + threshold: "1" + windows: + min_execution_period: 0s + voting_period: 432000s + group_id: "1" + metadata: AQ== + version: "1" +pagination: + next_key: null + total: "2" +``` + +##### proposal + +The `proposal` command allows users to query for proposal by id. + +```bash +simd query group proposal [id] [flags] +``` + +Example: + +```bash +simd query group proposal 1 +``` + +Example Output: + +```bash +proposal: + address: cosmos1.. + executor_result: EXECUTOR_RESULT_NOT_RUN + group_policy_version: "1" + group_version: "1" + metadata: AQ== + msgs: + - '@type': /cosmos.bank.v1beta1.MsgSend + amount: + - amount: "100000000" + denom: stake + from_address: cosmos1.. + to_address: cosmos1.. + proposal_id: "1" + proposers: + - cosmos1.. + result: RESULT_UNFINALIZED + status: STATUS_SUBMITTED + submitted_at: "2021-12-17T07:06:26.310638964Z" + windows: + min_execution_period: 0s + voting_period: 432000s + vote_state: + abstain_count: "0" + no_count: "0" + veto_count: "0" + yes_count: "0" + summary: "Summary" + title: "Title" +``` + +##### proposals-by-group-policy + +The `proposals-by-group-policy` command allows users to query for proposals by account address of group policy with pagination flags. + +```bash +simd query group proposals-by-group-policy [group-policy-account] [flags] +``` + +Example: + +```bash +simd query group proposals-by-group-policy cosmos1.. +``` + +Example Output: + +```bash +pagination: + next_key: null + total: "1" +proposals: +- address: cosmos1.. + executor_result: EXECUTOR_RESULT_NOT_RUN + group_policy_version: "1" + group_version: "1" + metadata: AQ== + msgs: + - '@type': /cosmos.bank.v1beta1.MsgSend + amount: + - amount: "100000000" + denom: stake + from_address: cosmos1.. + to_address: cosmos1.. + proposal_id: "1" + proposers: + - cosmos1.. + result: RESULT_UNFINALIZED + status: STATUS_SUBMITTED + submitted_at: "2021-12-17T07:06:26.310638964Z" + windows: + min_execution_period: 0s + voting_period: 432000s + vote_state: + abstain_count: "0" + no_count: "0" + veto_count: "0" + yes_count: "0" + summary: "Summary" + title: "Title" +``` + +##### vote + +The `vote` command allows users to query for vote by proposal id and voter account address. + +```bash +simd query group vote [proposal-id] [voter] [flags] +``` + +Example: + +```bash +simd query group vote 1 cosmos1.. +``` + +Example Output: + +```bash +vote: + choice: CHOICE_YES + metadata: AQ== + proposal_id: "1" + submitted_at: "2021-12-17T08:05:02.490164009Z" + voter: cosmos1.. +``` + +##### votes-by-proposal + +The `votes-by-proposal` command allows users to query for votes by proposal id with pagination flags. + +```bash +simd query group votes-by-proposal [proposal-id] [flags] +``` + +Example: + +```bash +simd query group votes-by-proposal 1 +``` + +Example Output: + +```bash +pagination: + next_key: null + total: "1" +votes: +- choice: CHOICE_YES + metadata: AQ== + proposal_id: "1" + submitted_at: "2021-12-17T08:05:02.490164009Z" + voter: cosmos1.. +``` + +##### votes-by-voter + +The `votes-by-voter` command allows users to query for votes by voter account address with pagination flags. + +```bash +simd query group votes-by-voter [voter] [flags] +``` + +Example: + +```bash +simd query group votes-by-voter cosmos1.. +``` + +Example Output: + +```bash +pagination: + next_key: null + total: "1" +votes: +- choice: CHOICE_YES + metadata: AQ== + proposal_id: "1" + submitted_at: "2021-12-17T08:05:02.490164009Z" + voter: cosmos1.. +``` + +### Transactions + +The `tx` commands allow users to interact with the `group` module. + +```bash +simd tx group --help +``` + +#### create-group + +The `create-group` command allows users to create a group which is an aggregation of member accounts with associated weights and +an administrator account. + +```bash +simd tx group create-group [admin] [metadata] [members-json-file] +``` + +Example: + +```bash +simd tx group create-group cosmos1.. "AQ==" members.json +``` + +#### update-group-admin + +The `update-group-admin` command allows users to update a group's admin. + +```bash +simd tx group update-group-admin [admin] [group-id] [new-admin] [flags] +``` + +Example: + +```bash +simd tx group update-group-admin cosmos1.. 1 cosmos1.. +``` + +#### update-group-members + +The `update-group-members` command allows users to update a group's members. + +```bash +simd tx group update-group-members [admin] [group-id] [members-json-file] [flags] +``` + +Example: + +```bash +simd tx group update-group-members cosmos1.. 1 members.json +``` + +#### update-group-metadata + +The `update-group-metadata` command allows users to update a group's metadata. + +```bash +simd tx group update-group-metadata [admin] [group-id] [metadata] [flags] +``` + +Example: + +```bash +simd tx group update-group-metadata cosmos1.. 1 "AQ==" +``` + +#### create-group-policy + +The `create-group-policy` command allows users to create a group policy which is an account associated with a group and a decision policy. + +```bash +simd tx group create-group-policy [admin] [group-id] [metadata] [decision-policy] [flags] +``` + +Example: + +```bash +simd tx group create-group-policy cosmos1.. 1 "AQ==" '{"@type":"/cosmos.group.v1.ThresholdDecisionPolicy", "threshold":"1", "windows": {"voting_period": "120h", "min_execution_period": "0s"}}' +``` + +#### create-group-with-policy + +The `create-group-with-policy` command allows users to create a group which is an aggregation of member accounts with associated weights and an administrator account with decision policy. If the `--group-policy-as-admin` flag is set to `true`, the group policy address becomes the group and group policy admin. + +```bash +simd tx group create-group-with-policy [admin] [group-metadata] [group-policy-metadata] [members-json-file] [decision-policy] [flags] +``` + +Example: + +```bash +simd tx group create-group-with-policy cosmos1.. "AQ==" "AQ==" members.json '{"@type":"/cosmos.group.v1.ThresholdDecisionPolicy", "threshold":"1", "windows": {"voting_period": "120h", "min_execution_period": "0s"}}' +``` + +#### update-group-policy-admin + +The `update-group-policy-admin` command allows users to update a group policy admin. + +```bash +simd tx group update-group-policy-admin [admin] [group-policy-account] [new-admin] [flags] +``` + +Example: + +```bash +simd tx group update-group-policy-admin cosmos1.. cosmos1.. cosmos1.. +``` + +#### update-group-policy-metadata + +The `update-group-policy-metadata` command allows users to update a group policy metadata. + +```bash +simd tx group update-group-policy-metadata [admin] [group-policy-account] [new-metadata] [flags] +``` + +Example: + +```bash +simd tx group update-group-policy-metadata cosmos1.. cosmos1.. "AQ==" +``` + +#### update-group-policy-decision-policy + +The `update-group-policy-decision-policy` command allows users to update a group policy's decision policy. + +```bash +simd tx group update-group-policy-decision-policy [admin] [group-policy-account] [decision-policy] [flags] +``` + +Example: + +```bash +simd tx group update-group-policy-decision-policy cosmos1.. cosmos1.. '{"@type":"/cosmos.group.v1.ThresholdDecisionPolicy", "threshold":"2", "windows": {"voting_period": "120h", "min_execution_period": "0s"}}' +``` + +#### submit-proposal + +The `submit-proposal` command allows users to submit a new proposal. + +```bash +simd tx group submit-proposal [group-policy-account] [proposer[,proposer]*] [msg_tx_json_file] [metadata] [flags] +``` + +Example: + +```bash +simd tx group submit-proposal cosmos1.. cosmos1.. msg_tx.json "AQ==" +``` + +#### withdraw-proposal + +The `withdraw-proposal` command allows users to withdraw a proposal. + +```bash +simd tx group withdraw-proposal [proposal-id] [group-policy-admin-or-proposer] +``` + +Example: + +```bash +simd tx group withdraw-proposal 1 cosmos1.. +``` + +#### vote + +The `vote` command allows users to vote on a proposal. + +```bash +simd tx group vote proposal-id] [voter] [choice] [metadata] [flags] +``` + +Example: + +```bash +simd tx group vote 1 cosmos1.. CHOICE_YES "AQ==" +``` + +#### exec + +The `exec` command allows users to execute a proposal. + +```bash +simd tx group exec [proposal-id] [flags] +``` + +Example: + +```bash +simd tx group exec 1 +``` + +#### leave-group + +The `leave-group` command allows group member to leave the group. + +```bash +simd tx group leave-group [member-address] [group-id] +``` + +Example: + +```bash +simd tx group leave-group cosmos1... 1 +``` + +### gRPC + +A user can query the `group` module using gRPC endpoints. + +#### GroupInfo + +The `GroupInfo` endpoint allows users to query for group info by given group id. + +```bash +cosmos.group.v1.Query/GroupInfo +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"group_id":1}' localhost:9090 cosmos.group.v1.Query/GroupInfo +``` + +Example Output: + +```bash +{ + "info": { + "groupId": "1", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "totalWeight": "3" + } +} +``` + +#### GroupPolicyInfo + +The `GroupPolicyInfo` endpoint allows users to query for group policy info by account address of group policy. + +```bash +cosmos.group.v1.Query/GroupPolicyInfo +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"address":"cosmos1.."}' localhost:9090 cosmos.group.v1.Query/GroupPolicyInfo +``` + +Example Output: + +```bash +{ + "info": { + "address": "cosmos1..", + "groupId": "1", + "admin": "cosmos1..", + "version": "1", + "decisionPolicy": {"@type":"/cosmos.group.v1.ThresholdDecisionPolicy","threshold":"1","windows": {"voting_period": "120h", "min_execution_period": "0s"}}, + } +} +``` + +#### GroupMembers + +The `GroupMembers` endpoint allows users to query for group members by group id with pagination flags. + +```bash +cosmos.group.v1.Query/GroupMembers +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"group_id":"1"}' localhost:9090 cosmos.group.v1.Query/GroupMembers +``` + +Example Output: + +```bash +{ + "members": [ + { + "groupId": "1", + "member": { + "address": "cosmos1..", + "weight": "1" + } + }, + { + "groupId": "1", + "member": { + "address": "cosmos1..", + "weight": "2" + } + } + ], + "pagination": { + "total": "2" + } +} +``` + +#### GroupsByAdmin + +The `GroupsByAdmin` endpoint allows users to query for groups by admin account address with pagination flags. + +```bash +cosmos.group.v1.Query/GroupsByAdmin +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"admin":"cosmos1.."}' localhost:9090 cosmos.group.v1.Query/GroupsByAdmin +``` + +Example Output: + +```bash +{ + "groups": [ + { + "groupId": "1", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "totalWeight": "3" + }, + { + "groupId": "2", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "totalWeight": "3" + } + ], + "pagination": { + "total": "2" + } +} +``` + +#### GroupPoliciesByGroup + +The `GroupPoliciesByGroup` endpoint allows users to query for group policies by group id with pagination flags. + +```bash +cosmos.group.v1.Query/GroupPoliciesByGroup +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"group_id":"1"}' localhost:9090 cosmos.group.v1.Query/GroupPoliciesByGroup +``` + +Example Output: + +```bash +{ + "GroupPolicies": [ + { + "address": "cosmos1..", + "groupId": "1", + "admin": "cosmos1..", + "version": "1", + "decisionPolicy": {"@type":"/cosmos.group.v1.ThresholdDecisionPolicy","threshold":"1","windows":{"voting_period": "120h", "min_execution_period": "0s"}}, + }, + { + "address": "cosmos1..", + "groupId": "1", + "admin": "cosmos1..", + "version": "1", + "decisionPolicy": {"@type":"/cosmos.group.v1.ThresholdDecisionPolicy","threshold":"1","windows":{"voting_period": "120h", "min_execution_period": "0s"}}, + } + ], + "pagination": { + "total": "2" + } +} +``` + +#### GroupPoliciesByAdmin + +The `GroupPoliciesByAdmin` endpoint allows users to query for group policies by admin account address with pagination flags. + +```bash +cosmos.group.v1.Query/GroupPoliciesByAdmin +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"admin":"cosmos1.."}' localhost:9090 cosmos.group.v1.Query/GroupPoliciesByAdmin +``` + +Example Output: + +```bash +{ + "GroupPolicies": [ + { + "address": "cosmos1..", + "groupId": "1", + "admin": "cosmos1..", + "version": "1", + "decisionPolicy": {"@type":"/cosmos.group.v1.ThresholdDecisionPolicy","threshold":"1","windows":{"voting_period": "120h", "min_execution_period": "0s"}}, + }, + { + "address": "cosmos1..", + "groupId": "1", + "admin": "cosmos1..", + "version": "1", + "decisionPolicy": {"@type":"/cosmos.group.v1.ThresholdDecisionPolicy","threshold":"1","windows":{"voting_period": "120h", "min_execution_period": "0s"}}, + } + ], + "pagination": { + "total": "2" + } +} +``` + +#### Proposal + +The `Proposal` endpoint allows users to query for proposal by id. + +```bash +cosmos.group.v1.Query/Proposal +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' localhost:9090 cosmos.group.v1.Query/Proposal +``` + +Example Output: + +```bash +{ + "proposal": { + "proposalId": "1", + "address": "cosmos1..", + "proposers": [ + "cosmos1.." + ], + "submittedAt": "2021-12-17T07:06:26.310638964Z", + "groupVersion": "1", + "GroupPolicyVersion": "1", + "status": "STATUS_SUBMITTED", + "result": "RESULT_UNFINALIZED", + "voteState": { + "yesCount": "0", + "noCount": "0", + "abstainCount": "0", + "vetoCount": "0" + }, + "windows": { + "min_execution_period": "0s", + "voting_period": "432000s" + }, + "executorResult": "EXECUTOR_RESULT_NOT_RUN", + "messages": [ + {"@type":"/cosmos.bank.v1beta1.MsgSend","amount":[{"denom":"stake","amount":"100000000"}],"fromAddress":"cosmos1..","toAddress":"cosmos1.."} + ], + "title": "Title", + "summary": "Summary", + } +} +``` + +#### ProposalsByGroupPolicy + +The `ProposalsByGroupPolicy` endpoint allows users to query for proposals by account address of group policy with pagination flags. + +```bash +cosmos.group.v1.Query/ProposalsByGroupPolicy +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"address":"cosmos1.."}' localhost:9090 cosmos.group.v1.Query/ProposalsByGroupPolicy +``` + +Example Output: + +```bash +{ + "proposals": [ + { + "proposalId": "1", + "address": "cosmos1..", + "proposers": [ + "cosmos1.." + ], + "submittedAt": "2021-12-17T08:03:27.099649352Z", + "groupVersion": "1", + "GroupPolicyVersion": "1", + "status": "STATUS_CLOSED", + "result": "RESULT_ACCEPTED", + "voteState": { + "yesCount": "1", + "noCount": "0", + "abstainCount": "0", + "vetoCount": "0" + }, + "windows": { + "min_execution_period": "0s", + "voting_period": "432000s" + }, + "executorResult": "EXECUTOR_RESULT_NOT_RUN", + "messages": [ + {"@type":"/cosmos.bank.v1beta1.MsgSend","amount":[{"denom":"stake","amount":"100000000"}],"fromAddress":"cosmos1..","toAddress":"cosmos1.."} + ], + "title": "Title", + "summary": "Summary", + } + ], + "pagination": { + "total": "1" + } +} +``` + +#### VoteByProposalVoter + +The `VoteByProposalVoter` endpoint allows users to query for vote by proposal id and voter account address. + +```bash +cosmos.group.v1.Query/VoteByProposalVoter +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1","voter":"cosmos1.."}' localhost:9090 cosmos.group.v1.Query/VoteByProposalVoter +``` + +Example Output: + +```bash +{ + "vote": { + "proposalId": "1", + "voter": "cosmos1..", + "choice": "CHOICE_YES", + "submittedAt": "2021-12-17T08:05:02.490164009Z" + } +} +``` + +#### VotesByProposal + +The `VotesByProposal` endpoint allows users to query for votes by proposal id with pagination flags. + +```bash +cosmos.group.v1.Query/VotesByProposal +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"proposal_id":"1"}' localhost:9090 cosmos.group.v1.Query/VotesByProposal +``` + +Example Output: + +```bash +{ + "votes": [ + { + "proposalId": "1", + "voter": "cosmos1..", + "choice": "CHOICE_YES", + "submittedAt": "2021-12-17T08:05:02.490164009Z" + } + ], + "pagination": { + "total": "1" + } +} +``` + +#### VotesByVoter + +The `VotesByVoter` endpoint allows users to query for votes by voter account address with pagination flags. + +```bash +cosmos.group.v1.Query/VotesByVoter +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"voter":"cosmos1.."}' localhost:9090 cosmos.group.v1.Query/VotesByVoter +``` + +Example Output: + +```bash +{ + "votes": [ + { + "proposalId": "1", + "voter": "cosmos1..", + "choice": "CHOICE_YES", + "submittedAt": "2021-12-17T08:05:02.490164009Z" + } + ], + "pagination": { + "total": "1" + } +} +``` + +### REST + +A user can query the `group` module using REST endpoints. + +#### GroupInfo + +The `GroupInfo` endpoint allows users to query for group info by given group id. + +```bash +/cosmos/group/v1/group_info/{group_id} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/group_info/1 +``` + +Example Output: + +```bash +{ + "info": { + "id": "1", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "total_weight": "3" + } +} +``` + +#### GroupPolicyInfo + +The `GroupPolicyInfo` endpoint allows users to query for group policy info by account address of group policy. + +```bash +/cosmos/group/v1/group_policy_info/{address} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/group_policy_info/cosmos1.. +``` + +Example Output: + +```bash +{ + "info": { + "address": "cosmos1..", + "group_id": "1", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "decision_policy": { + "@type": "/cosmos.group.v1.ThresholdDecisionPolicy", + "threshold": "1", + "windows": { + "voting_period": "120h", + "min_execution_period": "0s" + } + }, + } +} +``` + +#### GroupMembers + +The `GroupMembers` endpoint allows users to query for group members by group id with pagination flags. + +```bash +/cosmos/group/v1/group_members/{group_id} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/group_members/1 +``` + +Example Output: + +```bash +{ + "members": [ + { + "group_id": "1", + "member": { + "address": "cosmos1..", + "weight": "1", + "metadata": "AQ==" + } + }, + { + "group_id": "1", + "member": { + "address": "cosmos1..", + "weight": "2", + "metadata": "AQ==" + } + ], + "pagination": { + "next_key": null, + "total": "2" + } +} +``` + +#### GroupsByAdmin + +The `GroupsByAdmin` endpoint allows users to query for groups by admin account address with pagination flags. + +```bash +/cosmos/group/v1/groups_by_admin/{admin} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/groups_by_admin/cosmos1.. +``` + +Example Output: + +```bash +{ + "groups": [ + { + "id": "1", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "total_weight": "3" + }, + { + "id": "2", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "total_weight": "3" + } + ], + "pagination": { + "next_key": null, + "total": "2" + } +} +``` + +#### GroupPoliciesByGroup + +The `GroupPoliciesByGroup` endpoint allows users to query for group policies by group id with pagination flags. + +```bash +/cosmos/group/v1/group_policies_by_group/{group_id} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/group_policies_by_group/1 +``` + +Example Output: + +```bash +{ + "group_policies": [ + { + "address": "cosmos1..", + "group_id": "1", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "decision_policy": { + "@type": "/cosmos.group.v1.ThresholdDecisionPolicy", + "threshold": "1", + "windows": { + "voting_period": "120h", + "min_execution_period": "0s" + } + }, + }, + { + "address": "cosmos1..", + "group_id": "1", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "decision_policy": { + "@type": "/cosmos.group.v1.ThresholdDecisionPolicy", + "threshold": "1", + "windows": { + "voting_period": "120h", + "min_execution_period": "0s" + } + }, + } + ], + "pagination": { + "next_key": null, + "total": "2" + } +} +``` + +#### GroupPoliciesByAdmin + +The `GroupPoliciesByAdmin` endpoint allows users to query for group policies by admin account address with pagination flags. + +```bash +/cosmos/group/v1/group_policies_by_admin/{admin} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/group_policies_by_admin/cosmos1.. +``` + +Example Output: + +```bash +{ + "group_policies": [ + { + "address": "cosmos1..", + "group_id": "1", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "decision_policy": { + "@type": "/cosmos.group.v1.ThresholdDecisionPolicy", + "threshold": "1", + "windows": { + "voting_period": "120h", + "min_execution_period": "0s" + } + }, + }, + { + "address": "cosmos1..", + "group_id": "1", + "admin": "cosmos1..", + "metadata": "AQ==", + "version": "1", + "decision_policy": { + "@type": "/cosmos.group.v1.ThresholdDecisionPolicy", + "threshold": "1", + "windows": { + "voting_period": "120h", + "min_execution_period": "0s" + } + }, + } + ], + "pagination": { + "next_key": null, + "total": "2" + } +``` + +#### Proposal + +The `Proposal` endpoint allows users to query for proposal by id. + +```bash +/cosmos/group/v1/proposal/{proposal_id} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/proposal/1 +``` + +Example Output: + +```bash +{ + "proposal": { + "proposal_id": "1", + "address": "cosmos1..", + "metadata": "AQ==", + "proposers": [ + "cosmos1.." + ], + "submitted_at": "2021-12-17T07:06:26.310638964Z", + "group_version": "1", + "group_policy_version": "1", + "status": "STATUS_SUBMITTED", + "result": "RESULT_UNFINALIZED", + "vote_state": { + "yes_count": "0", + "no_count": "0", + "abstain_count": "0", + "veto_count": "0" + }, + "windows": { + "min_execution_period": "0s", + "voting_period": "432000s" + }, + "executor_result": "EXECUTOR_RESULT_NOT_RUN", + "messages": [ + { + "@type": "/cosmos.bank.v1beta1.MsgSend", + "from_address": "cosmos1..", + "to_address": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "100000000" + } + ] + } + ], + "title": "Title", + "summary": "Summary", + } +} +``` + +#### ProposalsByGroupPolicy + +The `ProposalsByGroupPolicy` endpoint allows users to query for proposals by account address of group policy with pagination flags. + +```bash +/cosmos/group/v1/proposals_by_group_policy/{address} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/proposals_by_group_policy/cosmos1.. +``` + +Example Output: + +```bash +{ + "proposals": [ + { + "id": "1", + "group_policy_address": "cosmos1..", + "metadata": "AQ==", + "proposers": [ + "cosmos1.." + ], + "submit_time": "2021-12-17T08:03:27.099649352Z", + "group_version": "1", + "group_policy_version": "1", + "status": "STATUS_CLOSED", + "result": "RESULT_ACCEPTED", + "vote_state": { + "yes_count": "1", + "no_count": "0", + "abstain_count": "0", + "veto_count": "0" + }, + "windows": { + "min_execution_period": "0s", + "voting_period": "432000s" + }, + "executor_result": "EXECUTOR_RESULT_NOT_RUN", + "messages": [ + { + "@type": "/cosmos.bank.v1beta1.MsgSend", + "from_address": "cosmos1..", + "to_address": "cosmos1..", + "amount": [ + { + "denom": "stake", + "amount": "100000000" + } + ] + } + ] + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +#### VoteByProposalVoter + +The `VoteByProposalVoter` endpoint allows users to query for vote by proposal id and voter account address. + +```bash +/cosmos/group/v1/vote_by_proposal_voter/{proposal_id}/{voter} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1beta1/vote_by_proposal_voter/1/cosmos1.. +``` + +Example Output: + +```bash +{ + "vote": { + "proposal_id": "1", + "voter": "cosmos1..", + "choice": "CHOICE_YES", + "metadata": "AQ==", + "submitted_at": "2021-12-17T08:05:02.490164009Z" + } +} +``` + +#### VotesByProposal + +The `VotesByProposal` endpoint allows users to query for votes by proposal id with pagination flags. + +```bash +/cosmos/group/v1/votes_by_proposal/{proposal_id} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/votes_by_proposal/1 +``` + +Example Output: + +```bash +{ + "votes": [ + { + "proposal_id": "1", + "voter": "cosmos1..", + "option": "CHOICE_YES", + "metadata": "AQ==", + "submit_time": "2021-12-17T08:05:02.490164009Z" + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +#### VotesByVoter + +The `VotesByVoter` endpoint allows users to query for votes by voter account address with pagination flags. + +```bash +/cosmos/group/v1/votes_by_voter/{voter} +``` + +Example: + +```bash +curl localhost:1317/cosmos/group/v1/votes_by_voter/cosmos1.. +``` + +Example Output: + +```bash +{ + "votes": [ + { + "proposal_id": "1", + "voter": "cosmos1..", + "choice": "CHOICE_YES", + "metadata": "AQ==", + "submitted_at": "2021-12-17T08:05:02.490164009Z" + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +## Metadata + +The group module has four locations for metadata where users can provide further context about the on-chain actions they are taking. By default all metadata fields have a 255 character length field where metadata can be stored in json format, either on-chain or off-chain depending on the amount of data required. Here we provide a recommendation for the json structure and where the data should be stored. There are two important factors in making these recommendations. First, that the group and gov modules are consistent with one another, note the number of proposals made by all groups may be quite large. Second, that client applications such as block explorers and governance interfaces have confidence in the consistency of metadata structure across chains. + +### Proposal + +Location: off-chain as json object stored on IPFS (mirrors [gov proposal](../gov/README.md#metadata)) + +```json +{ + "title": "", + "authors": [""], + "summary": "", + "details": "", + "proposal_forum_url": "", + "vote_option_context": "", +} +``` + +:::note +The `authors` field is an array of strings, this is to allow for multiple authors to be listed in the metadata. +In v0.46, the `authors` field is a comma-separated string. Frontends are encouraged to support both formats for backwards compatibility. +::: + +### Vote + +Location: on-chain as json within 255 character limit (mirrors [gov vote](../gov/README.md#metadata)) + +```json +{ + "justification": "", +} +``` + +### Group + +Location: off-chain as json object stored on IPFS + +```json +{ + "name": "", + "description": "", + "group_website_url": "", + "group_forum_url": "", +} +``` + +### Decision policy + +Location: on-chain as json within 255 character limit + +```json +{ + "name": "", + "description": "", +} +``` diff --git a/.gitbook/developers/modules/core/mint/README.md b/.gitbook/developers/modules/core/mint/README.md new file mode 100644 index 00000000..80198010 --- /dev/null +++ b/.gitbook/developers/modules/core/mint/README.md @@ -0,0 +1,383 @@ +--- +sidebar_position: 1 +--- + +# `x/mint` + +## Contents + +* [State](#state) + * [Minter](#minter) + * [Params](#params) +* [Begin-Block](#begin-block) + * [NextInflationRate](#nextinflationrate) + * [NextAnnualProvisions](#nextannualprovisions) + * [BlockProvision](#blockprovision) +* [Parameters](#parameters) +* [Events](#events) + * [BeginBlocker](#beginblocker) +* [Client](#client) + * [CLI](#cli) + * [gRPC](#grpc) + * [REST](#rest) + +## Concepts + +### The Minting Mechanism + +The minting mechanism was designed to: + +* allow for a flexible inflation rate determined by market demand targeting a particular bonded-stake ratio +* effect a balance between market liquidity and staked supply + +In order to best determine the appropriate market rate for inflation rewards, a +moving change rate is used. The moving change rate mechanism ensures that if +the % bonded is either over or under the goal %-bonded, the inflation rate will +adjust to further incentivize or disincentivize being bonded, respectively. Setting the goal +%-bonded at less than 100% encourages the network to maintain some non-staked tokens +which should help provide some liquidity. + +It can be broken down in the following way: + +* If the actual percentage of bonded tokens is below the goal %-bonded the inflation rate will + increase until a maximum value is reached +* If the goal % bonded (67% in Cosmos-Hub) is maintained, then the inflation + rate will stay constant +* If the actual percentage of bonded tokens is above the goal %-bonded the inflation rate will + decrease until a minimum value is reached + + +## State + +### Minter + +The minter is a space for holding current inflation information. + +* Minter: `0x00 -> ProtocolBuffer(minter)` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/mint/v1beta1/mint.proto#L10-L24 +``` + +### Params + +The mint module stores its params in state with the prefix of `0x01`, +it can be updated with governance or the address with authority. + +* Params: `mint/params -> legacy_amino(params)` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/mint/v1beta1/mint.proto#L26-L59 +``` + +## Begin-Block + +Minting parameters are recalculated and inflation paid at the beginning of each block. + +### Inflation rate calculation + +Inflation rate is calculated using an "inflation calculation function" that's +passed to the `NewAppModule` function. If no function is passed, then the SDK's +default inflation function will be used (`NextInflationRate`). In case a custom +inflation calculation logic is needed, this can be achieved by defining and +passing a function that matches `InflationCalculationFn`'s signature. + +```go +type InflationCalculationFn func(ctx sdk.Context, minter Minter, params Params, bondedRatio math.LegacyDec) math.LegacyDec +``` + +#### NextInflationRate + +The target annual inflation rate is recalculated each block. +The inflation is also subject to a rate change (positive or negative) +depending on the distance from the desired ratio (67%). The maximum rate change +possible is defined to be 13% per year, however, the annual inflation is capped +as between 7% and 20%. + +```go +NextInflationRate(params Params, bondedRatio math.LegacyDec) (inflation math.LegacyDec) { + inflationRateChangePerYear = (1 - bondedRatio/params.GoalBonded) * params.InflationRateChange + inflationRateChange = inflationRateChangePerYear/blocksPerYr + + // increase the new annual inflation for this next block + inflation += inflationRateChange + if inflation > params.InflationMax { + inflation = params.InflationMax + } + if inflation < params.InflationMin { + inflation = params.InflationMin + } + + return inflation +} +``` + +### NextAnnualProvisions + +Calculate the annual provisions based on current total supply and inflation +rate. This parameter is calculated once per block. + +```go +NextAnnualProvisions(params Params, totalSupply math.LegacyDec) (provisions math.LegacyDec) { + return Inflation * totalSupply +``` + +### BlockProvision + +Calculate the provisions generated for each block based on current annual provisions. The provisions are then minted by the `mint` module's `ModuleMinterAccount` and then transferred to the `auth`'s `FeeCollector` `ModuleAccount`. + +```go +BlockProvision(params Params) sdk.Coin { + provisionAmt = AnnualProvisions/ params.BlocksPerYear + return sdk.NewCoin(params.MintDenom, provisionAmt.Truncate()) +``` + + +## Parameters + +The minting module contains the following parameters: + +| Key | Type | Example | +|---------------------|-----------------|------------------------| +| MintDenom | string | "uatom" | +| InflationRateChange | string (dec) | "0.130000000000000000" | +| InflationMax | string (dec) | "0.200000000000000000" | +| InflationMin | string (dec) | "0.070000000000000000" | +| GoalBonded | string (dec) | "0.670000000000000000" | +| BlocksPerYear | string (uint64) | "6311520" | + + +## Events + +The minting module emits the following events: + +### BeginBlocker + +| Type | Attribute Key | Attribute Value | +|------|-------------------|--------------------| +| mint | bonded_ratio | {bondedRatio} | +| mint | inflation | {inflation} | +| mint | annual_provisions | {annualProvisions} | +| mint | amount | {amount} | + + +## Client + +### CLI + +A user can query and interact with the `mint` module using the CLI. + +#### Query + +The `query` commands allows users to query `mint` state. + +```shell +simd query mint --help +``` + +##### annual-provisions + +The `annual-provisions` command allows users to query the current minting annual provisions value + +```shell +simd query mint annual-provisions [flags] +``` + +Example: + +```shell +simd query mint annual-provisions +``` + +Example Output: + +```shell +22268504368893.612100895088410693 +``` + +##### inflation + +The `inflation` command allows users to query the current minting inflation value + +```shell +simd query mint inflation [flags] +``` + +Example: + +```shell +simd query mint inflation +``` + +Example Output: + +```shell +0.199200302563256955 +``` + +##### params + +The `params` command allows users to query the current minting parameters + +```shell +simd query mint params [flags] +``` + +Example: + +```yml +blocks_per_year: "4360000" +goal_bonded: "0.670000000000000000" +inflation_max: "0.200000000000000000" +inflation_min: "0.070000000000000000" +inflation_rate_change: "0.130000000000000000" +mint_denom: stake +``` + +### gRPC + +A user can query the `mint` module using gRPC endpoints. + +#### AnnualProvisions + +The `AnnualProvisions` endpoint allows users to query the current minting annual provisions value + +```shell +/cosmos.mint.v1beta1.Query/AnnualProvisions +``` + +Example: + +```shell +grpcurl -plaintext localhost:9090 cosmos.mint.v1beta1.Query/AnnualProvisions +``` + +Example Output: + +```json +{ + "annualProvisions": "1432452520532626265712995618" +} +``` + +#### Inflation + +The `Inflation` endpoint allows users to query the current minting inflation value + +```shell +/cosmos.mint.v1beta1.Query/Inflation +``` + +Example: + +```shell +grpcurl -plaintext localhost:9090 cosmos.mint.v1beta1.Query/Inflation +``` + +Example Output: + +```json +{ + "inflation": "130197115720711261" +} +``` + +#### Params + +The `Params` endpoint allows users to query the current minting parameters + +```shell +/cosmos.mint.v1beta1.Query/Params +``` + +Example: + +```shell +grpcurl -plaintext localhost:9090 cosmos.mint.v1beta1.Query/Params +``` + +Example Output: + +```json +{ + "params": { + "mintDenom": "stake", + "inflationRateChange": "130000000000000000", + "inflationMax": "200000000000000000", + "inflationMin": "70000000000000000", + "goalBonded": "670000000000000000", + "blocksPerYear": "6311520" + } +} +``` + +### REST + +A user can query the `mint` module using REST endpoints. + +#### annual-provisions + +```shell +/cosmos/mint/v1beta1/annual_provisions +``` + +Example: + +```shell +curl "localhost:1317/cosmos/mint/v1beta1/annual_provisions" +``` + +Example Output: + +```json +{ + "annualProvisions": "1432452520532626265712995618" +} +``` + +#### inflation + +```shell +/cosmos/mint/v1beta1/inflation +``` + +Example: + +```shell +curl "localhost:1317/cosmos/mint/v1beta1/inflation" +``` + +Example Output: + +```json +{ + "inflation": "130197115720711261" +} +``` + +#### params + +```shell +/cosmos/mint/v1beta1/params +``` + +Example: + +```shell +curl "localhost:1317/cosmos/mint/v1beta1/params" +``` + +Example Output: + +```json +{ + "params": { + "mintDenom": "stake", + "inflationRateChange": "130000000000000000", + "inflationMax": "200000000000000000", + "inflationMin": "70000000000000000", + "goalBonded": "670000000000000000", + "blocksPerYear": "6311520" + } +} +``` diff --git a/.gitbook/developers/modules/core/nft/README.md b/.gitbook/developers/modules/core/nft/README.md new file mode 100644 index 00000000..34c1d406 --- /dev/null +++ b/.gitbook/developers/modules/core/nft/README.md @@ -0,0 +1,89 @@ +--- +sidebar_position: 1 +--- + +# `x/nft` + +## Contents + +## Abstract + +`x/nft` is an implementation of a Cosmos SDK module, per [ADR 43](https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-043-nft-module.md), that allows you to create nft classification, create nft, transfer nft, update nft, and support various queries by integrating the module. It is fully compatible with the ERC721 specification. + +* [Concepts](#concepts) + * [Class](#class) + * [NFT](#nft) +* [State](#state) + * [Class](#class-1) + * [NFT](#nft-1) + * [NFTOfClassByOwner](#nftofclassbyowner) + * [Owner](#owner) + * [TotalSupply](#totalsupply) +* [Messages](#messages) + * [MsgSend](#msgsend) +* [Events](#events) + +## Concepts + +### Class + +`x/nft` module defines a struct `Class` to describe the common characteristics of a class of nft, under this class, you can create a variety of nft, which is equivalent to an erc721 contract for Ethereum. The design is defined in the [ADR 043](https://github.com/cosmos/cosmos-sdk/blob/main/docs/architecture/adr-043-nft-module.md). + +### NFT + +The full name of NFT is Non-Fungible Tokens. Because of the irreplaceable nature of NFT, it means that it can be used to represent unique things. The nft implemented by this module is fully compatible with Ethereum ERC721 standard. + +## State + +### Class + +Class is mainly composed of `id`, `name`, `symbol`, `description`, `uri`, `uri_hash`,`data` where `id` is the unique identifier of the class, similar to the Ethereum ERC721 contract address, the others are optional. + +* Class: `0x01 | classID | -> ProtocolBuffer(Class)` + +### NFT + +NFT is mainly composed of `class_id`, `id`, `uri`, `uri_hash` and `data`. Among them, `class_id` and `id` are two-tuples that identify the uniqueness of nft, `uri` and `uri_hash` is optional, which identifies the off-chain storage location of the nft, and `data` is an Any type. Use Any chain of `x/nft` modules can be customized by extending this field + +* NFT: `0x02 | classID | 0x00 | nftID |-> ProtocolBuffer(NFT)` + +### NFTOfClassByOwner + +NFTOfClassByOwner is mainly to realize the function of querying all nfts using classID and owner, without other redundant functions. + +* NFTOfClassByOwner: `0x03 | owner | 0x00 | classID | 0x00 | nftID |-> 0x01` + +### Owner + +Since there is no extra field in NFT to indicate the owner of nft, an additional key-value pair is used to save the ownership of nft. With the transfer of nft, the key-value pair is updated synchronously. + +* OwnerKey: `0x04 | classID | 0x00 | nftID |-> owner` + +### TotalSupply + +TotalSupply is responsible for tracking the number of all nfts under a certain class. Mint operation is performed under the changed class, supply increases by one, burn operation, and supply decreases by one. + +* OwnerKey: `0x05 | classID |-> totalSupply` + +## Messages + +In this section we describe the processing of messages for the NFT module. + +:::warning +The validation of `ClassID` and `NftID` is left to the app developer. +The SDK does not provide any validation for these fields. +::: + +### MsgSend + +You can use the `MsgSend` message to transfer the ownership of nft. This is a function provided by the `x/nft` module. Of course, you can use the `Transfer` method to implement your own transfer logic, but you need to pay extra attention to the transfer permissions. + +The message handling should fail if: + +* provided `ClassID` does not exist. +* provided `Id` does not exist. +* provided `Sender` does not the owner of nft. + +## Events + +The nft module emits proto events defined in [the Protobuf reference](https://buf.build/cosmos/cosmos-sdk/docs/main:cosmos.nft.v1beta1). diff --git a/.gitbook/developers/modules/core/params/README.md b/.gitbook/developers/modules/core/params/README.md new file mode 100644 index 00000000..f8d374d0 --- /dev/null +++ b/.gitbook/developers/modules/core/params/README.md @@ -0,0 +1,79 @@ +--- +sidebar_position: 1 +--- + +# `x/params` + +> Note: The Params module has been depreacted in favour of each module housing its own parameters. + +## Abstract + +Package params provides a globally available parameter store. + +There are two main types, Keeper and Subspace. Subspace is an isolated namespace for a +paramstore, where keys are prefixed by preconfigured spacename. Keeper has a +permission to access all existing spaces. + +Subspace can be used by the individual keepers, which need a private parameter store +that the other keepers cannot modify. The params Keeper can be used to add a route to `x/gov` router in order to modify any parameter in case a proposal passes. + +The following contents explains how to use params module for master and user modules. + +## Contents + +* [Keeper](#keeper) +* [Subspace](#subspace) + * [Key](#key) + * [KeyTable](#keytable) + * [ParamSet](#paramset) + +## Keeper + +In the app initialization stage, [subspaces](#subspace) can be allocated for other modules' keeper using `Keeper.Subspace` and are stored in `Keeper.spaces`. Then, those modules can have a reference to their specific parameter store through `Keeper.GetSubspace`. + +Example: + +```go +type ExampleKeeper struct { + paramSpace paramtypes.Subspace +} + +func (k ExampleKeeper) SetParams(ctx sdk.Context, params types.Params) { + k.paramSpace.SetParamSet(ctx, ¶ms) +} +``` + +## Subspace + +`Subspace` is a prefixed subspace of the parameter store. Each module which uses the +parameter store will take a `Subspace` to isolate permission to access. + +### Key + +Parameter keys are human readable alphanumeric strings. A parameter for the key +`"ExampleParameter"` is stored under `[]byte("SubspaceName" + "/" + "ExampleParameter")`, + where `"SubspaceName"` is the name of the subspace. + +Subkeys are secondary parameter keys those are used along with a primary parameter key. +Subkeys can be used for grouping or dynamic parameter key generation during runtime. + +### KeyTable + +All of the parameter keys that will be used should be registered at the compile +time. `KeyTable` is essentially a `map[string]attribute`, where the `string` is a parameter key. + +Currently, `attribute` consists of a `reflect.Type`, which indicates the parameter +type to check that provided key and value are compatible and registered, as well as a function `ValueValidatorFn` to validate values. + +Only primary keys have to be registered on the `KeyTable`. Subkeys inherit the +attribute of the primary key. + +### ParamSet + +Modules often define parameters as a proto message. The generated struct can implement +`ParamSet` interface to be used with the following methods: + +* `KeyTable.RegisterParamSet()`: registers all parameters in the struct +* `Subspace.{Get, Set}ParamSet()`: Get to & Set from the struct + +The implementor should be a pointer in order to use `GetParamSet()`. diff --git a/.gitbook/developers/modules/core/slashing/README.md b/.gitbook/developers/modules/core/slashing/README.md new file mode 100644 index 00000000..591a9a73 --- /dev/null +++ b/.gitbook/developers/modules/core/slashing/README.md @@ -0,0 +1,813 @@ +--- +sidebar_position: 1 +--- + +# `x/slashing` + +## Abstract + +This section specifies the slashing module of the Cosmos SDK, which implements functionality +first outlined in the [Cosmos Whitepaper](https://cosmos.network/about/whitepaper) in June 2016. + +The slashing module enables Cosmos SDK-based blockchains to disincentivize any attributable action +by a protocol-recognized actor with value at stake by penalizing them ("slashing"). + +Penalties may include, but are not limited to: + +* Burning some amount of their stake +* Removing their ability to vote on future blocks for a period of time. + +This module will be used by the Cosmos Hub, the first hub in the Cosmos ecosystem. + +## Contents + +* [Concepts](#concepts) + * [States](#states) + * [Tombstone Caps](#tombstone-caps) + * [Infraction Timelines](#infraction-timelines) +* [State](#state) + * [Signing Info (Liveness)](#signing-info-liveness) + * [Params](#params) +* [Messages](#messages) + * [Unjail](#unjail) +* [BeginBlock](#beginblock) + * [Liveness Tracking](#liveness-tracking) +* [Hooks](#hooks) +* [Events](#events) +* [Staking Tombstone](#staking-tombstone) +* [Parameters](#parameters) +* [CLI](#cli) + * [Query](#query) + * [Transactions](#transactions) + * [gRPC](#grpc) + * [REST](#rest) + +## Concepts + +### States + +At any given time, there are any number of validators registered in the state +machine. Each block, the top `MaxValidators` (defined by `x/staking`) validators +who are not jailed become _bonded_, meaning that they may propose and vote on +blocks. Validators who are _bonded_ are _at stake_, meaning that part or all of +their stake and their delegators' stake is at risk if they commit a protocol fault. + +For each of these validators we keep a `ValidatorSigningInfo` record that contains +information partaining to validator's liveness and other infraction related +attributes. + +### Tombstone Caps + +In order to mitigate the impact of initially likely categories of non-malicious +protocol faults, the Cosmos Hub implements for each validator +a _tombstone_ cap, which only allows a validator to be slashed once for a double +sign fault. For example, if you misconfigure your HSM and double-sign a bunch of +old blocks, you'll only be punished for the first double-sign (and then immediately tombstombed). This will still be quite expensive and desirable to avoid, but tombstone caps +somewhat blunt the economic impact of unintentional misconfiguration. + +Liveness faults do not have caps, as they can't stack upon each other. Liveness bugs are "detected" as soon as the infraction occurs, and the validators are immediately put in jail, so it is not possible for them to commit multiple liveness faults without unjailing in between. + +### Infraction Timelines + +To illustrate how the `x/slashing` module handles submitted evidence through +CometBFT consensus, consider the following examples: + +**Definitions**: + +_[_ : timeline start +_]_ : timeline end +_Cn_ : infraction `n` committed +_Dn_ : infraction `n` discovered +_Vb_ : validator bonded +_Vu_ : validator unbonded + +#### Single Double Sign Infraction + +\[----------C1----D1,Vu-----\] + +A single infraction is committed then later discovered, at which point the +validator is unbonded and slashed at the full amount for the infraction. + +#### Multiple Double Sign Infractions + +\[----------C1--C2---C3---D1,D2,D3Vu-----\] + +Multiple infractions are committed and then later discovered, at which point the +validator is jailed and slashed for only one infraction. Because the validator +is also tombstoned, they can not rejoin the validator set. + +## State + +### Signing Info (Liveness) + +Every block includes a set of precommits by the validators for the previous block, +known as the `LastCommitInfo` provided by CometBFT. A `LastCommitInfo` is valid so +long as it contains precommits from +2/3 of total voting power. + +Proposers are incentivized to include precommits from all validators in the CometBFT `LastCommitInfo` +by receiving additional fees proportional to the difference between the voting +power included in the `LastCommitInfo` and +2/3 (see [fee distribution](../distribution/README.md#begin-block)). + +```go +type LastCommitInfo struct { + Round int32 + Votes []VoteInfo +} +``` + +Validators are penalized for failing to be included in the `LastCommitInfo` for some +number of blocks by being automatically jailed, potentially slashed, and unbonded. + +Information about validator's liveness activity is tracked through `ValidatorSigningInfo`. +It is indexed in the store as follows: + +* ValidatorSigningInfo: `0x01 | ConsAddrLen (1 byte) | ConsAddress -> ProtocolBuffer(ValSigningInfo)` +* MissedBlocksBitArray: `0x02 | ConsAddrLen (1 byte) | ConsAddress | LittleEndianUint64(signArrayIndex) -> VarInt(didMiss)` (varint is a number encoding format) + +The first mapping allows us to easily lookup the recent signing info for a +validator based on the validator's consensus address. + +The second mapping (`MissedBlocksBitArray`) acts +as a bit-array of size `SignedBlocksWindow` that tells us if the validator missed +the block for a given index in the bit-array. The index in the bit-array is given +as little endian uint64. +The result is a `varint` that takes on `0` or `1`, where `0` indicates the +validator did not miss (did sign) the corresponding block, and `1` indicates +they missed the block (did not sign). + +Note that the `MissedBlocksBitArray` is not explicitly initialized up-front. Keys +are added as we progress through the first `SignedBlocksWindow` blocks for a newly +bonded validator. The `SignedBlocksWindow` parameter defines the size +(number of blocks) of the sliding window used to track validator liveness. + +The information stored for tracking validator liveness is as follows: + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/slashing/v1beta1/slashing.proto#L13-L35 +``` + +### Params + +The slashing module stores it's params in state with the prefix of `0x00`, +it can be updated with governance or the address with authority. + +* Params: `0x00 | ProtocolBuffer(Params)` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/slashing/v1beta1/slashing.proto#L37-L59 +``` + +## Messages + +In this section we describe the processing of messages for the `slashing` module. + +### Unjail + +If a validator was automatically unbonded due to downtime and wishes to come back online & +possibly rejoin the bonded set, it must send `MsgUnjail`: + +```protobuf +// MsgUnjail is an sdk.Msg used for unjailing a jailed validator, thus returning +// them into the bonded validator set, so they can begin receiving provisions +// and rewards again. +message MsgUnjail { + string validator_addr = 1; +} +``` + +Below is a pseudocode of the `MsgSrv/Unjail` RPC: + +```go +unjail(tx MsgUnjail) + validator = getValidator(tx.ValidatorAddr) + if validator == nil + fail with "No validator found" + + if getSelfDelegation(validator) == 0 + fail with "validator must self delegate before unjailing" + + if !validator.Jailed + fail with "Validator not jailed, cannot unjail" + + info = GetValidatorSigningInfo(operator) + if info.Tombstoned + fail with "Tombstoned validator cannot be unjailed" + if block time < info.JailedUntil + fail with "Validator still jailed, cannot unjail until period has expired" + + validator.Jailed = false + setValidator(validator) + + return +``` + +If the validator has enough stake to be in the top `n = MaximumBondedValidators`, it will be automatically rebonded, +and all delegators still delegated to the validator will be rebonded and begin to again collect +provisions and rewards. + +## BeginBlock + +### Liveness Tracking + +At the beginning of each block, we update the `ValidatorSigningInfo` for each +validator and check if they've crossed below the liveness threshold over a +sliding window. This sliding window is defined by `SignedBlocksWindow` and the +index in this window is determined by `IndexOffset` found in the validator's +`ValidatorSigningInfo`. For each block processed, the `IndexOffset` is incremented +regardless if the validator signed or not. Once the index is determined, the +`MissedBlocksBitArray` and `MissedBlocksCounter` are updated accordingly. + +Finally, in order to determine if a validator crosses below the liveness threshold, +we fetch the maximum number of blocks missed, `maxMissed`, which is +`SignedBlocksWindow - (MinSignedPerWindow * SignedBlocksWindow)` and the minimum +height at which we can determine liveness, `minHeight`. If the current block is +greater than `minHeight` and the validator's `MissedBlocksCounter` is greater than +`maxMissed`, they will be slashed by `SlashFractionDowntime`, will be jailed +for `DowntimeJailDuration`, and have the following values reset: +`MissedBlocksBitArray`, `MissedBlocksCounter`, and `IndexOffset`. + +**Note**: Liveness slashes do **NOT** lead to a tombstombing. + +```go +height := block.Height + +for vote in block.LastCommitInfo.Votes { + signInfo := GetValidatorSigningInfo(vote.Validator.Address) + + // This is a relative index, so we counts blocks the validator SHOULD have + // signed. We use the 0-value default signing info if not present, except for + // start height. + index := signInfo.IndexOffset % SignedBlocksWindow() + signInfo.IndexOffset++ + + // Update MissedBlocksBitArray and MissedBlocksCounter. The MissedBlocksCounter + // just tracks the sum of MissedBlocksBitArray. That way we avoid needing to + // read/write the whole array each time. + missedPrevious := GetValidatorMissedBlockBitArray(vote.Validator.Address, index) + missed := !signed + + switch { + case !missedPrevious && missed: + // array index has changed from not missed to missed, increment counter + SetValidatorMissedBlockBitArray(vote.Validator.Address, index, true) + signInfo.MissedBlocksCounter++ + + case missedPrevious && !missed: + // array index has changed from missed to not missed, decrement counter + SetValidatorMissedBlockBitArray(vote.Validator.Address, index, false) + signInfo.MissedBlocksCounter-- + + default: + // array index at this index has not changed; no need to update counter + } + + if missed { + // emit events... + } + + minHeight := signInfo.StartHeight + SignedBlocksWindow() + maxMissed := SignedBlocksWindow() - MinSignedPerWindow() + + // If we are past the minimum height and the validator has missed too many + // jail and slash them. + if height > minHeight && signInfo.MissedBlocksCounter > maxMissed { + validator := ValidatorByConsAddr(vote.Validator.Address) + + // emit events... + + // We need to retrieve the stake distribution which signed the block, so we + // subtract ValidatorUpdateDelay from the block height, and subtract an + // additional 1 since this is the LastCommit. + // + // Note, that this CAN result in a negative "distributionHeight" up to + // -ValidatorUpdateDelay-1, i.e. at the end of the pre-genesis block (none) = at the beginning of the genesis block. + // That's fine since this is just used to filter unbonding delegations & redelegations. + distributionHeight := height - sdk.ValidatorUpdateDelay - 1 + + SlashWithInfractionReason(vote.Validator.Address, distributionHeight, vote.Validator.Power, SlashFractionDowntime(), stakingtypes.Downtime) + Jail(vote.Validator.Address) + + signInfo.JailedUntil = block.Time.Add(DowntimeJailDuration()) + + // We need to reset the counter & array so that the validator won't be + // immediately slashed for downtime upon rebonding. + signInfo.MissedBlocksCounter = 0 + signInfo.IndexOffset = 0 + ClearValidatorMissedBlockBitArray(vote.Validator.Address) + } + + SetValidatorSigningInfo(vote.Validator.Address, signInfo) +} +``` + +## Hooks + +This section contains a description of the module's `hooks`. Hooks are operations that are executed automatically when events are raised. + +### Staking hooks + +The slashing module implements the `StakingHooks` defined in `x/staking` and are used as record-keeping of validators information. During the app initialization, these hooks should be registered in the staking module struct. + +The following hooks impact the slashing state: + +* `AfterValidatorBonded` creates a `ValidatorSigningInfo` instance as described in the following section. +* `AfterValidatorCreated` stores a validator's consensus key. +* `AfterValidatorRemoved` removes a validator's consensus key. + +### Validator Bonded + +Upon successful first-time bonding of a new validator, we create a new `ValidatorSigningInfo` structure for the +now-bonded validator, which `StartHeight` of the current block. + +If the validator was out of the validator set and gets bonded again, its new bonded height is set. + +```go +onValidatorBonded(address sdk.ValAddress) + + signingInfo, found = GetValidatorSigningInfo(address) + if !found { + signingInfo = ValidatorSigningInfo { + StartHeight : CurrentHeight, + IndexOffset : 0, + JailedUntil : time.Unix(0, 0), + Tombstone : false, + MissedBloskCounter : 0 + } else { + signingInfo.StartHeight = CurrentHeight + } + + setValidatorSigningInfo(signingInfo) + } + + return +``` + +## Events + +The slashing module emits the following events: + +### MsgServer + +#### MsgUnjail + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | ------------------ | +| message | module | slashing | +| message | sender | {validatorAddress} | + +### Keeper + +### BeginBlocker: HandleValidatorSignature + +| Type | Attribute Key | Attribute Value | +| ----- | ------------- | --------------------------- | +| slash | address | {validatorConsensusAddress} | +| slash | power | {validatorPower} | +| slash | reason | {slashReason} | +| slash | jailed [0] | {validatorConsensusAddress} | +| slash | burned coins | {math.Int} | + +* [0] Only included if the validator is jailed. + +| Type | Attribute Key | Attribute Value | +| -------- | ------------- | --------------------------- | +| liveness | address | {validatorConsensusAddress} | +| liveness | missed_blocks | {missedBlocksCounter} | +| liveness | height | {blockHeight} | + +#### Slash + +* same as `"slash"` event from `HandleValidatorSignature`, but without the `jailed` attribute. + +#### Jail + +| Type | Attribute Key | Attribute Value | +| ----- | ------------- | ------------------ | +| slash | jailed | {validatorAddress} | + +## Staking Tombstone + +### Abstract + +In the current implementation of the `slashing` module, when the consensus engine +informs the state machine of a validator's consensus fault, the validator is +partially slashed, and put into a "jail period", a period of time in which they +are not allowed to rejoin the validator set. However, because of the nature of +consensus faults and ABCI, there can be a delay between an infraction occurring, +and evidence of the infraction reaching the state machine (this is one of the +primary reasons for the existence of the unbonding period). + +> Note: The tombstone concept, only applies to faults that have a delay between +> the infraction occurring and evidence reaching the state machine. For example, +> evidence of a validator double signing may take a while to reach the state machine +> due to unpredictable evidence gossip layer delays and the ability of validators to +> selectively reveal double-signatures (e.g. to infrequently-online light clients). +> Liveness slashing, on the other hand, is detected immediately as soon as the +> infraction occurs, and therefore no slashing period is needed. A validator is +> immediately put into jail period, and they cannot commit another liveness fault +> until they unjail. In the future, there may be other types of byzantine faults +> that have delays (for example, submitting evidence of an invalid proposal as a transaction). +> When implemented, it will have to be decided whether these future types of +> byzantine faults will result in a tombstoning (and if not, the slash amounts +> will not be capped by a slashing period). + +In the current system design, once a validator is put in the jail for a consensus +fault, after the `JailPeriod` they are allowed to send a transaction to `unjail` +themselves, and thus rejoin the validator set. + +One of the "design desires" of the `slashing` module is that if multiple +infractions occur before evidence is executed (and a validator is put in jail), +they should only be punished for single worst infraction, but not cumulatively. +For example, if the sequence of events is: + +1. Validator A commits Infraction 1 (worth 30% slash) +2. Validator A commits Infraction 2 (worth 40% slash) +3. Validator A commits Infraction 3 (worth 35% slash) +4. Evidence for Infraction 1 reaches state machine (and validator is put in jail) +5. Evidence for Infraction 2 reaches state machine +6. Evidence for Infraction 3 reaches state machine + +Only Infraction 2 should have its slash take effect, as it is the highest. This +is done, so that in the case of the compromise of a validator's consensus key, +they will only be punished once, even if the hacker double-signs many blocks. +Because, the unjailing has to be done with the validator's operator key, they +have a chance to re-secure their consensus key, and then signal that they are +ready using their operator key. We call this period during which we track only +the max infraction, the "slashing period". + +Once, a validator rejoins by unjailing themselves, we begin a new slashing period; +if they commit a new infraction after unjailing, it gets slashed cumulatively on +top of the worst infraction from the previous slashing period. + +However, while infractions are grouped based off of the slashing periods, because +evidence can be submitted up to an `unbondingPeriod` after the infraction, we +still have to allow for evidence to be submitted for previous slashing periods. +For example, if the sequence of events is: + +1. Validator A commits Infraction 1 (worth 30% slash) +2. Validator A commits Infraction 2 (worth 40% slash) +3. Evidence for Infraction 1 reaches state machine (and Validator A is put in jail) +4. Validator A unjails + +We are now in a new slashing period, however we still have to keep the door open +for the previous infraction, as the evidence for Infraction 2 may still come in. +As the number of slashing periods increase, it creates more complexity as we have +to keep track of the highest infraction amount for every single slashing period. + +> Note: Currently, according to the `slashing` module spec, a new slashing period +> is created every time a validator is unbonded then rebonded. This should probably +> be changed to jailed/unjailed. See issue [#3205](https://github.com/cosmos/cosmos-sdk/issues/3205) +> for further details. For the remainder of this, I will assume that we only start +> a new slashing period when a validator gets unjailed. + +The maximum number of slashing periods is the `len(UnbondingPeriod) / len(JailPeriod)`. +The current defaults in Gaia for the `UnbondingPeriod` and `JailPeriod` are 3 weeks +and 2 days, respectively. This means there could potentially be up to 11 slashing +periods concurrently being tracked per validator. If we set the `JailPeriod >= UnbondingPeriod`, +we only have to track 1 slashing period (i.e not have to track slashing periods). + +Currently, in the jail period implementation, once a validator unjails, all of +their delegators who are delegated to them (haven't unbonded / redelegated away), +stay with them. Given that consensus safety faults are so egregious +(way more so than liveness faults), it is probably prudent to have delegators not +"auto-rebond" to the validator. + +#### Proposal: infinite jail + +We propose setting the "jail time" for a +validator who commits a consensus safety fault, to `infinite` (i.e. a tombstone state). +This essentially kicks the validator out of the validator set and does not allow +them to re-enter the validator set. All of their delegators (including the operator themselves) +have to either unbond or redelegate away. The validator operator can create a new +validator if they would like, with a new operator key and consensus key, but they +have to "re-earn" their delegations back. + +Implementing the tombstone system and getting rid of the slashing period tracking +will make the `slashing` module way simpler, especially because we can remove all +of the hooks defined in the `slashing` module consumed by the `staking` module +(the `slashing` module still consumes hooks defined in `staking`). + +#### Single slashing amount + +Another optimization that can be made is that if we assume that all ABCI faults +for CometBFT consensus are slashed at the same level, we don't have to keep +track of "max slash". Once an ABCI fault happens, we don't have to worry about +comparing potential future ones to find the max. + +Currently the only CometBFT ABCI fault is: + +* Unjustified precommits (double signs) + +It is currently planned to include the following fault in the near future: + +* Signing a precommit when you're in unbonding phase (needed to make light client bisection safe) + +Given that these faults are both attributable byzantine faults, we will likely +want to slash them equally, and thus we can enact the above change. + +> Note: This change may make sense for current CometBFT consensus, but maybe +> not for a different consensus algorithm or future versions of CometBFT that +> may want to punish at different levels (for example, partial slashing). + +## Parameters + +The slashing module contains the following parameters: + +| Key | Type | Example | +| ----------------------- | -------------- | ---------------------- | +| SignedBlocksWindow | string (int64) | "100" | +| MinSignedPerWindow | string (dec) | "0.500000000000000000" | +| DowntimeJailDuration | string (ns) | "600000000000" | +| SlashFractionDoubleSign | string (dec) | "0.050000000000000000" | +| SlashFractionDowntime | string (dec) | "0.010000000000000000" | + +## CLI + +A user can query and interact with the `slashing` module using the CLI. + +### Query + +The `query` commands allow users to query `slashing` state. + +```shell +simd query slashing --help +``` + +#### params + +The `params` command allows users to query genesis parameters for the slashing module. + +```shell +simd query slashing params [flags] +``` + +Example: + +```shell +simd query slashing params +``` + +Example Output: + +```yml +downtime_jail_duration: 600s +min_signed_per_window: "0.500000000000000000" +signed_blocks_window: "100" +slash_fraction_double_sign: "0.050000000000000000" +slash_fraction_downtime: "0.010000000000000000" +``` + +#### signing-info + +The `signing-info` command allows users to query signing-info of the validator using consensus public key. + +```shell +simd query slashing signing-infos [flags] +``` + +Example: + +```shell +simd query slashing signing-info '{"@type":"/cosmos.crypto.ed25519.PubKey","key":"Auxs3865HpB/EfssYOzfqNhEJjzys6jD5B6tPgC8="}' + +``` + +Example Output: + +```yml +address: cosmosvalcons1nrqsld3aw6lh6t082frdqc84uwxn0t958c +index_offset: "2068" +jailed_until: "1970-01-01T00:00:00Z" +missed_blocks_counter: "0" +start_height: "0" +tombstoned: false +``` + +#### signing-infos + +The `signing-infos` command allows users to query signing infos of all validators. + +```shell +simd query slashing signing-infos [flags] +``` + +Example: + +```shell +simd query slashing signing-infos +``` + +Example Output: + +```yml +info: +- address: cosmosvalcons1nrqsld3aw6lh6t082frdqc84uwxn0t958c + index_offset: "2075" + jailed_until: "1970-01-01T00:00:00Z" + missed_blocks_counter: "0" + start_height: "0" + tombstoned: false +pagination: + next_key: null + total: "0" +``` + +### Transactions + +The `tx` commands allow users to interact with the `slashing` module. + +```bash +simd tx slashing --help +``` + +#### unjail + +The `unjail` command allows users to unjail a validator previously jailed for downtime. + +```bash +simd tx slashing unjail --from mykey [flags] +``` + +Example: + +```bash +simd tx slashing unjail --from mykey +``` + +### gRPC + +A user can query the `slashing` module using gRPC endpoints. + +#### Params + +The `Params` endpoint allows users to query the parameters of slashing module. + +```shell +cosmos.slashing.v1beta1.Query/Params +``` + +Example: + +```shell +grpcurl -plaintext localhost:9090 cosmos.slashing.v1beta1.Query/Params +``` + +Example Output: + +```json +{ + "params": { + "signedBlocksWindow": "100", + "minSignedPerWindow": "NTAwMDAwMDAwMDAwMDAwMDAw", + "downtimeJailDuration": "600s", + "slashFractionDoubleSign": "NTAwMDAwMDAwMDAwMDAwMDA=", + "slashFractionDowntime": "MTAwMDAwMDAwMDAwMDAwMDA=" + } +} +``` + +#### SigningInfo + +The SigningInfo queries the signing info of given cons address. + +```shell +cosmos.slashing.v1beta1.Query/SigningInfo +``` + +Example: + +```shell +grpcurl -plaintext -d '{"cons_address":"cosmosvalcons1nrqsld3aw6lh6t082frdqc84uwxn0t958c"}' localhost:9090 cosmos.slashing.v1beta1.Query/SigningInfo +``` + +Example Output: + +```json +{ + "valSigningInfo": { + "address": "cosmosvalcons1nrqsld3aw6lh6t082frdqc84uwxn0t958c", + "indexOffset": "3493", + "jailedUntil": "1970-01-01T00:00:00Z" + } +} +``` + +#### SigningInfos + +The SigningInfos queries signing info of all validators. + +```shell +cosmos.slashing.v1beta1.Query/SigningInfos +``` + +Example: + +```shell +grpcurl -plaintext localhost:9090 cosmos.slashing.v1beta1.Query/SigningInfos +``` + +Example Output: + +```json +{ + "info": [ + { + "address": "cosmosvalcons1nrqslkwd3pz096lh6t082frdqc84uwxn0t958c", + "indexOffset": "2467", + "jailedUntil": "1970-01-01T00:00:00Z" + } + ], + "pagination": { + "total": "1" + } +} +``` + +### REST + +A user can query the `slashing` module using REST endpoints. + +#### Params + +```shell +/cosmos/slashing/v1beta1/params +``` + +Example: + +```shell +curl "localhost:1317/cosmos/slashing/v1beta1/params" +``` + +Example Output: + +```json +{ + "params": { + "signed_blocks_window": "100", + "min_signed_per_window": "0.500000000000000000", + "downtime_jail_duration": "600s", + "slash_fraction_double_sign": "0.050000000000000000", + "slash_fraction_downtime": "0.010000000000000000" +} +``` + +#### signing_info + +```shell +/cosmos/slashing/v1beta1/signing_infos/%s +``` + +Example: + +```shell +curl "localhost:1317/cosmos/slashing/v1beta1/signing_infos/cosmosvalcons1nrqslkwd3pz096lh6t082frdqc84uwxn0t958c" +``` + +Example Output: + +```json +{ + "val_signing_info": { + "address": "cosmosvalcons1nrqslkwd3pz096lh6t082frdqc84uwxn0t958c", + "start_height": "0", + "index_offset": "4184", + "jailed_until": "1970-01-01T00:00:00Z", + "tombstoned": false, + "missed_blocks_counter": "0" + } +} +``` + +#### signing_infos + +```shell +/cosmos/slashing/v1beta1/signing_infos +``` + +Example: + +```shell +curl "localhost:1317/cosmos/slashing/v1beta1/signing_infos +``` + +Example Output: + +```json +{ + "info": [ + { + "address": "cosmosvalcons1nrqslkwd3pz096lh6t082frdqc84uwxn0t958c", + "start_height": "0", + "index_offset": "4169", + "jailed_until": "1970-01-01T00:00:00Z", + "tombstoned": false, + "missed_blocks_counter": "0" + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` diff --git a/.gitbook/developers/modules/core/staking/README.md b/.gitbook/developers/modules/core/staking/README.md new file mode 100644 index 00000000..c011a593 --- /dev/null +++ b/.gitbook/developers/modules/core/staking/README.md @@ -0,0 +1,3058 @@ +--- +sidebar_position: 1 +--- + +# `x/staking` + +## Abstract + +This paper specifies the Staking module of the Cosmos SDK that was first +described in the [Cosmos Whitepaper](https://cosmos.network/about/whitepaper) +in June 2016. + +The module enables Cosmos SDK-based blockchain to support an advanced +Proof-of-Stake (PoS) system. In this system, holders of the native staking token of +the chain can become validators and can delegate tokens to validators, +ultimately determining the effective validator set for the system. + +This module is used in the Cosmos Hub, the first Hub in the Cosmos +network. + +## Contents + +* [State](#state) + * [Pool](#pool) + * [LastTotalPower](#lasttotalpower) + * [ValidatorUpdates](#validatorupdates) + * [UnbondingID](#unbondingid) + * [Params](#params) + * [Validator](#validator) + * [Delegation](#delegation) + * [UnbondingDelegation](#unbondingdelegation) + * [Redelegation](#redelegation) + * [Queues](#queues) + * [HistoricalInfo](#historicalinfo) +* [State Transitions](#state-transitions) + * [Validators](#validators) + * [Delegations](#delegations) + * [Slashing](#slashing) + * [How Shares are calculated](#how-shares-are-calculated) +* [Messages](#messages) + * [MsgCreateValidator](#msgcreatevalidator) + * [MsgEditValidator](#msgeditvalidator) + * [MsgDelegate](#msgdelegate) + * [MsgUndelegate](#msgundelegate) + * [MsgCancelUnbondingDelegation](#msgcancelunbondingdelegation) + * [MsgBeginRedelegate](#msgbeginredelegate) + * [MsgUpdateParams](#msgupdateparams) +* [Begin-Block](#begin-block) + * [Historical Info Tracking](#historical-info-tracking) +* [End-Block](#end-block) + * [Validator Set Changes](#validator-set-changes) + * [Queues](#queues-1) +* [Hooks](#hooks) +* [Events](#events) + * [EndBlocker](#endblocker) + * [Msg's](#msgs) +* [Parameters](#parameters) +* [Client](#client) + * [CLI](#cli) + * [gRPC](#grpc) + * [REST](#rest) + +## State + +### Pool + +Pool is used for tracking bonded and not-bonded token supply of the bond denomination. + +### LastTotalPower + +LastTotalPower tracks the total amounts of bonded tokens recorded during the previous end block. +Store entries prefixed with "Last" must remain unchanged until EndBlock. + +* LastTotalPower: `0x12 -> ProtocolBuffer(math.Int)` + +### ValidatorUpdates + +ValidatorUpdates contains the validator updates returned to ABCI at the end of every block. +The values are overwritten in every block. + +* ValidatorUpdates `0x61 -> []abci.ValidatorUpdate` + +### UnbondingID + +UnbondingID stores the ID of the latest unbonding operation. It enables creating unique IDs for unbonding operations, i.e., UnbondingID is incremented every time a new unbonding operation (validator unbonding, unbonding delegation, redelegation) is initiated. + +* UnbondingID: `0x37 -> uint64` + +### Params + +The staking module stores its params in state with the prefix of `0x51`, +it can be updated with governance or the address with authority. + +* Params: `0x51 | ProtocolBuffer(Params)` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/staking.proto#L310-L333 +``` + +### Validator + +Validators can have one of three statuses + +* `Unbonded`: The validator is not in the active set. They cannot sign blocks and do not earn + rewards. They can receive delegations. +* `Bonded`: Once the validator receives sufficient bonded tokens they automatically join the + active set during [`EndBlock`](#validator-set-changes) and their status is updated to `Bonded`. + They are signing blocks and receiving rewards. They can receive further delegations. + They can be slashed for misbehavior. Delegators to this validator who unbond their delegation + must wait the duration of the UnbondingTime, a chain-specific param, during which time + they are still slashable for offences of the source validator if those offences were committed + during the period of time that the tokens were bonded. +* `Unbonding`: When a validator leaves the active set, either by choice or due to slashing, jailing or + tombstoning, an unbonding of all their delegations begins. All delegations must then wait the UnbondingTime + before their tokens are moved to their accounts from the `BondedPool`. + +:::warning +Tombstoning is permanent, once tombstoned a validator's consensus key can not be reused within the chain where the tombstoning happened. +::: + +Validators objects should be primarily stored and accessed by the +`OperatorAddr`, an SDK validator address for the operator of the validator. Two +additional indices are maintained per validator object in order to fulfill +required lookups for slashing and validator-set updates. A third special index +(`LastValidatorPower`) is also maintained which however remains constant +throughout each block, unlike the first two indices which mirror the validator +records within a block. + +* Validators: `0x21 | OperatorAddrLen (1 byte) | OperatorAddr -> ProtocolBuffer(validator)` +* ValidatorsByConsAddr: `0x22 | ConsAddrLen (1 byte) | ConsAddr -> OperatorAddr` +* ValidatorsByPower: `0x23 | BigEndian(ConsensusPower) | OperatorAddrLen (1 byte) | OperatorAddr -> OperatorAddr` +* LastValidatorsPower: `0x11 | OperatorAddrLen (1 byte) | OperatorAddr -> ProtocolBuffer(ConsensusPower)` +* ValidatorsByUnbondingID: `0x38 | UnbondingID -> 0x21 | OperatorAddrLen (1 byte) | OperatorAddr` + +`Validators` is the primary index - it ensures that each operator can have only one +associated validator, where the public key of that validator can change in the +future. Delegators can refer to the immutable operator of the validator, without +concern for the changing public key. + +`ValidatorsByUnbondingID` is an additional index that enables lookups for + validators by the unbonding IDs corresponding to their current unbonding. + +`ValidatorByConsAddr` is an additional index that enables lookups for slashing. +When CometBFT reports evidence, it provides the validator address, so this +map is needed to find the operator. Note that the `ConsAddr` corresponds to the +address which can be derived from the validator's `ConsPubKey`. + +`ValidatorsByPower` is an additional index that provides a sorted list of +potential validators to quickly determine the current active set. Here +ConsensusPower is validator.Tokens/10^6 by default. Note that all validators +where `Jailed` is true are not stored within this index. + +`LastValidatorsPower` is a special index that provides a historical list of the +last-block's bonded validators. This index remains constant during a block but +is updated during the validator set update process which takes place in [`EndBlock`](#end-block). + +Each validator's state is stored in a `Validator` struct: + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/staking.proto#L82-L138 +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/staking.proto#L26-L80 +``` + +### Delegation + +Delegations are identified by combining `DelegatorAddr` (the address of the delegator) +with the `ValidatorAddr` Delegators are indexed in the store as follows: + +* Delegation: `0x31 | DelegatorAddrLen (1 byte) | DelegatorAddr | ValidatorAddrLen (1 byte) | ValidatorAddr -> ProtocolBuffer(delegation)` + +Stake holders may delegate coins to validators; under this circumstance their +funds are held in a `Delegation` data structure. It is owned by one +delegator, and is associated with the shares for one validator. The sender of +the transaction is the owner of the bond. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/staking.proto#L198-L216 +``` + +#### Delegator Shares + +When one delegates tokens to a Validator, they are issued a number of delegator shares based on a +dynamic exchange rate, calculated as follows from the total number of tokens delegated to the +validator and the number of shares issued so far: + +`Shares per Token = validator.TotalShares() / validator.Tokens()` + +Only the number of shares received is stored on the DelegationEntry. When a delegator then +Undelegates, the token amount they receive is calculated from the number of shares they currently +hold and the inverse exchange rate: + +`Tokens per Share = validator.Tokens() / validatorShares()` + +These `Shares` are simply an accounting mechanism. They are not a fungible asset. The reason for +this mechanism is to simplify the accounting around slashing. Rather than iteratively slashing the +tokens of every delegation entry, instead the Validator's total bonded tokens can be slashed, +effectively reducing the value of each issued delegator share. + +### UnbondingDelegation + +Shares in a `Delegation` can be unbonded, but they must for some time exist as +an `UnbondingDelegation`, where shares can be reduced if Byzantine behavior is +detected. + +`UnbondingDelegation` are indexed in the store as: + +* UnbondingDelegation: `0x32 | DelegatorAddrLen (1 byte) | DelegatorAddr | ValidatorAddrLen (1 byte) | ValidatorAddr -> ProtocolBuffer(unbondingDelegation)` +* UnbondingDelegationsFromValidator: `0x33 | ValidatorAddrLen (1 byte) | ValidatorAddr | DelegatorAddrLen (1 byte) | DelegatorAddr -> nil` +* UnbondingDelegationByUnbondingId: `0x38 | UnbondingId -> 0x32 | DelegatorAddrLen (1 byte) | DelegatorAddr | ValidatorAddrLen (1 byte) | ValidatorAddr` + `UnbondingDelegation` is used in queries, to lookup all unbonding delegations for + a given delegator. + +`UnbondingDelegationsFromValidator` is used in slashing, to lookup all + unbonding delegations associated with a given validator that need to be + slashed. + + `UnbondingDelegationByUnbondingId` is an additional index that enables + lookups for unbonding delegations by the unbonding IDs of the containing + unbonding delegation entries. + + +A UnbondingDelegation object is created every time an unbonding is initiated. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/staking.proto#L218-L261 +``` + +### Redelegation + +The bonded tokens worth of a `Delegation` may be instantly redelegated from a +source validator to a different validator (destination validator). However when +this occurs they must be tracked in a `Redelegation` object, whereby their +shares can be slashed if their tokens have contributed to a Byzantine fault +committed by the source validator. + +`Redelegation` are indexed in the store as: + +* Redelegations: `0x34 | DelegatorAddrLen (1 byte) | DelegatorAddr | ValidatorAddrLen (1 byte) | ValidatorSrcAddr | ValidatorDstAddr -> ProtocolBuffer(redelegation)` +* RedelegationsBySrc: `0x35 | ValidatorSrcAddrLen (1 byte) | ValidatorSrcAddr | ValidatorDstAddrLen (1 byte) | ValidatorDstAddr | DelegatorAddrLen (1 byte) | DelegatorAddr -> nil` +* RedelegationsByDst: `0x36 | ValidatorDstAddrLen (1 byte) | ValidatorDstAddr | ValidatorSrcAddrLen (1 byte) | ValidatorSrcAddr | DelegatorAddrLen (1 byte) | DelegatorAddr -> nil` +* RedelegationByUnbondingId: `0x38 | UnbondingId -> 0x34 | DelegatorAddrLen (1 byte) | DelegatorAddr | ValidatorAddrLen (1 byte) | ValidatorSrcAddr | ValidatorDstAddr` + + `Redelegations` is used for queries, to lookup all redelegations for a given + delegator. + + `RedelegationsBySrc` is used for slashing based on the `ValidatorSrcAddr`. + + `RedelegationsByDst` is used for slashing based on the `ValidatorDstAddr` + +The first map here is used for queries, to lookup all redelegations for a given +delegator. The second map is used for slashing based on the `ValidatorSrcAddr`, +while the third map is for slashing based on the `ValidatorDstAddr`. + +`RedelegationByUnbondingId` is an additional index that enables + lookups for redelegations by the unbonding IDs of the containing + redelegation entries. + +A redelegation object is created every time a redelegation occurs. To prevent +"redelegation hopping" redelegations may not occur under the situation that: + +* the (re)delegator already has another immature redelegation in progress + with a destination to a validator (let's call it `Validator X`) +* and, the (re)delegator is attempting to create a _new_ redelegation + where the source validator for this new redelegation is `Validator X`. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/staking.proto#L263-L308 +``` + +### Queues + +All queue objects are sorted by timestamp. The time used within any queue is +firstly converted to UTC, rounded to the nearest nanosecond then sorted. The sortable time format +used is a slight modification of the RFC3339Nano and uses the format string +`"2006-01-02T15:04:05.000000000"`. Notably this format: + +* right pads all zeros +* drops the time zone info (we already use UTC) + +In all cases, the stored timestamp represents the maturation time of the queue +element. + +#### UnbondingDelegationQueue + +For the purpose of tracking progress of unbonding delegations the unbonding +delegations queue is kept. + +* UnbondingDelegation: `0x41 | format(time) -> []DVPair` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/staking.proto#L162-L172 +``` + +#### RedelegationQueue + +For the purpose of tracking progress of redelegations the redelegation queue is +kept. + +* RedelegationQueue: `0x42 | format(time) -> []DVVTriplet` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/staking.proto#L179-L191 +``` + +#### ValidatorQueue + +For the purpose of tracking progress of unbonding validators the validator +queue is kept. + +* ValidatorQueueTime: `0x43 | format(time) -> []sdk.ValAddress` + +The stored object by each key is an array of validator operator addresses from +which the validator object can be accessed. Typically it is expected that only +a single validator record will be associated with a given timestamp however it is possible +that multiple validators exist in the queue at the same location. + +### HistoricalInfo + +HistoricalInfo objects are stored and pruned at each block such that the staking keeper persists +the `n` most recent historical info defined by staking module parameter: `HistoricalEntries`. + +```go reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/staking.proto#L17-L24 +``` + +At each BeginBlock, the staking keeper will persist the current Header and the Validators that committed +the current block in a `HistoricalInfo` object. The Validators are sorted on their address to ensure that +they are in a deterministic order. +The oldest HistoricalEntries will be pruned to ensure that there only exist the parameter-defined number of +historical entries. + +## State Transitions + +### Validators + +State transitions in validators are performed on every [`EndBlock`](#validator-set-changes) +in order to check for changes in the active `ValidatorSet`. + +A validator can be `Unbonded`, `Unbonding` or `Bonded`. `Unbonded` +and `Unbonding` are collectively called `Not Bonded`. A validator can move +directly between all the states, except for from `Bonded` to `Unbonded`. + +#### Not bonded to Bonded + +The following transition occurs when a validator's ranking in the `ValidatorPowerIndex` surpasses +that of the `LastValidator`. + +* set `validator.Status` to `Bonded` +* send the `validator.Tokens` from the `NotBondedTokens` to the `BondedPool` `ModuleAccount` +* delete the existing record from `ValidatorByPowerIndex` +* add a new updated record to the `ValidatorByPowerIndex` +* update the `Validator` object for this validator +* if it exists, delete any `ValidatorQueue` record for this validator + +#### Bonded to Unbonding + +When a validator begins the unbonding process the following operations occur: + +* send the `validator.Tokens` from the `BondedPool` to the `NotBondedTokens` `ModuleAccount` +* set `validator.Status` to `Unbonding` +* delete the existing record from `ValidatorByPowerIndex` +* add a new updated record to the `ValidatorByPowerIndex` +* update the `Validator` object for this validator +* insert a new record into the `ValidatorQueue` for this validator + +#### Unbonding to Unbonded + +A validator moves from unbonding to unbonded when the `ValidatorQueue` object +moves from bonded to unbonded + +* update the `Validator` object for this validator +* set `validator.Status` to `Unbonded` + +#### Jail/Unjail + +when a validator is jailed it is effectively removed from the CometBFT set. +this process may be also be reversed. the following operations occur: + +* set `Validator.Jailed` and update object +* if jailed delete record from `ValidatorByPowerIndex` +* if unjailed add record to `ValidatorByPowerIndex` + +Jailed validators are not present in any of the following stores: + +* the power store (from consensus power to address) + +### Delegations + +#### Delegate + +When a delegation occurs both the validator and the delegation objects are affected + +* determine the delegators shares based on tokens delegated and the validator's exchange rate +* remove tokens from the sending account +* add shares the delegation object or add them to a created validator object +* add new delegator shares and update the `Validator` object +* transfer the `delegation.Amount` from the delegator's account to the `BondedPool` or the `NotBondedPool` `ModuleAccount` depending if the `validator.Status` is `Bonded` or not +* delete the existing record from `ValidatorByPowerIndex` +* add an new updated record to the `ValidatorByPowerIndex` + +#### Begin Unbonding + +As a part of the Undelegate and Complete Unbonding state transitions Unbond +Delegation may be called. + +* subtract the unbonded shares from delegator +* add the unbonded tokens to an `UnbondingDelegationEntry` +* update the delegation or remove the delegation if there are no more shares +* if the delegation is the operator of the validator and no more shares exist then trigger a jail validator +* update the validator with removed the delegator shares and associated coins +* if the validator state is `Bonded`, transfer the `Coins` worth of the unbonded + shares from the `BondedPool` to the `NotBondedPool` `ModuleAccount` +* remove the validator if it is unbonded and there are no more delegation shares. +* remove the validator if it is unbonded and there are no more delegation shares +* get a unique `unbondingId` and map it to the `UnbondingDelegationEntry` in `UnbondingDelegationByUnbondingId` +* call the `AfterUnbondingInitiated(unbondingId)` hook +* add the unbonding delegation to `UnbondingDelegationQueue` with the completion time set to `UnbondingTime` + +#### Cancel an `UnbondingDelegation` Entry + +When a `cancel unbond delegation` occurs both the `validator`, the `delegation` and an `UnbondingDelegationQueue` state will be updated. + +* if cancel unbonding delegation amount equals to the `UnbondingDelegation` entry `balance`, then the `UnbondingDelegation` entry deleted from `UnbondingDelegationQueue`. +* if the `cancel unbonding delegation amount is less than the `UnbondingDelegation` entry balance, then the `UnbondingDelegation` entry will be updated with new balance in the `UnbondingDelegationQueue`. +* cancel `amount` is [Delegated](#delegations) back to the original `validator`. + +#### Complete Unbonding + +For undelegations which do not complete immediately, the following operations +occur when the unbonding delegation queue element matures: + +* remove the entry from the `UnbondingDelegation` object +* transfer the tokens from the `NotBondedPool` `ModuleAccount` to the delegator `Account` + +#### Begin Redelegation + +Redelegations affect the delegation, source and destination validators. + +* perform an `unbond` delegation from the source validator to retrieve the tokens worth of the unbonded shares +* using the unbonded tokens, `Delegate` them to the destination validator +* if the `sourceValidator.Status` is `Bonded`, and the `destinationValidator` is not, + transfer the newly delegated tokens from the `BondedPool` to the `NotBondedPool` `ModuleAccount` +* otherwise, if the `sourceValidator.Status` is not `Bonded`, and the `destinationValidator` + is `Bonded`, transfer the newly delegated tokens from the `NotBondedPool` to the `BondedPool` `ModuleAccount` +* record the token amount in an new entry in the relevant `Redelegation` + +From when a redelegation begins until it completes, the delegator is in a state of "pseudo-unbonding", and can still be +slashed for infractions that occurred before the redelegation began. + +#### Complete Redelegation + +When a redelegations complete the following occurs: + +* remove the entry from the `Redelegation` object + +### Slashing + +#### Slash Validator + +When a Validator is slashed, the following occurs: + +* The total `slashAmount` is calculated as the `slashFactor` (a chain parameter) \* `TokensFromConsensusPower`, + the total number of tokens bonded to the validator at the time of the infraction. +* Every unbonding delegation and pseudo-unbonding redelegation such that the infraction occured before the unbonding or + redelegation began from the validator are slashed by the `slashFactor` percentage of the initialBalance. +* Each amount slashed from redelegations and unbonding delegations is subtracted from the + total slash amount. +* The `remaingSlashAmount` is then slashed from the validator's tokens in the `BondedPool` or + `NonBondedPool` depending on the validator's status. This reduces the total supply of tokens. + +In the case of a slash due to any infraction that requires evidence to submitted (for example double-sign), the slash +occurs at the block where the evidence is included, not at the block where the infraction occured. +Put otherwise, validators are not slashed retroactively, only when they are caught. + +#### Slash Unbonding Delegation + +When a validator is slashed, so are those unbonding delegations from the validator that began unbonding +after the time of the infraction. Every entry in every unbonding delegation from the validator +is slashed by `slashFactor`. The amount slashed is calculated from the `InitialBalance` of the +delegation and is capped to prevent a resulting negative balance. Completed (or mature) unbondings are not slashed. + +#### Slash Redelegation + +When a validator is slashed, so are all redelegations from the validator that began after the +infraction. Redelegations are slashed by `slashFactor`. +Redelegations that began before the infraction are not slashed. +The amount slashed is calculated from the `InitialBalance` of the delegation and is capped to +prevent a resulting negative balance. +Mature redelegations (that have completed pseudo-unbonding) are not slashed. + +### How Shares are calculated + +At any given point in time, each validator has a number of tokens, `T`, and has a number of shares issued, `S`. +Each delegator, `i`, holds a number of shares, `S_i`. +The number of tokens is the sum of all tokens delegated to the validator, plus the rewards, minus the slashes. + +The delegator is entitled to a portion of the underlying tokens proportional to their proportion of shares. +So delegator `i` is entitled to `T * S_i / S` of the validator's tokens. + +When a delegator delegates new tokens to the validator, they receive a number of shares proportional to their contribution. +So when delegator `j` delegates `T_j` tokens, they receive `S_j = S * T_j / T` shares. +The total number of tokens is now `T + T_j`, and the total number of shares is `S + S_j`. +`j`s proportion of the shares is the same as their proportion of the total tokens contributed: `(S + S_j) / S = (T + T_j) / T`. + +A special case is the initial delegation, when `T = 0` and `S = 0`, so `T_j / T` is undefined. +For the initial delegation, delegator `j` who delegates `T_j` tokens receive `S_j = T_j` shares. +So a validator that hasn't received any rewards and has not been slashed will have `T = S`. + +## Messages + +In this section we describe the processing of the staking messages and the corresponding updates to the state. All created/modified state objects specified by each message are defined within the [state](#state) section. + +### MsgCreateValidator + +A validator is created using the `MsgCreateValidator` message. +The validator must be created with an initial delegation from the operator. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L20-L21 +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L50-L73 +``` + +This message is expected to fail if: + +* another validator with this operator address is already registered +* another validator with this pubkey is already registered +* the initial self-delegation tokens are of a denom not specified as the bonding denom +* the commission parameters are faulty, namely: + * `MaxRate` is either > 1 or < 0 + * the initial `Rate` is either negative or > `MaxRate` + * the initial `MaxChangeRate` is either negative or > `MaxRate` +* the description fields are too large + +This message creates and stores the `Validator` object at appropriate indexes. +Additionally a self-delegation is made with the initial tokens delegation +tokens `Delegation`. The validator always starts as unbonded but may be bonded +in the first end-block. + +### MsgEditValidator + +The `Description`, `CommissionRate` of a validator can be updated using the +`MsgEditValidator` message. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L23-L24 +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L78-L97 +``` + +This message is expected to fail if: + +* the initial `CommissionRate` is either negative or > `MaxRate` +* the `CommissionRate` has already been updated within the previous 24 hours +* the `CommissionRate` is > `MaxChangeRate` +* the description fields are too large + +This message stores the updated `Validator` object. + +### MsgDelegate + +Within this message the delegator provides coins, and in return receives +some amount of their validator's (newly created) delegator-shares that are +assigned to `Delegation.Shares`. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L26-L28 +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L102-L114 +``` + +This message is expected to fail if: + +* the validator does not exist +* the `Amount` `Coin` has a denomination different than one defined by `params.BondDenom` +* the exchange rate is invalid, meaning the validator has no tokens (due to slashing) but there are outstanding shares +* the amount delegated is less than the minimum allowed delegation + +If an existing `Delegation` object for provided addresses does not already +exist then it is created as part of this message otherwise the existing +`Delegation` is updated to include the newly received shares. + +The delegator receives newly minted shares at the current exchange rate. +The exchange rate is the number of existing shares in the validator divided by +the number of currently delegated tokens. + +The validator is updated in the `ValidatorByPower` index, and the delegation is +tracked in validator object in the `Validators` index. + +It is possible to delegate to a jailed validator, the only difference being it +will not be added to the power index until it is unjailed. + +![Delegation sequence](https://raw.githubusercontent.com/cosmos/cosmos-sdk/release/v0.46.x/docs/uml/svg/delegation_sequence.svg) + +### MsgUndelegate + +The `MsgUndelegate` message allows delegators to undelegate their tokens from +validator. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L34-L36 +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L140-L152 +``` + +This message returns a response containing the completion time of the undelegation: + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L154-L158 +``` + +This message is expected to fail if: + +* the delegation doesn't exist +* the validator doesn't exist +* the delegation has less shares than the ones worth of `Amount` +* existing `UnbondingDelegation` has maximum entries as defined by `params.MaxEntries` +* the `Amount` has a denomination different than one defined by `params.BondDenom` + +When this message is processed the following actions occur: + +* validator's `DelegatorShares` and the delegation's `Shares` are both reduced by the message `SharesAmount` +* calculate the token worth of the shares remove that amount tokens held within the validator +* with those removed tokens, if the validator is: + * `Bonded` - add them to an entry in `UnbondingDelegation` (create `UnbondingDelegation` if it doesn't exist) with a completion time a full unbonding period from the current time. Update pool shares to reduce BondedTokens and increase NotBondedTokens by token worth of the shares. + * `Unbonding` - add them to an entry in `UnbondingDelegation` (create `UnbondingDelegation` if it doesn't exist) with the same completion time as the validator (`UnbondingMinTime`). + * `Unbonded` - then send the coins the message `DelegatorAddr` +* if there are no more `Shares` in the delegation, then the delegation object is removed from the store + * under this situation if the delegation is the validator's self-delegation then also jail the validator. + +![Unbond sequence](https://raw.githubusercontent.com/cosmos/cosmos-sdk/release/v0.46.x/docs/uml/svg/unbond_sequence.svg) + +### MsgCancelUnbondingDelegation + +The `MsgCancelUnbondingDelegation` message allows delegators to cancel the `unbondingDelegation` entry and delegate back to a previous validator. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L38-L42 +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L160-L175 +``` + +This message is expected to fail if: + +* the `unbondingDelegation` entry is already processed. +* the `cancel unbonding delegation` amount is greater than the `unbondingDelegation` entry balance. +* the `cancel unbonding delegation` height doesn't exist in the `unbondingDelegationQueue` of the delegator. + +When this message is processed the following actions occur: + +* if the `unbondingDelegation` Entry balance is zero + * in this condition `unbondingDelegation` entry will be removed from `unbondingDelegationQueue`. + * otherwise `unbondingDelegationQueue` will be updated with new `unbondingDelegation` entry balance and initial balance +* the validator's `DelegatorShares` and the delegation's `Shares` are both increased by the message `Amount`. + +### MsgBeginRedelegate + +The redelegation command allows delegators to instantly switch validators. Once +the unbonding period has passed, the redelegation is automatically completed in +the EndBlocker. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L30-L32 +``` + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L119-L132 +``` + +This message returns a response containing the completion time of the redelegation: + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L133-L138 +``` + +This message is expected to fail if: + +* the delegation doesn't exist +* the source or destination validators don't exist +* the delegation has less shares than the ones worth of `Amount` +* the source validator has a receiving redelegation which is not matured (aka. the redelegation may be transitive) +* existing `Redelegation` has maximum entries as defined by `params.MaxEntries` +* the `Amount` `Coin` has a denomination different than one defined by `params.BondDenom` + +When this message is processed the following actions occur: + +* the source validator's `DelegatorShares` and the delegations `Shares` are both reduced by the message `SharesAmount` +* calculate the token worth of the shares remove that amount tokens held within the source validator. +* if the source validator is: + * `Bonded` - add an entry to the `Redelegation` (create `Redelegation` if it doesn't exist) with a completion time a full unbonding period from the current time. Update pool shares to reduce BondedTokens and increase NotBondedTokens by token worth of the shares (this may be effectively reversed in the next step however). + * `Unbonding` - add an entry to the `Redelegation` (create `Redelegation` if it doesn't exist) with the same completion time as the validator (`UnbondingMinTime`). + * `Unbonded` - no action required in this step +* Delegate the token worth to the destination validator, possibly moving tokens back to the bonded state. +* if there are no more `Shares` in the source delegation, then the source delegation object is removed from the store + * under this situation if the delegation is the validator's self-delegation then also jail the validator. + +![Begin redelegation sequence](https://raw.githubusercontent.com/cosmos/cosmos-sdk/release/v0.46.x/docs/uml/svg/begin_redelegation_sequence.svg) + + +### MsgUpdateParams + +The `MsgUpdateParams` update the staking module parameters. +The params are updated through a governance proposal where the signer is the gov module account address. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/staking/v1beta1/tx.proto#L182-L195 +``` + +The message handling can fail if: + +* signer is not the authority defined in the staking keeper (usually the gov module account). + +## Begin-Block + +Each abci begin block call, the historical info will get stored and pruned +according to the `HistoricalEntries` parameter. + +### Historical Info Tracking + +If the `HistoricalEntries` parameter is 0, then the `BeginBlock` performs a no-op. + +Otherwise, the latest historical info is stored under the key `historicalInfoKey|height`, while any entries older than `height - HistoricalEntries` is deleted. +In most cases, this results in a single entry being pruned per block. +However, if the parameter `HistoricalEntries` has changed to a lower value there will be multiple entries in the store that must be pruned. + +## End-Block + +Each abci end block call, the operations to update queues and validator set +changes are specified to execute. + +### Validator Set Changes + +The staking validator set is updated during this process by state transitions +that run at the end of every block. As a part of this process any updated +validators are also returned back to CometBFT for inclusion in the CometBFT +validator set which is responsible for validating CometBFT messages at the +consensus layer. Operations are as following: + +* the new validator set is taken as the top `params.MaxValidators` number of + validators retrieved from the `ValidatorsByPower` index +* the previous validator set is compared with the new validator set: + * missing validators begin unbonding and their `Tokens` are transferred from the + `BondedPool` to the `NotBondedPool` `ModuleAccount` + * new validators are instantly bonded and their `Tokens` are transferred from the + `NotBondedPool` to the `BondedPool` `ModuleAccount` + +In all cases, any validators leaving or entering the bonded validator set or +changing balances and staying within the bonded validator set incur an update +message reporting their new consensus power which is passed back to CometBFT. + +The `LastTotalPower` and `LastValidatorsPower` hold the state of the total power +and validator power from the end of the last block, and are used to check for +changes that have occurred in `ValidatorsByPower` and the total new power, which +is calculated during `EndBlock`. + +### Queues + +Within staking, certain state-transitions are not instantaneous but take place +over a duration of time (typically the unbonding period). When these +transitions are mature certain operations must take place in order to complete +the state operation. This is achieved through the use of queues which are +checked/processed at the end of each block. + +#### Unbonding Validators + +When a validator is kicked out of the bonded validator set (either through +being jailed, or not having sufficient bonded tokens) it begins the unbonding +process along with all its delegations begin unbonding (while still being +delegated to this validator). At this point the validator is said to be an +"unbonding validator", whereby it will mature to become an "unbonded validator" +after the unbonding period has passed. + +Each block the validator queue is to be checked for mature unbonding validators +(namely with a completion time <= current time and completion height <= current +block height). At this point any mature validators which do not have any +delegations remaining are deleted from state. For all other mature unbonding +validators that still have remaining delegations, the `validator.Status` is +switched from `types.Unbonding` to +`types.Unbonded`. + +Unbonding operations can be put on hold by external modules via the `PutUnbondingOnHold(unbondingId)` method. + As a result, an unbonding operation (e.g., an unbonding delegation) that is on hold, cannot complete + even if it reaches maturity. For an unbonding operation with `unbondingId` to eventually complete + (after it reaches maturity), every call to `PutUnbondingOnHold(unbondingId)` must be matched + by a call to `UnbondingCanComplete(unbondingId)`. + +#### Unbonding Delegations + +Complete the unbonding of all mature `UnbondingDelegations.Entries` within the +`UnbondingDelegations` queue with the following procedure: + +* transfer the balance coins to the delegator's wallet address +* remove the mature entry from `UnbondingDelegation.Entries` +* remove the `UnbondingDelegation` object from the store if there are no + remaining entries. + +#### Redelegations + +Complete the unbonding of all mature `Redelegation.Entries` within the +`Redelegations` queue with the following procedure: + +* remove the mature entry from `Redelegation.Entries` +* remove the `Redelegation` object from the store if there are no + remaining entries. + +## Hooks + +Other modules may register operations to execute when a certain event has +occurred within staking. These events can be registered to execute either +right `Before` or `After` the staking event (as per the hook name). The +following hooks can registered with staking: + +* `AfterValidatorCreated(Context, ValAddress) error` + * called when a validator is created +* `BeforeValidatorModified(Context, ValAddress) error` + * called when a validator's state is changed +* `AfterValidatorRemoved(Context, ConsAddress, ValAddress) error` + * called when a validator is deleted +* `AfterValidatorBonded(Context, ConsAddress, ValAddress) error` + * called when a validator is bonded +* `AfterValidatorBeginUnbonding(Context, ConsAddress, ValAddress) error` + * called when a validator begins unbonding +* `BeforeDelegationCreated(Context, AccAddress, ValAddress) error` + * called when a delegation is created +* `BeforeDelegationSharesModified(Context, AccAddress, ValAddress) error` + * called when a delegation's shares are modified +* `AfterDelegationModified(Context, AccAddress, ValAddress) error` + * called when a delegation is created or modified +* `BeforeDelegationRemoved(Context, AccAddress, ValAddress) error` + * called when a delegation is removed +* `AfterUnbondingInitiated(Context, UnbondingID)` + * called when an unbonding operation (validator unbonding, unbonding delegation, redelegation) was initiated + + +## Events + +The staking module emits the following events: + +### EndBlocker + +| Type | Attribute Key | Attribute Value | +| --------------------- | --------------------- | ------------------------- | +| complete_unbonding | amount | {totalUnbondingAmount} | +| complete_unbonding | validator | {validatorAddress} | +| complete_unbonding | delegator | {delegatorAddress} | +| complete_redelegation | amount | {totalRedelegationAmount} | +| complete_redelegation | source_validator | {srcValidatorAddress} | +| complete_redelegation | destination_validator | {dstValidatorAddress} | +| complete_redelegation | delegator | {delegatorAddress} | + +## Msg's + +### MsgCreateValidator + +| Type | Attribute Key | Attribute Value | +| ---------------- | ------------- | ------------------ | +| create_validator | validator | {validatorAddress} | +| create_validator | amount | {delegationAmount} | +| message | module | staking | +| message | action | create_validator | +| message | sender | {senderAddress} | + +### MsgEditValidator + +| Type | Attribute Key | Attribute Value | +| -------------- | ------------------- | ------------------- | +| edit_validator | commission_rate | {commissionRate} | +| edit_validator | min_self_delegation | {minSelfDelegation} | +| message | module | staking | +| message | action | edit_validator | +| message | sender | {senderAddress} | + +### MsgDelegate + +| Type | Attribute Key | Attribute Value | +| -------- | ------------- | ------------------ | +| delegate | validator | {validatorAddress} | +| delegate | amount | {delegationAmount} | +| message | module | staking | +| message | action | delegate | +| message | sender | {senderAddress} | + +### MsgUndelegate + +| Type | Attribute Key | Attribute Value | +| ------- | ------------------- | ------------------ | +| unbond | validator | {validatorAddress} | +| unbond | amount | {unbondAmount} | +| unbond | completion_time [0] | {completionTime} | +| message | module | staking | +| message | action | begin_unbonding | +| message | sender | {senderAddress} | + +* [0] Time is formatted in the RFC3339 standard + +### MsgCancelUnbondingDelegation + +| Type | Attribute Key | Attribute Value | +| ----------------------------- | ------------------ | ------------------------------------| +| cancel_unbonding_delegation | validator | {validatorAddress} | +| cancel_unbonding_delegation | delegator | {delegatorAddress} | +| cancel_unbonding_delegation | amount | {cancelUnbondingDelegationAmount} | +| cancel_unbonding_delegation | creation_height | {unbondingCreationHeight} | +| message | module | staking | +| message | action | cancel_unbond | +| message | sender | {senderAddress} | + +### MsgBeginRedelegate + +| Type | Attribute Key | Attribute Value | +| ---------- | --------------------- | --------------------- | +| redelegate | source_validator | {srcValidatorAddress} | +| redelegate | destination_validator | {dstValidatorAddress} | +| redelegate | amount | {unbondAmount} | +| redelegate | completion_time [0] | {completionTime} | +| message | module | staking | +| message | action | begin_redelegate | +| message | sender | {senderAddress} | + +* [0] Time is formatted in the RFC3339 standard + +## Parameters + +The staking module contains the following parameters: + +| Key | Type | Example | +|-------------------|------------------|------------------------| +| UnbondingTime | string (time ns) | "259200000000000" | +| MaxValidators | uint16 | 100 | +| KeyMaxEntries | uint16 | 7 | +| HistoricalEntries | uint16 | 3 | +| BondDenom | string | "stake" | +| MinCommissionRate | string | "0.000000000000000000" | + +## Client + +### CLI + +A user can query and interact with the `staking` module using the CLI. + +#### Query + +The `query` commands allows users to query `staking` state. + +```bash +simd query staking --help +``` + +##### delegation + +The `delegation` command allows users to query delegations for an individual delegator on an individual validator. + +Usage: + +```bash +simd query staking delegation [delegator-addr] [validator-addr] [flags] +``` + +Example: + +```bash +simd query staking delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +``` + +Example Output: + +```bash +balance: + amount: "10000000000" + denom: stake +delegation: + delegator_address: cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p + shares: "10000000000.000000000000000000" + validator_address: cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +``` + +##### delegations + +The `delegations` command allows users to query delegations for an individual delegator on all validators. + +Usage: + +```bash +simd query staking delegations [delegator-addr] [flags] +``` + +Example: + +```bash +simd query staking delegations cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p +``` + +Example Output: + +```bash +delegation_responses: +- balance: + amount: "10000000000" + denom: stake + delegation: + delegator_address: cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p + shares: "10000000000.000000000000000000" + validator_address: cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +- balance: + amount: "10000000000" + denom: stake + delegation: + delegator_address: cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p + shares: "10000000000.000000000000000000" + validator_address: cosmosvaloper1x20lytyf6zkcrv5edpkfkn8sz578qg5sqfyqnp +pagination: + next_key: null + total: "0" +``` + +##### delegations-to + +The `delegations-to` command allows users to query delegations on an individual validator. + +Usage: + +```bash +simd query staking delegations-to [validator-addr] [flags] +``` + +Example: + +```bash +simd query staking delegations-to cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +``` + +Example Output: + +```bash +- balance: + amount: "504000000" + denom: stake + delegation: + delegator_address: cosmos1q2qwwynhv8kh3lu5fkeex4awau9x8fwt45f5cp + shares: "504000000.000000000000000000" + validator_address: cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +- balance: + amount: "78125000000" + denom: uixo + delegation: + delegator_address: cosmos1qvppl3479hw4clahe0kwdlfvf8uvjtcd99m2ca + shares: "78125000000.000000000000000000" + validator_address: cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +pagination: + next_key: null + total: "0" +``` + +##### historical-info + +The `historical-info` command allows users to query historical information at given height. + +Usage: + +```bash +simd query staking historical-info [height] [flags] +``` + +Example: + +```bash +simd query staking historical-info 10 +``` + +Example Output: + +```bash +header: + app_hash: Lbx8cXpI868wz8sgp4qPYVrlaKjevR5WP/IjUxwp3oo= + chain_id: testnet + consensus_hash: BICRvH3cKD93v7+R1zxE2ljD34qcvIZ0Bdi389qtoi8= + data_hash: 47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU= + evidence_hash: 47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU= + height: "10" + last_block_id: + hash: RFbkpu6pWfSThXxKKl6EZVDnBSm16+U0l0xVjTX08Fk= + part_set_header: + hash: vpIvXD4rxD5GM4MXGz0Sad9I7//iVYLzZsEU4BVgWIU= + total: 1 + last_commit_hash: Ne4uXyx4QtNp4Zx89kf9UK7oG9QVbdB6e7ZwZkhy8K0= + last_results_hash: 47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU= + next_validators_hash: nGBgKeWBjoxeKFti00CxHsnULORgKY4LiuQwBuUrhCs= + proposer_address: mMEP2c2IRPLr99LedSRtBg9eONM= + time: "2021-10-01T06:00:49.785790894Z" + validators_hash: nGBgKeWBjoxeKFti00CxHsnULORgKY4LiuQwBuUrhCs= + version: + app: "0" + block: "11" +valset: +- commission: + commission_rates: + max_change_rate: "0.010000000000000000" + max_rate: "0.200000000000000000" + rate: "0.100000000000000000" + update_time: "2021-10-01T05:52:50.380144238Z" + consensus_pubkey: + '@type': /cosmos.crypto.ed25519.PubKey + key: Auxs3865HpB/EfssYOzfqNhEJjzys2Fo6jD5B8tPgC8= + delegator_shares: "10000000.000000000000000000" + description: + details: "" + identity: "" + moniker: myvalidator + security_contact: "" + website: "" + jailed: false + min_self_delegation: "1" + operator_address: cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc + status: BOND_STATUS_BONDED + tokens: "10000000" + unbonding_height: "0" + unbonding_time: "1970-01-01T00:00:00Z" +``` + +##### params + +The `params` command allows users to query values set as staking parameters. + +Usage: + +```bash +simd query staking params [flags] +``` + +Example: + +```bash +simd query staking params +``` + +Example Output: + +```bash +bond_denom: stake +historical_entries: 10000 +max_entries: 7 +max_validators: 50 +unbonding_time: 1814400s +``` + +##### pool + +The `pool` command allows users to query values for amounts stored in the staking pool. + +Usage: + +```bash +simd q staking pool [flags] +``` + +Example: + +```bash +simd q staking pool +``` + +Example Output: + +```bash +bonded_tokens: "10000000" +not_bonded_tokens: "0" +``` + +##### redelegation + +The `redelegation` command allows users to query a redelegation record based on delegator and a source and destination validator address. + +Usage: + +```bash +simd query staking redelegation [delegator-addr] [src-validator-addr] [dst-validator-addr] [flags] +``` + +Example: + +```bash +simd query staking redelegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p cosmosvaloper1l2rsakp388kuv9k8qzq6lrm9taddae7fpx59wm cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +``` + +Example Output: + +```bash +pagination: null +redelegation_responses: +- entries: + - balance: "50000000" + redelegation_entry: + completion_time: "2021-10-24T20:33:21.960084845Z" + creation_height: 2.382847e+06 + initial_balance: "50000000" + shares_dst: "50000000.000000000000000000" + - balance: "5000000000" + redelegation_entry: + completion_time: "2021-10-25T21:33:54.446846862Z" + creation_height: 2.397271e+06 + initial_balance: "5000000000" + shares_dst: "5000000000.000000000000000000" + redelegation: + delegator_address: cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p + entries: null + validator_dst_address: cosmosvaloper1l2rsakp388kuv9k8qzq6lrm9taddae7fpx59wm + validator_src_address: cosmosvaloper1l2rsakp388kuv9k8qzq6lrm9taddae7fpx59wm +``` + +##### redelegations + +The `redelegations` command allows users to query all redelegation records for an individual delegator. + +Usage: + +```bash +simd query staking redelegations [delegator-addr] [flags] +``` + +Example: + +```bash +simd query staking redelegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p +``` + +Example Output: + +```bash +pagination: + next_key: null + total: "0" +redelegation_responses: +- entries: + - balance: "50000000" + redelegation_entry: + completion_time: "2021-10-24T20:33:21.960084845Z" + creation_height: 2.382847e+06 + initial_balance: "50000000" + shares_dst: "50000000.000000000000000000" + - balance: "5000000000" + redelegation_entry: + completion_time: "2021-10-25T21:33:54.446846862Z" + creation_height: 2.397271e+06 + initial_balance: "5000000000" + shares_dst: "5000000000.000000000000000000" + redelegation: + delegator_address: cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p + entries: null + validator_dst_address: cosmosvaloper1uccl5ugxrm7vqlzwqr04pjd320d2fz0z3hc6vm + validator_src_address: cosmosvaloper1zppjyal5emta5cquje8ndkpz0rs046m7zqxrpp +- entries: + - balance: "562770000000" + redelegation_entry: + completion_time: "2021-10-25T21:42:07.336911677Z" + creation_height: 2.39735e+06 + initial_balance: "562770000000" + shares_dst: "562770000000.000000000000000000" + redelegation: + delegator_address: cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p + entries: null + validator_dst_address: cosmosvaloper1uccl5ugxrm7vqlzwqr04pjd320d2fz0z3hc6vm + validator_src_address: cosmosvaloper1zppjyal5emta5cquje8ndkpz0rs046m7zqxrpp +``` + +##### redelegations-from + +The `redelegations-from` command allows users to query delegations that are redelegating _from_ a validator. + +Usage: + +```bash +simd query staking redelegations-from [validator-addr] [flags] +``` + +Example: + +```bash +simd query staking redelegations-from cosmosvaloper1y4rzzrgl66eyhzt6gse2k7ej3zgwmngeleucjy +``` + +Example Output: + +```bash +pagination: + next_key: null + total: "0" +redelegation_responses: +- entries: + - balance: "50000000" + redelegation_entry: + completion_time: "2021-10-24T20:33:21.960084845Z" + creation_height: 2.382847e+06 + initial_balance: "50000000" + shares_dst: "50000000.000000000000000000" + - balance: "5000000000" + redelegation_entry: + completion_time: "2021-10-25T21:33:54.446846862Z" + creation_height: 2.397271e+06 + initial_balance: "5000000000" + shares_dst: "5000000000.000000000000000000" + redelegation: + delegator_address: cosmos1pm6e78p4pgn0da365plzl4t56pxy8hwtqp2mph + entries: null + validator_dst_address: cosmosvaloper1uccl5ugxrm7vqlzwqr04pjd320d2fz0z3hc6vm + validator_src_address: cosmosvaloper1y4rzzrgl66eyhzt6gse2k7ej3zgwmngeleucjy +- entries: + - balance: "221000000" + redelegation_entry: + completion_time: "2021-10-05T21:05:45.669420544Z" + creation_height: 2.120693e+06 + initial_balance: "221000000" + shares_dst: "221000000.000000000000000000" + redelegation: + delegator_address: cosmos1zqv8qxy2zgn4c58fz8jt8jmhs3d0attcussrf6 + entries: null + validator_dst_address: cosmosvaloper10mseqwnwtjaqfrwwp2nyrruwmjp6u5jhah4c3y + validator_src_address: cosmosvaloper1y4rzzrgl66eyhzt6gse2k7ej3zgwmngeleucjy +``` + +##### unbonding-delegation + +The `unbonding-delegation` command allows users to query unbonding delegations for an individual delegator on an individual validator. + +Usage: + +```bash +simd query staking unbonding-delegation [delegator-addr] [validator-addr] [flags] +``` + +Example: + +```bash +simd query staking unbonding-delegation cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +``` + +Example Output: + +```bash +delegator_address: cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p +entries: +- balance: "52000000" + completion_time: "2021-11-02T11:35:55.391594709Z" + creation_height: "55078" + initial_balance: "52000000" +validator_address: cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +``` + +##### unbonding-delegations + +The `unbonding-delegations` command allows users to query all unbonding-delegations records for one delegator. + +Usage: + +```bash +simd query staking unbonding-delegations [delegator-addr] [flags] +``` + +Example: + +```bash +simd query staking unbonding-delegations cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p +``` + +Example Output: + +```bash +pagination: + next_key: null + total: "0" +unbonding_responses: +- delegator_address: cosmos1gghjut3ccd8ay0zduzj64hwre2fxs9ld75ru9p + entries: + - balance: "52000000" + completion_time: "2021-11-02T11:35:55.391594709Z" + creation_height: "55078" + initial_balance: "52000000" + validator_address: cosmosvaloper1t8ehvswxjfn3ejzkjtntcyrqwvmvuknzmvtaaa + +``` + +##### unbonding-delegations-from + +The `unbonding-delegations-from` command allows users to query delegations that are unbonding _from_ a validator. + +Usage: + +```bash +simd query staking unbonding-delegations-from [validator-addr] [flags] +``` + +Example: + +```bash +simd query staking unbonding-delegations-from cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +``` + +Example Output: + +```bash +pagination: + next_key: null + total: "0" +unbonding_responses: +- delegator_address: cosmos1qqq9txnw4c77sdvzx0tkedsafl5s3vk7hn53fn + entries: + - balance: "150000000" + completion_time: "2021-11-01T21:41:13.098141574Z" + creation_height: "46823" + initial_balance: "150000000" + validator_address: cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +- delegator_address: cosmos1peteje73eklqau66mr7h7rmewmt2vt99y24f5z + entries: + - balance: "24000000" + completion_time: "2021-10-31T02:57:18.192280361Z" + creation_height: "21516" + initial_balance: "24000000" + validator_address: cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +``` + +##### validator + +The `validator` command allows users to query details about an individual validator. + +Usage: + +```bash +simd query staking validator [validator-addr] [flags] +``` + +Example: + +```bash +simd query staking validator cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +``` + +Example Output: + +```bash +commission: + commission_rates: + max_change_rate: "0.020000000000000000" + max_rate: "0.200000000000000000" + rate: "0.050000000000000000" + update_time: "2021-10-01T19:24:52.663191049Z" +consensus_pubkey: + '@type': /cosmos.crypto.ed25519.PubKey + key: sIiexdJdYWn27+7iUHQJDnkp63gq/rzUq1Y+fxoGjXc= +delegator_shares: "32948270000.000000000000000000" +description: + details: Witval is the validator arm from Vitwit. Vitwit is into software consulting + and services business since 2015. We are working closely with Cosmos ecosystem + since 2018. We are also building tools for the ecosystem, Aneka is our explorer + for the cosmos ecosystem. + identity: 51468B615127273A + moniker: Witval + security_contact: "" + website: "" +jailed: false +min_self_delegation: "1" +operator_address: cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj +status: BOND_STATUS_BONDED +tokens: "32948270000" +unbonding_height: "0" +unbonding_time: "1970-01-01T00:00:00Z" +``` + +##### validators + +The `validators` command allows users to query details about all validators on a network. + +Usage: + +```bash +simd query staking validators [flags] +``` + +Example: + +```bash +simd query staking validators +``` + +Example Output: + +```bash +pagination: + next_key: FPTi7TKAjN63QqZh+BaXn6gBmD5/ + total: "0" +validators: +commission: + commission_rates: + max_change_rate: "0.020000000000000000" + max_rate: "0.200000000000000000" + rate: "0.050000000000000000" + update_time: "2021-10-01T19:24:52.663191049Z" +consensus_pubkey: + '@type': /cosmos.crypto.ed25519.PubKey + key: sIiexdJdYWn27+7iUHQJDnkp63gq/rzUq1Y+fxoGjXc= +delegator_shares: "32948270000.000000000000000000" +description: + details: Witval is the validator arm from Vitwit. Vitwit is into software consulting + and services business since 2015. We are working closely with Cosmos ecosystem + since 2018. We are also building tools for the ecosystem, Aneka is our explorer + for the cosmos ecosystem. + identity: 51468B615127273A + moniker: Witval + security_contact: "" + website: "" + jailed: false + min_self_delegation: "1" + operator_address: cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj + status: BOND_STATUS_BONDED + tokens: "32948270000" + unbonding_height: "0" + unbonding_time: "1970-01-01T00:00:00Z" +- commission: + commission_rates: + max_change_rate: "0.100000000000000000" + max_rate: "0.200000000000000000" + rate: "0.050000000000000000" + update_time: "2021-10-04T18:02:21.446645619Z" + consensus_pubkey: + '@type': /cosmos.crypto.ed25519.PubKey + key: GDNpuKDmCg9GnhnsiU4fCWktuGUemjNfvpCZiqoRIYA= + delegator_shares: "559343421.000000000000000000" + description: + details: Noderunners is a professional validator in POS networks. We have a huge + node running experience, reliable soft and hardware. Our commissions are always + low, our support to delegators is always full. Stake with us and start receiving + your Cosmos rewards now! + identity: 812E82D12FEA3493 + moniker: Noderunners + security_contact: info@noderunners.biz + website: http://noderunners.biz + jailed: false + min_self_delegation: "1" + operator_address: cosmosvaloper1q5ku90atkhktze83j9xjaks2p7uruag5zp6wt7 + status: BOND_STATUS_BONDED + tokens: "559343421" + unbonding_height: "0" + unbonding_time: "1970-01-01T00:00:00Z" +``` + +#### Transactions + +The `tx` commands allows users to interact with the `staking` module. + +```bash +simd tx staking --help +``` + +##### create-validator + +The command `create-validator` allows users to create new validator initialized with a self-delegation to it. + +Usage: + +```bash +simd tx staking create-validator [path/to/validator.json] [flags] +``` + +Example: + +```bash +simd tx staking create-validator /path/to/validator.json \ + --chain-id="name_of_chain_id" \ + --gas="auto" \ + --gas-adjustment="1.2" \ + --gas-prices="0.025stake" \ + --from=mykey +``` + +where `validator.json` contains: + +```json +{ + "pubkey": {"@type":"/cosmos.crypto.ed25519.PubKey","key":"BnbwFpeONLqvWqJb3qaUbL5aoIcW3fSuAp9nT3z5f20="}, + "amount": "1000000stake", + "moniker": "my-moniker", + "website": "https://myweb.site", + "security": "security-contact@gmail.com", + "details": "description of your validator", + "commission-rate": "0.10", + "commission-max-rate": "0.20", + "commission-max-change-rate": "0.01", + "min-self-delegation": "1" +} +``` + +and pubkey can be obtained by using `simd tendermint show-validator` command. + +##### delegate + +The command `delegate` allows users to delegate liquid tokens to a validator. + +Usage: + +```bash +simd tx staking delegate [validator-addr] [amount] [flags] +``` + +Example: + +```bash +simd tx staking delegate cosmosvaloper1l2rsakp388kuv9k8qzq6lrm9taddae7fpx59wm 1000stake --from mykey +``` + +##### edit-validator + +The command `edit-validator` allows users to edit an existing validator account. + +Usage: + +```bash +simd tx staking edit-validator [flags] +``` + +Example: + +```bash +simd tx staking edit-validator --moniker "new_moniker_name" --website "new_webiste_url" --from mykey +``` + +##### redelegate + +The command `redelegate` allows users to redelegate illiquid tokens from one validator to another. + +Usage: + +```bash +simd tx staking redelegate [src-validator-addr] [dst-validator-addr] [amount] [flags] +``` + +Example: + +```bash +simd tx staking redelegate cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj cosmosvaloper1l2rsakp388kuv9k8qzq6lrm9taddae7fpx59wm 100stake --from mykey +``` + +##### unbond + +The command `unbond` allows users to unbond shares from a validator. + +Usage: + +```bash +simd tx staking unbond [validator-addr] [amount] [flags] +``` + +Example: + +```bash +simd tx staking unbond cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj 100stake --from mykey +``` + +##### cancel unbond + +The command `cancel-unbond` allow users to cancel the unbonding delegation entry and delegate back to the original validator. + +Usage: + +```bash +simd tx staking cancel-unbond [validator-addr] [amount] [creation-height] +``` + +Example: + +```bash +simd tx staking cancel-unbond cosmosvaloper1gghjut3ccd8ay0zduzj64hwre2fxs9ldmqhffj 100stake 123123 --from mykey +``` + + +### gRPC + +A user can query the `staking` module using gRPC endpoints. + +#### Validators + +The `Validators` endpoint queries all validators that match the given status. + +```bash +cosmos.staking.v1beta1.Query/Validators +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 cosmos.staking.v1beta1.Query/Validators +``` + +Example Output: + +```bash +{ + "validators": [ + { + "operatorAddress": "cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc", + "consensusPubkey": {"@type":"/cosmos.crypto.ed25519.PubKey","key":"Auxs3865HpB/EfssYOzfqNhEJjzys2Fo6jD5B8tPgC8="}, + "status": "BOND_STATUS_BONDED", + "tokens": "10000000", + "delegatorShares": "10000000000000000000000000", + "description": { + "moniker": "myvalidator" + }, + "unbondingTime": "1970-01-01T00:00:00Z", + "commission": { + "commissionRates": { + "rate": "100000000000000000", + "maxRate": "200000000000000000", + "maxChangeRate": "10000000000000000" + }, + "updateTime": "2021-10-01T05:52:50.380144238Z" + }, + "minSelfDelegation": "1" + } + ], + "pagination": { + "total": "1" + } +} +``` + +#### Validator + +The `Validator` endpoint queries validator information for given validator address. + +```bash +cosmos.staking.v1beta1.Query/Validator +``` + +Example: + +```bash +grpcurl -plaintext -d '{"validator_addr":"cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/Validator +``` + +Example Output: + +```bash +{ + "validator": { + "operatorAddress": "cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc", + "consensusPubkey": {"@type":"/cosmos.crypto.ed25519.PubKey","key":"Auxs3865HpB/EfssYOzfqNhEJjzys2Fo6jD5B8tPgC8="}, + "status": "BOND_STATUS_BONDED", + "tokens": "10000000", + "delegatorShares": "10000000000000000000000000", + "description": { + "moniker": "myvalidator" + }, + "unbondingTime": "1970-01-01T00:00:00Z", + "commission": { + "commissionRates": { + "rate": "100000000000000000", + "maxRate": "200000000000000000", + "maxChangeRate": "10000000000000000" + }, + "updateTime": "2021-10-01T05:52:50.380144238Z" + }, + "minSelfDelegation": "1" + } +} +``` + +#### ValidatorDelegations + +The `ValidatorDelegations` endpoint queries delegate information for given validator. + +```bash +cosmos.staking.v1beta1.Query/ValidatorDelegations +``` + +Example: + +```bash +grpcurl -plaintext -d '{"validator_addr":"cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/ValidatorDelegations +``` + +Example Output: + +```bash +{ + "delegationResponses": [ + { + "delegation": { + "delegatorAddress": "cosmos1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgy3ua5t", + "validatorAddress": "cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc", + "shares": "10000000000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "10000000" + } + } + ], + "pagination": { + "total": "1" + } +} +``` + +#### ValidatorUnbondingDelegations + +The `ValidatorUnbondingDelegations` endpoint queries delegate information for given validator. + +```bash +cosmos.staking.v1beta1.Query/ValidatorUnbondingDelegations +``` + +Example: + +```bash +grpcurl -plaintext -d '{"validator_addr":"cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/ValidatorUnbondingDelegations +``` + +Example Output: + +```bash +{ + "unbonding_responses": [ + { + "delegator_address": "cosmos1z3pzzw84d6xn00pw9dy3yapqypfde7vg6965fy", + "validator_address": "cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc", + "entries": [ + { + "creation_height": "25325", + "completion_time": "2021-10-31T09:24:36.797320636Z", + "initial_balance": "20000000", + "balance": "20000000" + } + ] + }, + { + "delegator_address": "cosmos1y8nyfvmqh50p6ldpzljk3yrglppdv3t8phju77", + "validator_address": "cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc", + "entries": [ + { + "creation_height": "13100", + "completion_time": "2021-10-30T12:53:02.272266791Z", + "initial_balance": "1000000", + "balance": "1000000" + } + ] + }, + ], + "pagination": { + "next_key": null, + "total": "8" + } +} +``` + +#### Delegation + +The `Delegation` endpoint queries delegate information for given validator delegator pair. + +```bash +cosmos.staking.v1beta1.Query/Delegation +``` + +Example: + +```bash +grpcurl -plaintext \ +-d '{"delegator_addr": "cosmos1y8nyfvmqh50p6ldpzljk3yrglppdv3t8phju77", validator_addr":"cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/Delegation +``` + +Example Output: + +```bash +{ + "delegation_response": + { + "delegation": + { + "delegator_address":"cosmos1y8nyfvmqh50p6ldpzljk3yrglppdv3t8phju77", + "validator_address":"cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc", + "shares":"25083119936.000000000000000000" + }, + "balance": + { + "denom":"stake", + "amount":"25083119936" + } + } +} +``` + +#### UnbondingDelegation + +The `UnbondingDelegation` endpoint queries unbonding information for given validator delegator. + +```bash +cosmos.staking.v1beta1.Query/UnbondingDelegation +``` + +Example: + +```bash +grpcurl -plaintext \ +-d '{"delegator_addr": "cosmos1y8nyfvmqh50p6ldpzljk3yrglppdv3t8phju77", validator_addr":"cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/UnbondingDelegation +``` + +Example Output: + +```bash +{ + "unbond": { + "delegator_address": "cosmos1y8nyfvmqh50p6ldpzljk3yrglppdv3t8phju77", + "validator_address": "cosmosvaloper1rne8lgs98p0jqe82sgt0qr4rdn4hgvmgp9ggcc", + "entries": [ + { + "creation_height": "136984", + "completion_time": "2021-11-08T05:38:47.505593891Z", + "initial_balance": "400000000", + "balance": "400000000" + }, + { + "creation_height": "137005", + "completion_time": "2021-11-08T05:40:53.526196312Z", + "initial_balance": "385000000", + "balance": "385000000" + } + ] + } +} +``` + +#### DelegatorDelegations + +The `DelegatorDelegations` endpoint queries all delegations of a given delegator address. + +```bash +cosmos.staking.v1beta1.Query/DelegatorDelegations +``` + +Example: + +```bash +grpcurl -plaintext \ +-d '{"delegator_addr": "cosmos1y8nyfvmqh50p6ldpzljk3yrglppdv3t8phju77"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/DelegatorDelegations +``` + +Example Output: + +```bash +{ + "delegation_responses": [ + {"delegation":{"delegator_address":"cosmos1y8nyfvmqh50p6ldpzljk3yrglppdv3t8phju77","validator_address":"cosmosvaloper1eh5mwu044gd5ntkkc2xgfg8247mgc56fww3vc8","shares":"25083339023.000000000000000000"},"balance":{"denom":"stake","amount":"25083339023"}} + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +#### DelegatorUnbondingDelegations + +The `DelegatorUnbondingDelegations` endpoint queries all unbonding delegations of a given delegator address. + +```bash +cosmos.staking.v1beta1.Query/DelegatorUnbondingDelegations +``` + +Example: + +```bash +grpcurl -plaintext \ +-d '{"delegator_addr": "cosmos1y8nyfvmqh50p6ldpzljk3yrglppdv3t8phju77"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/DelegatorUnbondingDelegations +``` + +Example Output: + +```bash +{ + "unbonding_responses": [ + { + "delegator_address": "cosmos1y8nyfvmqh50p6ldpzljk3yrglppdv3t8phju77", + "validator_address": "cosmosvaloper1sjllsnramtg3ewxqwwrwjxfgc4n4ef9uxyejze", + "entries": [ + { + "creation_height": "136984", + "completion_time": "2021-11-08T05:38:47.505593891Z", + "initial_balance": "400000000", + "balance": "400000000" + }, + { + "creation_height": "137005", + "completion_time": "2021-11-08T05:40:53.526196312Z", + "initial_balance": "385000000", + "balance": "385000000" + } + ] + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +#### Redelegations + +The `Redelegations` endpoint queries redelegations of given address. + +```bash +cosmos.staking.v1beta1.Query/Redelegations +``` + +Example: + +```bash +grpcurl -plaintext \ +-d '{"delegator_addr": "cosmos1ld5p7hn43yuh8ht28gm9pfjgj2fctujp2tgwvf", "src_validator_addr" : "cosmosvaloper1j7euyj85fv2jugejrktj540emh9353ltgppc3g", "dst_validator_addr" : "cosmosvaloper1yy3tnegzmkdcm7czzcy3flw5z0zyr9vkkxrfse"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/Redelegations +``` + +Example Output: + +```bash +{ + "redelegation_responses": [ + { + "redelegation": { + "delegator_address": "cosmos1ld5p7hn43yuh8ht28gm9pfjgj2fctujp2tgwvf", + "validator_src_address": "cosmosvaloper1j7euyj85fv2jugejrktj540emh9353ltgppc3g", + "validator_dst_address": "cosmosvaloper1yy3tnegzmkdcm7czzcy3flw5z0zyr9vkkxrfse", + "entries": null + }, + "entries": [ + { + "redelegation_entry": { + "creation_height": 135932, + "completion_time": "2021-11-08T03:52:55.299147901Z", + "initial_balance": "2900000", + "shares_dst": "2900000.000000000000000000" + }, + "balance": "2900000" + } + ] + } + ], + "pagination": null +} +``` + +#### DelegatorValidators + +The `DelegatorValidators` endpoint queries all validators information for given delegator. + +```bash +cosmos.staking.v1beta1.Query/DelegatorValidators +``` + +Example: + +```bash +grpcurl -plaintext \ +-d '{"delegator_addr": "cosmos1ld5p7hn43yuh8ht28gm9pfjgj2fctujp2tgwvf"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/DelegatorValidators +``` + +Example Output: + +```bash +{ + "validators": [ + { + "operator_address": "cosmosvaloper1eh5mwu044gd5ntkkc2xgfg8247mgc56fww3vc8", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "UPwHWxH1zHJWGOa/m6JB3f5YjHMvPQPkVbDqqi+U7Uw=" + }, + "jailed": false, + "status": "BOND_STATUS_BONDED", + "tokens": "347260647559", + "delegator_shares": "347260647559.000000000000000000", + "description": { + "moniker": "BouBouNode", + "identity": "", + "website": "https://boubounode.com", + "security_contact": "", + "details": "AI-based Validator. #1 AI Validator on Game of Stakes. Fairly priced. Don't trust (humans), verify. Made with BouBou love." + }, + "unbonding_height": "0", + "unbonding_time": "1970-01-01T00:00:00Z", + "commission": { + "commission_rates": { + "rate": "0.061000000000000000", + "max_rate": "0.300000000000000000", + "max_change_rate": "0.150000000000000000" + }, + "update_time": "2021-10-01T15:00:00Z" + }, + "min_self_delegation": "1" + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +#### DelegatorValidator + +The `DelegatorValidator` endpoint queries validator information for given delegator validator + +```bash +cosmos.staking.v1beta1.Query/DelegatorValidator +``` + +Example: + +```bash +grpcurl -plaintext \ +-d '{"delegator_addr": "cosmos1eh5mwu044gd5ntkkc2xgfg8247mgc56f3n8rr7", "validator_addr": "cosmosvaloper1eh5mwu044gd5ntkkc2xgfg8247mgc56fww3vc8"}' \ +localhost:9090 cosmos.staking.v1beta1.Query/DelegatorValidator +``` + +Example Output: + +```bash +{ + "validator": { + "operator_address": "cosmosvaloper1eh5mwu044gd5ntkkc2xgfg8247mgc56fww3vc8", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "UPwHWxH1zHJWGOa/m6JB3f5YjHMvPQPkVbDqqi+U7Uw=" + }, + "jailed": false, + "status": "BOND_STATUS_BONDED", + "tokens": "347262754841", + "delegator_shares": "347262754841.000000000000000000", + "description": { + "moniker": "BouBouNode", + "identity": "", + "website": "https://boubounode.com", + "security_contact": "", + "details": "AI-based Validator. #1 AI Validator on Game of Stakes. Fairly priced. Don't trust (humans), verify. Made with BouBou love." + }, + "unbonding_height": "0", + "unbonding_time": "1970-01-01T00:00:00Z", + "commission": { + "commission_rates": { + "rate": "0.061000000000000000", + "max_rate": "0.300000000000000000", + "max_change_rate": "0.150000000000000000" + }, + "update_time": "2021-10-01T15:00:00Z" + }, + "min_self_delegation": "1" + } +} +``` + +#### HistoricalInfo + +```bash +cosmos.staking.v1beta1.Query/HistoricalInfo +``` + +Example: + +```bash +grpcurl -plaintext -d '{"height" : 1}' localhost:9090 cosmos.staking.v1beta1.Query/HistoricalInfo +``` + +Example Output: + +```bash +{ + "hist": { + "header": { + "version": { + "block": "11", + "app": "0" + }, + "chain_id": "simd-1", + "height": "140142", + "time": "2021-10-11T10:56:29.720079569Z", + "last_block_id": { + "hash": "9gri/4LLJUBFqioQ3NzZIP9/7YHR9QqaM6B2aJNQA7o=", + "part_set_header": { + "total": 1, + "hash": "Hk1+C864uQkl9+I6Zn7IurBZBKUevqlVtU7VqaZl1tc=" + } + }, + "last_commit_hash": "VxrcS27GtvGruS3I9+AlpT7udxIT1F0OrRklrVFSSKc=", + "data_hash": "80BjOrqNYUOkTnmgWyz9AQ8n7SoEmPVi4QmAe8RbQBY=", + "validators_hash": "95W49n2hw8RWpr1GPTAO5MSPi6w6Wjr3JjjS7AjpBho=", + "next_validators_hash": "95W49n2hw8RWpr1GPTAO5MSPi6w6Wjr3JjjS7AjpBho=", + "consensus_hash": "BICRvH3cKD93v7+R1zxE2ljD34qcvIZ0Bdi389qtoi8=", + "app_hash": "ZZaxnSY3E6Ex5Bvkm+RigYCK82g8SSUL53NymPITeOE=", + "last_results_hash": "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=", + "evidence_hash": "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=", + "proposer_address": "aH6dO428B+ItuoqPq70efFHrSMY=" + }, + "valset": [ + { + "operator_address": "cosmosvaloper196ax4vc0lwpxndu9dyhvca7jhxp70rmcqcnylw", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "/O7BtNW0pafwfvomgR4ZnfldwPXiFfJs9mHg3gwfv5Q=" + }, + "jailed": false, + "status": "BOND_STATUS_BONDED", + "tokens": "1426045203613", + "delegator_shares": "1426045203613.000000000000000000", + "description": { + "moniker": "SG-1", + "identity": "48608633F99D1B60", + "website": "https://sg-1.online", + "security_contact": "", + "details": "SG-1 - your favorite validator on Witval. We offer 100% Soft Slash protection." + }, + "unbonding_height": "0", + "unbonding_time": "1970-01-01T00:00:00Z", + "commission": { + "commission_rates": { + "rate": "0.037500000000000000", + "max_rate": "0.200000000000000000", + "max_change_rate": "0.030000000000000000" + }, + "update_time": "2021-10-01T15:00:00Z" + }, + "min_self_delegation": "1" + } + ] + } +} + +``` + +#### Pool + +The `Pool` endpoint queries the pool information. + +```bash +cosmos.staking.v1beta1.Query/Pool +``` + +Example: + +```bash +grpcurl -plaintext -d localhost:9090 cosmos.staking.v1beta1.Query/Pool +``` + +Example Output: + +```bash +{ + "pool": { + "not_bonded_tokens": "369054400189", + "bonded_tokens": "15657192425623" + } +} +``` + +#### Params + +The `Params` endpoint queries the pool information. + +```bash +cosmos.staking.v1beta1.Query/Params +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 cosmos.staking.v1beta1.Query/Params +``` + +Example Output: + +```bash +{ + "params": { + "unbondingTime": "1814400s", + "maxValidators": 100, + "maxEntries": 7, + "historicalEntries": 10000, + "bondDenom": "stake" + } +} +``` + +### REST + +A user can query the `staking` module using REST endpoints. + +#### DelegatorDelegations + +The `DelegtaorDelegations` REST endpoint queries all delegations of a given delegator address. + +```bash +/cosmos/staking/v1beta1/delegations/{delegatorAddr} +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/staking/v1beta1/delegations/cosmos1vcs68xf2tnqes5tg0khr0vyevm40ff6zdxatp5" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "delegation_responses": [ + { + "delegation": { + "delegator_address": "cosmos1vcs68xf2tnqes5tg0khr0vyevm40ff6zdxatp5", + "validator_address": "cosmosvaloper1quqxfrxkycr0uzt4yk0d57tcq3zk7srm7sm6r8", + "shares": "256250000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "256250000" + } + }, + { + "delegation": { + "delegator_address": "cosmos1vcs68xf2tnqes5tg0khr0vyevm40ff6zdxatp5", + "validator_address": "cosmosvaloper194v8uwee2fvs2s8fa5k7j03ktwc87h5ym39jfv", + "shares": "255150000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "255150000" + } + } + ], + "pagination": { + "next_key": null, + "total": "2" + } +} +``` + +#### Redelegations + +The `Redelegations` REST endpoint queries redelegations of given address. + +```bash +/cosmos/staking/v1beta1/delegators/{delegatorAddr}/redelegations +``` + +Example: + +```bash +curl -X GET \ +"http://localhost:1317/cosmos/staking/v1beta1/delegators/cosmos1thfntksw0d35n2tkr0k8v54fr8wxtxwxl2c56e/redelegations?srcValidatorAddr=cosmosvaloper1lzhlnpahvznwfv4jmay2tgaha5kmz5qx4cuznf&dstValidatorAddr=cosmosvaloper1vq8tw77kp8lvxq9u3c8eeln9zymn68rng8pgt4" \ +-H "accept: application/json" +``` + +Example Output: + +```bash +{ + "redelegation_responses": [ + { + "redelegation": { + "delegator_address": "cosmos1thfntksw0d35n2tkr0k8v54fr8wxtxwxl2c56e", + "validator_src_address": "cosmosvaloper1lzhlnpahvznwfv4jmay2tgaha5kmz5qx4cuznf", + "validator_dst_address": "cosmosvaloper1vq8tw77kp8lvxq9u3c8eeln9zymn68rng8pgt4", + "entries": null + }, + "entries": [ + { + "redelegation_entry": { + "creation_height": 151523, + "completion_time": "2021-11-09T06:03:25.640682116Z", + "initial_balance": "200000000", + "shares_dst": "200000000.000000000000000000" + }, + "balance": "200000000" + } + ] + } + ], + "pagination": null +} +``` + +#### DelegatorUnbondingDelegations + +The `DelegatorUnbondingDelegations` REST endpoint queries all unbonding delegations of a given delegator address. + +```bash +/cosmos/staking/v1beta1/delegators/{delegatorAddr}/unbonding_delegations +``` + +Example: + +```bash +curl -X GET \ +"http://localhost:1317/cosmos/staking/v1beta1/delegators/cosmos1nxv42u3lv642q0fuzu2qmrku27zgut3n3z7lll/unbonding_delegations" \ +-H "accept: application/json" +``` + +Example Output: + +```bash +{ + "unbonding_responses": [ + { + "delegator_address": "cosmos1nxv42u3lv642q0fuzu2qmrku27zgut3n3z7lll", + "validator_address": "cosmosvaloper1e7mvqlz50ch6gw4yjfemsc069wfre4qwmw53kq", + "entries": [ + { + "creation_height": "2442278", + "completion_time": "2021-10-12T10:59:03.797335857Z", + "initial_balance": "50000000000", + "balance": "50000000000" + } + ] + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +#### DelegatorValidators + +The `DelegatorValidators` REST endpoint queries all validators information for given delegator address. + +```bash +/cosmos/staking/v1beta1/delegators/{delegatorAddr}/validators +``` + +Example: + +```bash +curl -X GET \ +"http://localhost:1317/cosmos/staking/v1beta1/delegators/cosmos1xwazl8ftks4gn00y5x3c47auquc62ssune9ppv/validators" \ +-H "accept: application/json" +``` + +Example Output: + +```bash +{ + "validators": [ + { + "operator_address": "cosmosvaloper1xwazl8ftks4gn00y5x3c47auquc62ssuvynw64", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "5v4n3px3PkfNnKflSgepDnsMQR1hiNXnqOC11Y72/PQ=" + }, + "jailed": false, + "status": "BOND_STATUS_BONDED", + "tokens": "21592843799", + "delegator_shares": "21592843799.000000000000000000", + "description": { + "moniker": "jabbey", + "identity": "", + "website": "https://twitter.com/JoeAbbey", + "security_contact": "", + "details": "just another dad in the cosmos" + }, + "unbonding_height": "0", + "unbonding_time": "1970-01-01T00:00:00Z", + "commission": { + "commission_rates": { + "rate": "0.100000000000000000", + "max_rate": "0.200000000000000000", + "max_change_rate": "0.100000000000000000" + }, + "update_time": "2021-10-09T19:03:54.984821705Z" + }, + "min_self_delegation": "1" + } + ], + "pagination": { + "next_key": null, + "total": "1" + } +} +``` + +#### DelegatorValidator + +The `DelegatorValidator` REST endpoint queries validator information for given delegator validator pair. + +```bash +/cosmos/staking/v1beta1/delegators/{delegatorAddr}/validators/{validatorAddr} +``` + +Example: + +```bash +curl -X GET \ +"http://localhost:1317/cosmos/staking/v1beta1/delegators/cosmos1xwazl8ftks4gn00y5x3c47auquc62ssune9ppv/validators/cosmosvaloper1xwazl8ftks4gn00y5x3c47auquc62ssuvynw64" \ +-H "accept: application/json" +``` + +Example Output: + +```bash +{ + "validator": { + "operator_address": "cosmosvaloper1xwazl8ftks4gn00y5x3c47auquc62ssuvynw64", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "5v4n3px3PkfNnKflSgepDnsMQR1hiNXnqOC11Y72/PQ=" + }, + "jailed": false, + "status": "BOND_STATUS_BONDED", + "tokens": "21592843799", + "delegator_shares": "21592843799.000000000000000000", + "description": { + "moniker": "jabbey", + "identity": "", + "website": "https://twitter.com/JoeAbbey", + "security_contact": "", + "details": "just another dad in the cosmos" + }, + "unbonding_height": "0", + "unbonding_time": "1970-01-01T00:00:00Z", + "commission": { + "commission_rates": { + "rate": "0.100000000000000000", + "max_rate": "0.200000000000000000", + "max_change_rate": "0.100000000000000000" + }, + "update_time": "2021-10-09T19:03:54.984821705Z" + }, + "min_self_delegation": "1" + } +} +``` + +#### HistoricalInfo + +The `HistoricalInfo` REST endpoint queries the historical information for given height. + +```bash +/cosmos/staking/v1beta1/historical_info/{height} +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/staking/v1beta1/historical_info/153332" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "hist": { + "header": { + "version": { + "block": "11", + "app": "0" + }, + "chain_id": "cosmos-1", + "height": "153332", + "time": "2021-10-12T09:05:35.062230221Z", + "last_block_id": { + "hash": "NX8HevR5khb7H6NGKva+jVz7cyf0skF1CrcY9A0s+d8=", + "part_set_header": { + "total": 1, + "hash": "zLQ2FiKM5tooL3BInt+VVfgzjlBXfq0Hc8Iux/xrhdg=" + } + }, + "last_commit_hash": "P6IJrK8vSqU3dGEyRHnAFocoDGja0bn9euLuy09s350=", + "data_hash": "eUd+6acHWrNXYju8Js449RJ99lOYOs16KpqQl4SMrEM=", + "validators_hash": "mB4pravvMsJKgi+g8aYdSeNlt0kPjnRFyvtAQtaxcfw=", + "next_validators_hash": "mB4pravvMsJKgi+g8aYdSeNlt0kPjnRFyvtAQtaxcfw=", + "consensus_hash": "BICRvH3cKD93v7+R1zxE2ljD34qcvIZ0Bdi389qtoi8=", + "app_hash": "fuELArKRK+CptnZ8tu54h6xEleSWenHNmqC84W866fU=", + "last_results_hash": "p/BPexV4LxAzlVcPRvW+lomgXb6Yze8YLIQUo/4Kdgc=", + "evidence_hash": "47DEQpj8HBSa+/TImW+5JCeuQeRkm5NMpJWZG3hSuFU=", + "proposer_address": "G0MeY8xQx7ooOsni8KE/3R/Ib3Q=" + }, + "valset": [ + { + "operator_address": "cosmosvaloper196ax4vc0lwpxndu9dyhvca7jhxp70rmcqcnylw", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "/O7BtNW0pafwfvomgR4ZnfldwPXiFfJs9mHg3gwfv5Q=" + }, + "jailed": false, + "status": "BOND_STATUS_BONDED", + "tokens": "1416521659632", + "delegator_shares": "1416521659632.000000000000000000", + "description": { + "moniker": "SG-1", + "identity": "48608633F99D1B60", + "website": "https://sg-1.online", + "security_contact": "", + "details": "SG-1 - your favorite validator on cosmos. We offer 100% Soft Slash protection." + }, + "unbonding_height": "0", + "unbonding_time": "1970-01-01T00:00:00Z", + "commission": { + "commission_rates": { + "rate": "0.037500000000000000", + "max_rate": "0.200000000000000000", + "max_change_rate": "0.030000000000000000" + }, + "update_time": "2021-10-01T15:00:00Z" + }, + "min_self_delegation": "1" + }, + { + "operator_address": "cosmosvaloper1t8ehvswxjfn3ejzkjtntcyrqwvmvuknzmvtaaa", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "uExZyjNLtr2+FFIhNDAMcQ8+yTrqE7ygYTsI7khkA5Y=" + }, + "jailed": false, + "status": "BOND_STATUS_BONDED", + "tokens": "1348298958808", + "delegator_shares": "1348298958808.000000000000000000", + "description": { + "moniker": "Cosmostation", + "identity": "AE4C403A6E7AA1AC", + "website": "https://www.cosmostation.io", + "security_contact": "admin@stamper.network", + "details": "Cosmostation validator node. Delegate your tokens and Start Earning Staking Rewards" + }, + "unbonding_height": "0", + "unbonding_time": "1970-01-01T00:00:00Z", + "commission": { + "commission_rates": { + "rate": "0.050000000000000000", + "max_rate": "1.000000000000000000", + "max_change_rate": "0.200000000000000000" + }, + "update_time": "2021-10-01T15:06:38.821314287Z" + }, + "min_self_delegation": "1" + } + ] + } +} +``` + +#### Parameters + +The `Parameters` REST endpoint queries the staking parameters. + +```bash +/cosmos/staking/v1beta1/params +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/staking/v1beta1/params" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "params": { + "unbonding_time": "2419200s", + "max_validators": 100, + "max_entries": 7, + "historical_entries": 10000, + "bond_denom": "stake" + } +} +``` + +#### Pool + +The `Pool` REST endpoint queries the pool information. + +```bash +/cosmos/staking/v1beta1/pool +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/staking/v1beta1/pool" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "pool": { + "not_bonded_tokens": "432805737458", + "bonded_tokens": "15783637712645" + } +} +``` + +#### Validators + +The `Validators` REST endpoint queries all validators that match the given status. + +```bash +/cosmos/staking/v1beta1/validators +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/staking/v1beta1/validators" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "validators": [ + { + "operator_address": "cosmosvaloper1q3jsx9dpfhtyqqgetwpe5tmk8f0ms5qywje8tw", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "N7BPyek2aKuNZ0N/8YsrqSDhGZmgVaYUBuddY8pwKaE=" + }, + "jailed": false, + "status": "BOND_STATUS_BONDED", + "tokens": "383301887799", + "delegator_shares": "383301887799.000000000000000000", + "description": { + "moniker": "SmartNodes", + "identity": "D372724899D1EDC8", + "website": "https://smartnodes.co", + "security_contact": "", + "details": "Earn Rewards with Crypto Staking & Node Deployment" + }, + "unbonding_height": "0", + "unbonding_time": "1970-01-01T00:00:00Z", + "commission": { + "commission_rates": { + "rate": "0.050000000000000000", + "max_rate": "0.200000000000000000", + "max_change_rate": "0.100000000000000000" + }, + "update_time": "2021-10-01T15:51:31.596618510Z" + }, + "min_self_delegation": "1" + }, + { + "operator_address": "cosmosvaloper1q5ku90atkhktze83j9xjaks2p7uruag5zp6wt7", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "GDNpuKDmCg9GnhnsiU4fCWktuGUemjNfvpCZiqoRIYA=" + }, + "jailed": false, + "status": "BOND_STATUS_UNBONDING", + "tokens": "1017819654", + "delegator_shares": "1017819654.000000000000000000", + "description": { + "moniker": "Noderunners", + "identity": "812E82D12FEA3493", + "website": "http://noderunners.biz", + "security_contact": "info@noderunners.biz", + "details": "Noderunners is a professional validator in POS networks. We have a huge node running experience, reliable soft and hardware. Our commissions are always low, our support to delegators is always full. Stake with us and start receiving your cosmos rewards now!" + }, + "unbonding_height": "147302", + "unbonding_time": "2021-11-08T22:58:53.718662452Z", + "commission": { + "commission_rates": { + "rate": "0.050000000000000000", + "max_rate": "0.200000000000000000", + "max_change_rate": "0.100000000000000000" + }, + "update_time": "2021-10-04T18:02:21.446645619Z" + }, + "min_self_delegation": "1" + } + ], + "pagination": { + "next_key": "FONDBFkE4tEEf7yxWWKOD49jC2NK", + "total": "2" + } +} +``` + +#### Validator + +The `Validator` REST endpoint queries validator information for given validator address. + +```bash +/cosmos/staking/v1beta1/validators/{validatorAddr} +``` + +Example: + +```bash +curl -X GET \ +"http://localhost:1317/cosmos/staking/v1beta1/validators/cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q" \ +-H "accept: application/json" +``` + +Example Output: + +```bash +{ + "validator": { + "operator_address": "cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q", + "consensus_pubkey": { + "@type": "/cosmos.crypto.ed25519.PubKey", + "key": "sIiexdJdYWn27+7iUHQJDnkp63gq/rzUq1Y+fxoGjXc=" + }, + "jailed": false, + "status": "BOND_STATUS_BONDED", + "tokens": "33027900000", + "delegator_shares": "33027900000.000000000000000000", + "description": { + "moniker": "Witval", + "identity": "51468B615127273A", + "website": "", + "security_contact": "", + "details": "Witval is the validator arm from Vitwit. Vitwit is into software consulting and services business since 2015. We are working closely with Cosmos ecosystem since 2018. We are also building tools for the ecosystem, Aneka is our explorer for the cosmos ecosystem." + }, + "unbonding_height": "0", + "unbonding_time": "1970-01-01T00:00:00Z", + "commission": { + "commission_rates": { + "rate": "0.050000000000000000", + "max_rate": "0.200000000000000000", + "max_change_rate": "0.020000000000000000" + }, + "update_time": "2021-10-01T19:24:52.663191049Z" + }, + "min_self_delegation": "1" + } +} +``` + +#### ValidatorDelegations + +The `ValidatorDelegations` REST endpoint queries delegate information for given validator. + +```bash +/cosmos/staking/v1beta1/validators/{validatorAddr}/delegations +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/staking/v1beta1/validators/cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q/delegations" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "delegation_responses": [ + { + "delegation": { + "delegator_address": "cosmos190g5j8aszqhvtg7cprmev8xcxs6csra7xnk3n3", + "validator_address": "cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q", + "shares": "31000000000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "31000000000" + } + }, + { + "delegation": { + "delegator_address": "cosmos1ddle9tczl87gsvmeva3c48nenyng4n56qwq4ee", + "validator_address": "cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q", + "shares": "628470000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "628470000" + } + }, + { + "delegation": { + "delegator_address": "cosmos10fdvkczl76m040smd33lh9xn9j0cf26kk4s2nw", + "validator_address": "cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q", + "shares": "838120000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "838120000" + } + }, + { + "delegation": { + "delegator_address": "cosmos1n8f5fknsv2yt7a8u6nrx30zqy7lu9jfm0t5lq8", + "validator_address": "cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q", + "shares": "500000000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "500000000" + } + }, + { + "delegation": { + "delegator_address": "cosmos16msryt3fqlxtvsy8u5ay7wv2p8mglfg9hrek2e", + "validator_address": "cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q", + "shares": "61310000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "61310000" + } + } + ], + "pagination": { + "next_key": null, + "total": "5" + } +} +``` + +#### Delegation + +The `Delegation` REST endpoint queries delegate information for given validator delegator pair. + +```bash +/cosmos/staking/v1beta1/validators/{validatorAddr}/delegations/{delegatorAddr} +``` + +Example: + +```bash +curl -X GET \ +"http://localhost:1317/cosmos/staking/v1beta1/validators/cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q/delegations/cosmos1n8f5fknsv2yt7a8u6nrx30zqy7lu9jfm0t5lq8" \ +-H "accept: application/json" +``` + +Example Output: + +```bash +{ + "delegation_response": { + "delegation": { + "delegator_address": "cosmos1n8f5fknsv2yt7a8u6nrx30zqy7lu9jfm0t5lq8", + "validator_address": "cosmosvaloper16msryt3fqlxtvsy8u5ay7wv2p8mglfg9g70e3q", + "shares": "500000000.000000000000000000" + }, + "balance": { + "denom": "stake", + "amount": "500000000" + } + } +} +``` + +#### UnbondingDelegation + +The `UnbondingDelegation` REST endpoint queries unbonding information for given validator delegator pair. + +```bash +/cosmos/staking/v1beta1/validators/{validatorAddr}/delegations/{delegatorAddr}/unbonding_delegation +``` + +Example: + +```bash +curl -X GET \ +"http://localhost:1317/cosmos/staking/v1beta1/validators/cosmosvaloper13v4spsah85ps4vtrw07vzea37gq5la5gktlkeu/delegations/cosmos1ze2ye5u5k3qdlexvt2e0nn0508p04094ya0qpm/unbonding_delegation" \ +-H "accept: application/json" +``` + +Example Output: + +```bash +{ + "unbond": { + "delegator_address": "cosmos1ze2ye5u5k3qdlexvt2e0nn0508p04094ya0qpm", + "validator_address": "cosmosvaloper13v4spsah85ps4vtrw07vzea37gq5la5gktlkeu", + "entries": [ + { + "creation_height": "153687", + "completion_time": "2021-11-09T09:41:18.352401903Z", + "initial_balance": "525111", + "balance": "525111" + } + ] + } +} +``` + +#### ValidatorUnbondingDelegations + +The `ValidatorUnbondingDelegations` REST endpoint queries unbonding delegations of a validator. + +```bash +/cosmos/staking/v1beta1/validators/{validatorAddr}/unbonding_delegations +``` + +Example: + +```bash +curl -X GET \ +"http://localhost:1317/cosmos/staking/v1beta1/validators/cosmosvaloper13v4spsah85ps4vtrw07vzea37gq5la5gktlkeu/unbonding_delegations" \ +-H "accept: application/json" +``` + +Example Output: + +```bash +{ + "unbonding_responses": [ + { + "delegator_address": "cosmos1q9snn84jfrd9ge8t46kdcggpe58dua82vnj7uy", + "validator_address": "cosmosvaloper13v4spsah85ps4vtrw07vzea37gq5la5gktlkeu", + "entries": [ + { + "creation_height": "90998", + "completion_time": "2021-11-05T00:14:37.005841058Z", + "initial_balance": "24000000", + "balance": "24000000" + } + ] + }, + { + "delegator_address": "cosmos1qf36e6wmq9h4twhdvs6pyq9qcaeu7ye0s3dqq2", + "validator_address": "cosmosvaloper13v4spsah85ps4vtrw07vzea37gq5la5gktlkeu", + "entries": [ + { + "creation_height": "47478", + "completion_time": "2021-11-01T22:47:26.714116854Z", + "initial_balance": "8000000", + "balance": "8000000" + } + ] + } + ], + "pagination": { + "next_key": null, + "total": "2" + } +} +``` diff --git a/.gitbook/developers/modules/core/upgrade/README.md b/.gitbook/developers/modules/core/upgrade/README.md new file mode 100644 index 00000000..0d98c160 --- /dev/null +++ b/.gitbook/developers/modules/core/upgrade/README.md @@ -0,0 +1,619 @@ +--- +sidebar_position: 1 +--- + +# `x/upgrade` + +## Abstract + +`x/upgrade` is an implementation of a Cosmos SDK module that facilitates smoothly +upgrading a live Cosmos chain to a new (breaking) software version. It accomplishes this by +providing a `PreBlocker` hook that prevents the blockchain state machine from +proceeding once a pre-defined upgrade block height has been reached. + +The module does not prescribe anything regarding how governance decides to do an +upgrade, but just the mechanism for coordinating the upgrade safely. Without software +support for upgrades, upgrading a live chain is risky because all of the validators +need to pause their state machines at exactly the same point in the process. If +this is not done correctly, there can be state inconsistencies which are hard to +recover from. + +* [Concepts](#concepts) +* [State](#state) +* [Events](#events) +* [Client](#client) + * [CLI](#cli) + * [REST](#rest) + * [gRPC](#grpc) +* [Resources](#resources) + +## Concepts + +### Plan + +The `x/upgrade` module defines a `Plan` type in which a live upgrade is scheduled +to occur. A `Plan` can be scheduled at a specific block height. +A `Plan` is created once a (frozen) release candidate along with an appropriate upgrade +`Handler` (see below) is agreed upon, where the `Name` of a `Plan` corresponds to a +specific `Handler`. Typically, a `Plan` is created through a governance proposal +process, where if voted upon and passed, will be scheduled. The `Info` of a `Plan` +may contain various metadata about the upgrade, typically application specific +upgrade info to be included on-chain such as a git commit that validators could +automatically upgrade to. + +```go +type Plan struct { + Name string + Height int64 + Info string +} +``` + +#### Sidecar Process + +If an operator running the application binary also runs a sidecar process to assist +in the automatic download and upgrade of a binary, the `Info` allows this process to +be seamless. This tool is [Cosmovisor](https://github.com/cosmos/cosmos-sdk/tree/main/tools/cosmovisor#readme). + +### Handler + +The `x/upgrade` module facilitates upgrading from major version X to major version Y. To +accomplish this, node operators must first upgrade their current binary to a new +binary that has a corresponding `Handler` for the new version Y. It is assumed that +this version has fully been tested and approved by the community at large. This +`Handler` defines what state migrations need to occur before the new binary Y +can successfully run the chain. Naturally, this `Handler` is application specific +and not defined on a per-module basis. Registering a `Handler` is done via +`Keeper#SetUpgradeHandler` in the application. + +```go +type UpgradeHandler func(Context, Plan, VersionMap) (VersionMap, error) +``` + +During each `EndBlock` execution, the `x/upgrade` module checks if there exists a +`Plan` that should execute (is scheduled at that height). If so, the corresponding +`Handler` is executed. If the `Plan` is expected to execute but no `Handler` is registered +or if the binary was upgraded too early, the node will gracefully panic and exit. + +### StoreLoader + +The `x/upgrade` module also facilitates store migrations as part of the upgrade. The +`StoreLoader` sets the migrations that need to occur before the new binary can +successfully run the chain. This `StoreLoader` is also application specific and +not defined on a per-module basis. Registering this `StoreLoader` is done via +`app#SetStoreLoader` in the application. + +```go +func UpgradeStoreLoader (upgradeHeight int64, storeUpgrades *store.StoreUpgrades) baseapp.StoreLoader +``` + +If there's a planned upgrade and the upgrade height is reached, the old binary writes `Plan` to the disk before panicking. + +This information is critical to ensure the `StoreUpgrades` happens smoothly at correct height and +expected upgrade. It eliminiates the chances for the new binary to execute `StoreUpgrades` multiple +times everytime on restart. Also if there are multiple upgrades planned on same height, the `Name` +will ensure these `StoreUpgrades` takes place only in planned upgrade handler. + +### Proposal + +Typically, a `Plan` is proposed and submitted through governance via a proposal +containing a `MsgSoftwareUpgrade` message. +This proposal prescribes to the standard governance process. If the proposal passes, +the `Plan`, which targets a specific `Handler`, is persisted and scheduled. The +upgrade can be delayed or hastened by updating the `Plan.Height` in a new proposal. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/upgrade/v1beta1/tx.proto#L29-L41 +``` + +#### Cancelling Upgrade Proposals + +Upgrade proposals can be cancelled. There exists a gov-enabled `MsgCancelUpgrade` +message type, which can be embedded in a proposal, voted on and, if passed, will +remove the scheduled upgrade `Plan`. +Of course this requires that the upgrade was known to be a bad idea well before the +upgrade itself, to allow time for a vote. + +```protobuf reference +https://github.com/cosmos/cosmos-sdk/blob/v0.47.0-rc1/proto/cosmos/upgrade/v1beta1/tx.proto#L48-L57 +``` + +If such a possibility is desired, the upgrade height is to be +`2 * (VotingPeriod + DepositPeriod) + (SafetyDelta)` from the beginning of the +upgrade proposal. The `SafetyDelta` is the time available from the success of an +upgrade proposal and the realization it was a bad idea (due to external social consensus). + +A `MsgCancelUpgrade` proposal can also be made while the original +`MsgSoftwareUpgrade` proposal is still being voted upon, as long as the `VotingPeriod` +ends after the `MsgSoftwareUpgrade` proposal. + +## State + +The internal state of the `x/upgrade` module is relatively minimal and simple. The +state contains the currently active upgrade `Plan` (if one exists) by key +`0x0` and if a `Plan` is marked as "done" by key `0x1`. The state +contains the consensus versions of all app modules in the application. The versions +are stored as big endian `uint64`, and can be accessed with prefix `0x2` appended +by the corresponding module name of type `string`. The state maintains a +`Protocol Version` which can be accessed by key `0x3`. + +* Plan: `0x0 -> Plan` +* Done: `0x1 | byte(plan name) -> BigEndian(Block Height)` +* ConsensusVersion: `0x2 | byte(module name) -> BigEndian(Module Consensus Version)` +* ProtocolVersion: `0x3 -> BigEndian(Protocol Version)` + +The `x/upgrade` module contains no genesis state. + +## Events + +The `x/upgrade` does not emit any events by itself. Any and all proposal related +events are emitted through the `x/gov` module. + +## Client + +### CLI + +A user can query and interact with the `upgrade` module using the CLI. + +#### Query + +The `query` commands allow users to query `upgrade` state. + +```bash +simd query upgrade --help +``` + +##### applied + +The `applied` command allows users to query the block header for height at which a completed upgrade was applied. + +```bash +simd query upgrade applied [upgrade-name] [flags] +``` + +If upgrade-name was previously executed on the chain, this returns the header for the block at which it was applied. +This helps a client determine which binary was valid over a given range of blocks, as well as more context to understand past migrations. + +Example: + +```bash +simd query upgrade applied "test-upgrade" +``` + +Example Output: + +```bash +"block_id": { + "hash": "A769136351786B9034A5F196DC53F7E50FCEB53B48FA0786E1BFC45A0BB646B5", + "parts": { + "total": 1, + "hash": "B13CBD23011C7480E6F11BE4594EE316548648E6A666B3575409F8F16EC6939E" + } + }, + "block_size": "7213", + "header": { + "version": { + "block": "11" + }, + "chain_id": "testnet-2", + "height": "455200", + "time": "2021-04-10T04:37:57.085493838Z", + "last_block_id": { + "hash": "0E8AD9309C2DC411DF98217AF59E044A0E1CCEAE7C0338417A70338DF50F4783", + "parts": { + "total": 1, + "hash": "8FE572A48CD10BC2CBB02653CA04CA247A0F6830FF19DC972F64D339A355E77D" + } + }, + "last_commit_hash": "DE890239416A19E6164C2076B837CC1D7F7822FC214F305616725F11D2533140", + "data_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855", + "validators_hash": "A31047ADE54AE9072EE2A12FF260A8990BA4C39F903EAF5636B50D58DBA72582", + "next_validators_hash": "A31047ADE54AE9072EE2A12FF260A8990BA4C39F903EAF5636B50D58DBA72582", + "consensus_hash": "048091BC7DDC283F77BFBF91D73C44DA58C3DF8A9CBC867405D8B7F3DAADA22F", + "app_hash": "28ECC486AFC332BA6CC976706DBDE87E7D32441375E3F10FD084CD4BAF0DA021", + "last_results_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855", + "evidence_hash": "E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855", + "proposer_address": "2ABC4854B1A1C5AA8403C4EA853A81ACA901CC76" + }, + "num_txs": "0" +} +``` + +##### module versions + +The `module_versions` command gets a list of module names and their respective consensus versions. + +Following the command with a specific module name will return only +that module's information. + +```bash +simd query upgrade module_versions [optional module_name] [flags] +``` + +Example: + +```bash +simd query upgrade module_versions +``` + +Example Output: + +```bash +module_versions: +- name: auth + version: "2" +- name: authz + version: "1" +- name: bank + version: "2" +- name: crisis + version: "1" +- name: distribution + version: "2" +- name: evidence + version: "1" +- name: feegrant + version: "1" +- name: genutil + version: "1" +- name: gov + version: "2" +- name: ibc + version: "2" +- name: mint + version: "1" +- name: params + version: "1" +- name: slashing + version: "2" +- name: staking + version: "2" +- name: transfer + version: "1" +- name: upgrade + version: "1" +- name: vesting + version: "1" +``` + +Example: + +```bash +regen query upgrade module_versions ibc +``` + +Example Output: + +```bash +module_versions: +- name: ibc + version: "2" +``` + +##### plan + +The `plan` command gets the currently scheduled upgrade plan, if one exists. + +```bash +regen query upgrade plan [flags] +``` + +Example: + +```bash +simd query upgrade plan +``` + +Example Output: + +```bash +height: "130" +info: "" +name: test-upgrade +time: "0001-01-01T00:00:00Z" +upgraded_client_state: null +``` + +#### Transactions + +The upgrade module supports the following transactions: + +* `software-proposal` - submits an upgrade proposal: + +```bash +simd tx upgrade software-upgrade v2 --title="Test Proposal" --summary="testing" --deposit="100000000stake" --upgrade-height 1000000 \ +--upgrade-info '{ "binaries": { "linux/amd64":"https://example.com/simd.zip?checksum=sha256:aec070645fe53ee3b3763059376134f058cc337247c978add178b6ccdfb0019f" } }' --from cosmos1.. +``` + +* `cancel-software-upgrade` - cancels a previously submitted upgrade proposal: + +```bash +simd tx upgrade cancel-software-upgrade --title="Test Proposal" --summary="testing" --deposit="100000000stake" --from cosmos1.. +``` + +### REST + +A user can query the `upgrade` module using REST endpoints. + +#### Applied Plan + +`AppliedPlan` queries a previously applied upgrade plan by its name. + +```bash +/cosmos/upgrade/v1beta1/applied_plan/{name} +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/upgrade/v1beta1/applied_plan/v2.0-upgrade" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "height": "30" +} +``` + +#### Current Plan + +`CurrentPlan` queries the current upgrade plan. + +```bash +/cosmos/upgrade/v1beta1/current_plan +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/upgrade/v1beta1/current_plan" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "plan": "v2.1-upgrade" +} +``` + +#### Module versions + +`ModuleVersions` queries the list of module versions from state. + +```bash +/cosmos/upgrade/v1beta1/module_versions +``` + +Example: + +```bash +curl -X GET "http://localhost:1317/cosmos/upgrade/v1beta1/module_versions" -H "accept: application/json" +``` + +Example Output: + +```bash +{ + "module_versions": [ + { + "name": "auth", + "version": "2" + }, + { + "name": "authz", + "version": "1" + }, + { + "name": "bank", + "version": "2" + }, + { + "name": "crisis", + "version": "1" + }, + { + "name": "distribution", + "version": "2" + }, + { + "name": "evidence", + "version": "1" + }, + { + "name": "feegrant", + "version": "1" + }, + { + "name": "genutil", + "version": "1" + }, + { + "name": "gov", + "version": "2" + }, + { + "name": "ibc", + "version": "2" + }, + { + "name": "mint", + "version": "1" + }, + { + "name": "params", + "version": "1" + }, + { + "name": "slashing", + "version": "2" + }, + { + "name": "staking", + "version": "2" + }, + { + "name": "transfer", + "version": "1" + }, + { + "name": "upgrade", + "version": "1" + }, + { + "name": "vesting", + "version": "1" + } + ] +} +``` + +### gRPC + +A user can query the `upgrade` module using gRPC endpoints. + +#### Applied Plan + +`AppliedPlan` queries a previously applied upgrade plan by its name. + +```bash +cosmos.upgrade.v1beta1.Query/AppliedPlan +``` + +Example: + +```bash +grpcurl -plaintext \ + -d '{"name":"v2.0-upgrade"}' \ + localhost:9090 \ + cosmos.upgrade.v1beta1.Query/AppliedPlan +``` + +Example Output: + +```bash +{ + "height": "30" +} +``` + +#### Current Plan + +`CurrentPlan` queries the current upgrade plan. + +```bash +cosmos.upgrade.v1beta1.Query/CurrentPlan +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 cosmos.slashing.v1beta1.Query/CurrentPlan +``` + +Example Output: + +```bash +{ + "plan": "v2.1-upgrade" +} +``` + +#### Module versions + +`ModuleVersions` queries the list of module versions from state. + +```bash +cosmos.upgrade.v1beta1.Query/ModuleVersions +``` + +Example: + +```bash +grpcurl -plaintext localhost:9090 cosmos.slashing.v1beta1.Query/ModuleVersions +``` + +Example Output: + +```bash +{ + "module_versions": [ + { + "name": "auth", + "version": "2" + }, + { + "name": "authz", + "version": "1" + }, + { + "name": "bank", + "version": "2" + }, + { + "name": "crisis", + "version": "1" + }, + { + "name": "distribution", + "version": "2" + }, + { + "name": "evidence", + "version": "1" + }, + { + "name": "feegrant", + "version": "1" + }, + { + "name": "genutil", + "version": "1" + }, + { + "name": "gov", + "version": "2" + }, + { + "name": "ibc", + "version": "2" + }, + { + "name": "mint", + "version": "1" + }, + { + "name": "params", + "version": "1" + }, + { + "name": "slashing", + "version": "2" + }, + { + "name": "staking", + "version": "2" + }, + { + "name": "transfer", + "version": "1" + }, + { + "name": "upgrade", + "version": "1" + }, + { + "name": "vesting", + "version": "1" + } + ] +} +``` + +## Resources + +A list of (external) resources to learn more about the `x/upgrade` module. + +* [Cosmos Dev Series: Cosmos Blockchain Upgrade](https://medium.com/web3-surfers/cosmos-dev-series-cosmos-sdk-based-blockchain-upgrade-b5e99181554c) - The blog post that explains how software upgrades work in detail. diff --git a/.gitbook/developers/modules/injective/README.md b/.gitbook/developers/modules/injective/README.md new file mode 100644 index 00000000..8a5fa20d --- /dev/null +++ b/.gitbook/developers/modules/injective/README.md @@ -0,0 +1,14 @@ +import { + HomepageSection as Section +} from "../../../../src/components/HomepageComponents"; +import ComponentsGrid from "@theme/DocCardList"; + +# Injective Modules + +
+ +
diff --git a/.gitbook/developers/modules/injective/auction/01_state.md b/.gitbook/developers/modules/injective/auction/01_state.md new file mode 100644 index 00000000..ecb09d89 --- /dev/null +++ b/.gitbook/developers/modules/injective/auction/01_state.md @@ -0,0 +1,60 @@ +--- +sidebar_position: 1 +title: State +--- + +# State + +## Params + +Params is a module-wide configuration structure that stores system parameters and defines overall functioning of the auction module. + +- Params: `Paramsspace("auction") -> legacy_amino(params)` + +```go +type Params struct { + // auction_period_duration defines the auction period duration + AuctionPeriod int64 + // min_next_bid_increment_rate defines the minimum increment rate for new bids + MinNextBidIncrementRate math.LegacyDec +} +``` + +### **LastBid** + +Keeps track of the current highest bid + +* LastBid: `0x01 -> ProtocolBuffer(Bid)` + +```go +type Bid struct { + Bidder string + Amount sdk.Coin +} +``` + +### **AuctionRound** + +The current auction round. + +* AuctionRound: `0x03 -> BigEndian(AuctionRound)` + +### **EndingTimeStamp** + +This value is compared against current block time to decide an auction round settlement. When the exported chain is imported again, the EndingTimeStamp will be updated to the next value in future. + +* `EndingTimeStamp`: `0x04 -> BigEndian(EndingTimestamp)` + +### **LastAuctionResult** + +Keeps track of the last auction result. + +* LastAuctionResult: `0x05 -> ProtocolBuffer(LastAuctionResult)` + +```go +type LastAuctionResult struct { + Winner string + Amount sdk.Coin + Round uint64 +} +``` diff --git a/.gitbook/developers/modules/injective/auction/02_messages.md b/.gitbook/developers/modules/injective/auction/02_messages.md new file mode 100644 index 00000000..97f7253f --- /dev/null +++ b/.gitbook/developers/modules/injective/auction/02_messages.md @@ -0,0 +1,32 @@ +--- +sidebar_position: 2 +title: Messages +--- + +# Messages + +In this section we describe the processing of the auction messages and the corresponding updates to the state. + +## Msg/Bid + +An auction basket from a given round is bid upon by using the `Msg/Bid` service message. + +```protobuf +// Bid defines a SDK message for placing a bid for an auction +message MsgBid { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + string sender = 1; + // amount of the bid in INJ tokens + cosmos.base.v1beta1.Coin bid_amount = 2 [(gogoproto.nullable) = false]; + // the current auction round being bid on + uint64 round = 3; +} +``` + +This service message is expected to fail if: + +- `Round` does not equal the current auction round +- `BidAmount` does not exceed the previous highest bid amount by at least `min_next_increment_rate` percent. + +This service message transfers the `BidAmount` of INJ from the `Sender` to the auction module, stores the bid, and refunds the last bidder's bid amount. diff --git a/.gitbook/developers/modules/injective/auction/03_end_block.md b/.gitbook/developers/modules/injective/auction/03_end_block.md new file mode 100644 index 00000000..88018bc3 --- /dev/null +++ b/.gitbook/developers/modules/injective/auction/03_end_block.md @@ -0,0 +1,21 @@ +--- +sidebar_position: 3 +title: End-Block +--- + +# End-Block + +### Auction Settlement + +The settlement of a given auction round occurs when `blockTime ≥ EndingTimeStamp.` If a non-zero INJ bid was placed during this period (i.e. there exists a `LastBid`), the following procedure will take place: + +- The winning INJ bid amount is burned. +- The basket of coins held by the auction module is transferred to the winning bidder. +- `LastAuctionResult` is written to state and `EventAuctionResult` is emitted. +- The `LastBid` is cleared. +- The AuctionRound is incremented by 1 and the EndingTimestamp is incremented by `AuctionPeriod`. +- The accumulated exchange fees are transferred from the `exchange` module to the `auction` module for the new upcoming auction. + +If the round closed without any successful bids, the existing coin basket will be rolled over into the next auction and combined with the new accumulated fee basket. + +![img.png](./img.png) \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/auction/04_events.md b/.gitbook/developers/modules/injective/auction/04_events.md new file mode 100644 index 00000000..ed87d2d7 --- /dev/null +++ b/.gitbook/developers/modules/injective/auction/04_events.md @@ -0,0 +1,28 @@ +--- +sidebar_position: 4 +title: Events +--- + +# Events + +The auction module emits the following events: + +## Handlers + +### Msg/Bid + +| Type | Attribute Key | Attribute Value | +| ---------------- | ------------- | ------------------ | +| EventBid | Bidder | | +| EventBid | Amount | | +| EventBid | Round | | + + +## EndBlocker + +| Type | Attribute Key | Attribute Value | +| --------------------- | --------------------- | ------------------------- | +| EventAuctionResult | Winner | +| EventAuctionResult | Amount | +| EventAuctionResult | Round | + diff --git a/.gitbook/developers/modules/injective/auction/05_params.md b/.gitbook/developers/modules/injective/auction/05_params.md new file mode 100644 index 00000000..2f56a4a4 --- /dev/null +++ b/.gitbook/developers/modules/injective/auction/05_params.md @@ -0,0 +1,14 @@ +--- +sidebar_position: 5 +title: Parameters +--- + +# Parameters + +The auction module contains the following parameters: + +| Key | Type | Example | +|-------------------|------------------|-------------------| +| AuctionPeriod | int64 | 604800 | +| MinNextBidIncrementRate | math.LegacyDec | "0.0025" | + diff --git a/.gitbook/developers/modules/injective/auction/README.md b/.gitbook/developers/modules/injective/auction/README.md new file mode 100644 index 00000000..55f22fdc --- /dev/null +++ b/.gitbook/developers/modules/injective/auction/README.md @@ -0,0 +1,15 @@ +# `Auction` + +## Abstract + +The `auction` module periodically obtains a basket of tokens accumulated from trading fees from the `exchange` module and auctions the basket to the highest bidder in an open English auction for INJ. The winner of this auction receives the basket of tokens and the winning INJ bid amount from this auction is burned. + +## Contents + +1. **[State](./01_state.md)** +2. **[Messages](./02_messages.md)** +3. **[End Block](./03_end_block.md)** +4. **[Events](./04_events.md)** +5. **[Params](./05_params.md)** + + diff --git a/.gitbook/developers/modules/injective/auction/img.png b/.gitbook/developers/modules/injective/auction/img.png new file mode 100644 index 0000000000000000000000000000000000000000..10dad042969149ce92eca68ad79bff67b6a6212f GIT binary patch literal 198989 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 z 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 Quantity * (InitialMarginRatio * MarkPrice - PNL)` + +PNL is the expected profit and loss of the position if it was closed at the current MarkPrice. Solved for MarkPrice this results in: + +- For Buys: $\mathrm{MarkPrice}$ ≥ $\mathrm{\frac{Margin - Price * Quantity}{(InitialMarginRatio - 1) * Quantity}}$ +- For Sells: $\mathrm{MarkPrice}$ ≤ $\mathrm{\frac{Margin + Price * Quantity}{(InitialMarginRatio + 1) * Quantity}}$ + +**Maintenance Margin Requirement** + +Throughout the lifecycle of an active position, if the following margin requirement is not met, the position is subject +to liquidation. (Note: for simplicity of notation but without loss of generality, we assume the position considered does +not have any funding). + +- For Longs: `Margin >= Quantity * MaintenanceMarginRatio * MarkPrice - (MarkPrice - EntryPrice)` +- For Shorts: `Margin >= Quantity * MaintenanceMarginRatio * MarkPrice - (EntryPrice - MarkPrice)` + +**Liquidation Payouts** + +When your position falls below the maintenance margin ratio, the position can be liquidated by anyone. What happens on-chain is that automatically a reduce-only market order of the same size as the position is created. The market order will have a worst price defined as _Infinity_ or _0_, implying it will be matched at whatever prices are available in the order book. + +The payout from executing the reduce-only market order will not go towards the position owner. Instead, a part of the remaining funds are transferred to the liquidator bot and the other part is transferred to the insurance fund. The split is defined in the exchange params by `LiquidatorRewardShareRate`. If the payout in the position was negative, i.e., the position's negative PNL was greater than its margin, then the insurance fund will cover the missing funds. + +Also note that liquidations are executed immediately in a block before any other order matching occurs. + +### Funding Payments + +Funding exists only for perpetual markets as a mechanism to align trading prices with the mark price. It refers to the +periodic payments exchanged between the traders that are long or short of a contract at the end of every funding epoch, +e.g. every hour. When the funding rate is positive, longs pay shorts. When it is negative, shorts pay longs. + +- `Position Size = Position Quantity * MarkPrice` +- `Funding Payment = Position Size * Hourly Funding Rate (HFR)` +- `HFR = Cap((TWAP((SyntheticVWAPExecutionPrice - MarkPrice)/MarkPrice) + DailyInterestRate) * 1/24)` +- `SyntheticVWAPExecutionPrice = (Price_A*Volume_A +Price_B*Volume_B +Price_C*Volume_C)/(Volume_A + Volume_B + Volume_C)` + - `A` is the market buy batch execution + - `B` is the market sell batch execution + - `C` is the limit matching batch execution + +Funding payments are applied to the whole market by modifying the `CumulativeFunding` value. Each position stores the current `CumulativeFunding` as `CumulativeFundingEntry`. Subsequent funding payments are only applied upon position changes and can be calculated as: + +- FundingPayment + - For Longs: `FundingPayment ← PositionQuantity * (CumulativeFunding - CumulativeFundingEntry)` + - For Shorts: `FundingPayment ← PositionQuantity * (CumulativeFundingEntry - CumulativeFunding)` +- `Margin' ← Margin + FundingPayment` +- `CumulativeFundingEntry' ← CumulativeFunding` + +## Perpetual Market Trading Specification + +### Positions + +A trader's position records the conditions under which the trader has entered into the derivative contract and is +defined as follows + +- Position Definition: + - `Quantity` + - `EntryPrice` + - `Margin` + - `HoldQuantity` + - `CumulativeFundingEntry` + +As an example, consider the following position in the ETH/USDT market: + +- `Quantity` = -2 +- `EntryPrice` = 2200 +- `Margin` = 800 +- `HoldQuantity` = 1 +- `CumulativeFundingEntry` = 4838123 + +This position represents short exposure for 2 contracts of the ETH/USDT market collateralized with 800 USDT, with an +entry price of 2200. The `HoldQuantity` represents the quantity of the position that the trader has opposing orders for. +`CumulativeFundingEntry` represents the cumulative funding value that the position was last updated at. + +Position Netting: + +When a new vanilla order is matched for a subaccount with an existing position, the new position will be the result from +netting the existing position with the new vanilla order. A matched vanilla order produces a position delta defined by +`FillQuantity`, `FillMargin` and `ClearingPrice`. + +- Applying Position Delta to a position in the same direction: + - `Entry Price' ← (Quantity \* EntryPrice + FillQuantity \* ClearingPrice) / (Quantity + FillQuantity)` + - `Quantity' ← Quantity + FillQuantity` + - `Margin' ← Margin + FillMargin` +- Apply Position Delta to a position in the opposing direction: + - `Entry Price - no change` + - `Quantity' ← Quantity - FillQuantity` + - `Margin' ← Margin \* (Quantity - FillQuantity) / Quantity` + +### Limit Buy Order + +A limit buy order seeks to purchase a specified Quantity of a derivative contract at a specified Price by providing a +specified amount of margin as collateral. + +### Limit Sell Order + +A limit sell order seeks to sell a specified Quantity of a derivative contract at a specified Price by providing a +specified amount of margin as collateral. + +A matched position will have **subtracted fees** which depend on whether the limit order becomes executed as a +maker order or a taker order. + +### Market Buy Order + +A market buy order seeks to purchase a specified Quantity of a derivative contract at a specified worst price using +the subaccount's available balance as margin collateral. + +Handler and EndBlocker Execution of the market order are conceptually identical to the Limit Buy Order +(Immediately Matched case), since the trader passes the margin which implicitly sets a maximum price limit due to the +initial min margin requirements. + +### Market Sell Order + +A market sell order seeks to sell a specified Quantity of a derivative contract at a specified worst price using the +subaccount's available balance as margin collateral. + +Handler and EndBlocker Execution of the market order are conceptually identical to the Limit Sell Order +(Immediately Matched case), since the trader passes the margin which implicitly sets a minimum price limit due to the +initial min margin requirements. + +### Order Types + +- BUY (1): A standard buy order to purchase an asset at either the current market price or a set limit price. +- SELL (2): A standard sell order to sell an asset at either the current market price or a set limit price. +- STOP_BUY (3): A stop-buy order converts into a regular buy order once the oracle price reaches or surpasses a specified trigger price. +- STOP_SELL (4): A stop-sell order becomes a regular sell order once the oracle price drops to or below a specified trigger price. +- TAKE_BUY (5): A take-buy order converts into a regular buy order once the oracle price reaches or drops below a specified trigger price. +- TAKE_SELL (6):A stop-sell order becomes a regular sell order once the oracle price reaches or surpasses a specified trigger price. +- BUY_PO (7): Post-Only Buy. This order type ensures that the order will only be added to the order book and not match with a pre-existing order. It guarantees that you will be the market "maker" and not the "taker". +- SELL_PO (8): Post-Only Sell. Similar to BUY_PO, this ensures that your sell order will only add liquidity to the order book and not match with a pre-existing order. +- BUY_ATOMIC (9): An atomic buy order is a market order that gets executed instantly, bypassing the Frequent Batch Auctions (FBA). It's intended for smart contracts that need to execute a trade instantly. A higher fee is paid defined in the global exchange parameters. +- SELL_ATOMIC (10): An atomic sell order is similar to a BUY_ATOMIC, and it gets executed instantly at the current market price, bypassing the FBA. + +### Reduce-Only Orders (Selling Positions) + +### Limit Buy Reduce-Only Order + +A limit buy reduce-only order seeks to reduce existing long exposure by a specified `Quantity` ETH (**base currency**). +The payout for closing a position will have **subtracted fees**. + +### Limit Sell Reduce-Only Order + +A limit sell reduce-only order seeks to reduce existing short exposure by a specified `Quantity` ETH (**base currency**). +The payout for closing a position will have **subtracted fees**. diff --git a/.gitbook/developers/modules/injective/exchange/01_spot_market_concepts.md b/.gitbook/developers/modules/injective/exchange/01_spot_market_concepts.md new file mode 100644 index 00000000..6d413d33 --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/01_spot_market_concepts.md @@ -0,0 +1,135 @@ +--- +sidebar_position: 2 +title: Spot Market Concepts +--- + +# Spot Market Concepts + +## Definitions + +In a Spot Market with ticker **AAA/BBB, AAA is the base asset, BBB is the quote asset.** + +For example, in the ETH/USDT market + +- ETH is base asset +- USDT is the quote asset + +The spot market's **price** refers to how much USDT (the quote asset) is required for one unit of ETH (the base +asset). For all spot markets, **fees are always paid in the quote asset**, e.g., USDT. + +**Debit vs Credit** + +- **Debit Amount** refers to the amount of asset that is withdrawn from an account. +- **Credit Amount** refers to the amount of asset that is deposited to an account. + +**Refunds** + +In our system, a refund refers to the action of incrementing the **available balance** of an account. This liberation of +funds occurs as the result of an encumbrance being lifted from the account (e.g. cancelling a limit order, reducing an +order's payable fee to a maker fee, using less margin to fund a market order, etc.). + +### Limit Buy Order + +A limit buy order seeks to buy a specified `Quantity` ETH (**base asset**) in exchange for `Quantity * Price` amount of +USDT (**quote asset**) **plus fees** which depend on whether the limit order becomes executed as a maker order or a +taker order. + +### Limit Sell Order + +A limit sell order seeks to sell a specified `Quantity` ETH (**base asset**) in exchange for `Quantity * Price` amount +of USDT (**quote asset**) **minus fees** which depend on whether the limit order becomes executed as a maker order or a +taker order. + +### Market Buy Order + +A market buy order seeks to buy a specified `Quantity` ETH (**base asset**) at a specified worst price which is at or near +the current ask using the respective account quote asset balance (USDT) as collateral\*\* (inclusive of fees). + +As a result, each market buy order implicitly has a maximum acceptable price associated with it, as filling the market +order beyond that price would simply fail due to a lack of funds. + +### Market Sell Order + +A market sell order seeks to sell a specified `Quantity` ETH (**base asset**) at a specified worst price which is at or +near the current bid in exchange for any amount of the quote asset (USDT) available in the market. + +As a result, each market sell order implicitly has a zero price associated with it. + +### Order Types + +- BUY (1): A standard buy order to purchase an asset at either the current market price or a set limit price. +- SELL (2): A standard sell order to sell an asset at either the current market price or a set limit price. +- STOP_BUY (3): This order type is not supported for spot markets. +- STOP_SELL (4): This order type is not supported for spot markets. +- TAKE_BUY (5): This order type is not supported for spot markets. +- TAKE_SELL (6): This order type is not supported for spot markets. +- BUY_PO (7): Post-Only Buy. This order type ensures that the order will only be added to the order book and not match with a pre-existing order. It guarantees that you will be the market "maker" and not the "taker". +- SELL_PO (8): Post-Only Sell. Similar to BUY_PO, this ensures that your sell order will only add liquidity to the order book and not match with a pre-existing order. +- BUY_ATOMIC (9): An atomic buy order is a market order that gets executed instantly, bypassing the Frequent Batch Auctions (FBA). It's intended for smart contracts that need to execute a trade instantly. A higher fee is paid defined in the global exchange parameters. +- SELL_ATOMIC (10): An atomic sell order is similar to a BUY_ATOMIC, and it gets executed instantly at the current market price, bypassing the FBA. + +### Market Data Requirements + +Orderbook data aside, so long as our Chain supports the **base capability** to obtain Tick by Tick trading data, +aggregations can be applied to obtain most of the necessary higher order data, including + +- OHLCV data +- Account Trading History +- Market Statistics + +## Spot Market Lifecycle + +### Governance based Spot Market Creation + +A market is first created either by the instant launch functionality through `MsgInstantSpotMarketLaunch` which creates a market by paying an extra fee which doesn't require governance to approve it. Or it is created in the normal way through governance through `MsgSpotMarketLaunchProposal`. + +### Listing Fee based Spot Market Creation + +Allow anyone to create an active spot market of their choice without requiring governance approval by burning a pre-set +SpotMarketInstantListingFee of INJ. + +We should still check that the denom is valid though. + +### Spot Market Status Update + +A Spot Market can exist in four different states: + +1. Active +2. Paused +3. Suspended +4. Demolished + +#### **Active State** + +If a spot market is an active state, it can accept orders and trades. + +#### Paused State + +If a spot market is a paused state, it will no longer accept orders and trades and will also not allow any users to take +actions on that market (no order cancellations). + +#### Suspended State + +If a spot market is a suspended state, it will no longer accept orders and trades, and will only allow traders to cancel +their orders. + +## Demolished State + +When a market becomes demolished, all outstanding orders are cancelled. + +#### Market Status State Transitions + +There are three state transitions that correspond to the following status changes + +- Activate Action - **Paused or Suspended Status → Active Status** +- Pause Action - **Active or Suspended Status → Paused Status** +- Suspend Action - **Active or Paused Status → Suspended Status** +- Demolish Action - **Paused or Suspended Status → Demolished Status** + +### Spot Market Parameter Update + +The following parameters exist for Spot Markets + +- SpotMarketInstantListingFee +- DefaultSpotMakerFeeRate +- DefaultSpotTakerFeeRate diff --git a/.gitbook/developers/modules/injective/exchange/02_binary_options_markets.md b/.gitbook/developers/modules/injective/exchange/02_binary_options_markets.md new file mode 100644 index 00000000..8e9dc11f --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/02_binary_options_markets.md @@ -0,0 +1,115 @@ +--- +sidebar_position: 2 +title: Binary Options Markets +--- + +# Binary Options Markets + +## Concept + +Binary options markets don't have base asset as other markets do, and they are quoted in **USDT** (there is a possibility other quote assets will be added later). Tickers for binary options markets usually follow the scheme of **UFC-KHABIB-TKO-09082022** or similar. Typically, binary options markets are used for betting on sport events, but can also be used for betting on any outcome. All markets have possible price bands between $0.00 and $1.00 with users able to put in orders from $0.01 to $0.99. ($0.00 and $1.00 respectively show an end condition that the outcome did not occur or did). The price submitted in the order is essentially an assumed probability of the given event (market) occurring. + +For all binary options markets, **fees are always paid in the quote asset**, e.g., USDT. + +There is no leverage in these type of markets, as users trade against each other in a zero-sum market. From this the other requirement is implied: if one side of a bet believes the event will occur (YES side), and current market probability for this exact event is *P* (which means the current market price is *P*), opposing side of the bet should be certain that the event will not happen with *(1-P)* probability. Thus, if the person on YES side buys *Q* number of contracts with the price *P*, he locks *Q\*P* of his balance as his margin, while opposing NO side (seller side) should lock *Q\*(1-P)* of his quote balance as margin. + +**Example:** + +Alice buys 1 contract at $0.20 (margined with $0.20) against Bob who sells 1 contract at $0.20 (margined with $0.80), creating positions for both of them. + +- Alice wins $0.80 if the market settles at $1 and Bob wins $0.2 if the market settles at $0. + +## Oracle + +Binary options markets are tightly coupled to the Provider Oracle type, which allows a governance-registered provider to relay price feed data for arbitrary new price feeds under the provider's subtype without the need for extra governance for adding successively new price feeds. Each binary options market is comprised of the following oracle parameters: +* Oracle symbol (e.g. UFC-KHABIB-TKO-09082022) +* Oracle provider (e.g. frontrunner) +* Oracle type (required to be provider) +* Oracle scale factor (e.g. 6 if the quote denom is USDT) + +The main goal of the oracle is to post the final outcome of the event. This final price settles the market at that exact price. This price is expected to be equal to be 0 or 1 most of the time, reflective of the binary outcome. + +Moreover, the market could be settled at any price within the (0, 1) price band. In case the *settlement_price* posted by oracle is between 0 or 1, all positions will be closed at the *settlement_price* (e.g. 0.42). If the oracle price exceeds 1, the settlement price will be rounded down to 1. + +Oracle can also post the final price of **-1**, which is the flag price than triggers refunding of all positions in the current market and demolishes the market. If there is no oracle update ever prior to settlement, then an oracle price of -1 will be used by default to trigger the refunds of all positions. + +Further documentation on the oracle provider type can be found in the Oracle module documentation. + +### Registering an oracle provider + +To register your oracle provider, you need to submit a `GrantProviderPrivilegeProposal` governance proposal. This proposal will register your provider and will allow your address to relay price feeds. + +```go +type GrantProviderPrivilegeProposal struct { + Title string + Description string + Provider string // the name of the provider, should be specific to you + Relayers []string // addresses which will be able to relay prices +} +``` + +Once the proposal passes, your provider will be registered and you'll be able to relay your price feeds (example below). + +## Market Lifecycle + +### Market Creation +A binary options market can be created through an instant launch (through a `MsgInstantBinaryOptionsMarketLaunch`) or through governance (through a `BinaryOptionsMarketLaunchProposal`). + +The market may be optionally configured with a market admin which has the ability to trigger settlement, change the market status as well as modify the expiration and settlement timestamp of the given market. If the market does not specify an admin, then the market parameters can only be modified through governance and that the settlement procedure will be fully based on the associated oracle provider price feed. + +### Market State Transitions +Binary options markets can take one of three statuses on Injective: Active, Expired or Demolished. After the market is created, the market has an `Active` status, which signifies that individuals can begin trading. + +Pertinently, binary options markets also have a characteristic `ExpirationTimestamp` which specifies the deadline at which trading activity for the market ceases as well as a `SettlementTimestamp` which specifies the deadline at which settlement will occur by (which must be after expiration). + +* **Active** = trading is open +* **Expired** = trading is closed, open orders are cancelled, no change to positions. +* **Demolished** = positions are settled / refunded (depending on the settlement), market is demolished + +The nature of the status transitions for binary options markets are as follows: + +| Status Change | Workflow | +| --- | --- | +| Active → Expired | Expiration is part of the standard workflow for a market. Trading is halted immediately for the market and all open orders are cancelled. The market can now be settled immediately (forcefully) by the admin or oracle or be settled naturally using the latest oracle price when we reach SettlementTimestamp. +| Expired → Demolished (Settlement) | All positions are settled at either the price set by forceful settlement or natural settlement. The market can never be traded on or reactivated again. For natural settlement, upon the SettlementTimestamp time, the last oracle price is recorded and used for settlement. For ‘force-settle’, Admin should post the MarketUpdate msg with SettlementPrice in it being set in a price band of [0, 1]. +| Active/Expired → Demolished (Refund) | All positions get refunded. The market can never be traded on or reactivated again. Admin should post the MarketUpdate msg with SettlementPrice in it being set to -1. | + + +### Market Settlement + +The settlement price options are explained above in the [oracle](#oracle) section. + +Settling a market can be achieved using one of these two options: +1. Using the registered provider oracle for the particular market. Once the provider oracle is granted privileges to relay prices (explained above), the address with the privileges can relay prices for a particular price feed using the `MsgRelayProviderPrices` message. +```go +// MsgRelayProviderPrices defines a SDK message for setting a price through the provider oracle. +type MsgRelayProviderPrices struct { + Sender string + Provider string + Symbols []string + Prices []cosmossdk_io_math.LegacyDec +} +``` + +2. Using the `MsgAdminUpdateBinaryOptionsMarket` which allows the market's admin (creator) to submit a settlement price directly to the market. +```go +type MsgAdminUpdateBinaryOptionsMarket struct { + // new price at which market will be settled + SettlementPrice *Dec + // expiration timestamp + ExpirationTimestamp int64 + // expiration timestamp + SettlementTimestamp int64 + // Status of the market + Status MarketStatus +} + +// Where Status can be one of these options +enum MarketStatus { + Unspecified = 0; + Active = 1; + Paused = 2; + Demolished = 3; + Expired = 4; +} +``` diff --git a/.gitbook/developers/modules/injective/exchange/02_other_concepts.md b/.gitbook/developers/modules/injective/exchange/02_other_concepts.md new file mode 100644 index 00000000..e971f931 --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/02_other_concepts.md @@ -0,0 +1,69 @@ +--- +sidebar_position: 3 +title: Other Concepts +--- + +# Other Concepts + +## Concurrency-Friendly Market Order Clearing Price Algorithm + +We apply the [split-apply-combine](https://stackoverflow.com/tags/split-apply-combine/info) paradigm to leverage +concurrency for efficient data processing. + +1. Match all matchable orders (see order matching for details) concurrently in all markets. + +- The intermediate result is a clearing price and a list of matched orders with their fill quantities. +- The final result is a temporary cache of all new events and all changes to positions, orders, subaccount deposits, + trading reward points and fees paid. + +2. Wait for execution on all markets and persist all data. + +Note: beyond just executing settlement, the design must also take into account market data dissemination requirements +for off-chain consumption. + +## Atomic Market Order Execution + +A common request from new applications built on Cosmwasm is for the ability to be notified upon the execution of an order. In the regular order execution flow, this would not be possible, since the Frequent Batch Auctions (FBA) are executed inside the EndBlocker. To circumvent the FBA, the new type of atomic market orders is introduced. For the privilege of executing such an atomic market order instantly, an additional trading fee is imposed. To calculate the fee of an atomic market order, the market's taker fee is multiplied by the market types's `AtomicMarketOrderFeeMultiplier`. + +- `SpotAtomicMarketOrderFeeMultiplier` +- `DerivativeAtomicMarketOrderFeeMultiplier` +- `BinaryOptionsAtomicMarketOrderFeeMultiplier` + +These multipliers are defined the global exchange parameters. In addition, the exchange parameters also define the `AtomicMarketOrderAccessLevel` which specifies the minimum access level required to execute an atomic market order. + +```golang +const ( + AtomicMarketOrderAccessLevel_Nobody AtomicMarketOrderAccessLevel = 0 + AtomicMarketOrderAccessLevel_BeginBlockerSmartContractsOnly AtomicMarketOrderAccessLevel = 1 + AtomicMarketOrderAccessLevel_SmartContractsOnly AtomicMarketOrderAccessLevel = 2 + AtomicMarketOrderAccessLevel_Everyone AtomicMarketOrderAccessLevel = 3 +) +``` + +## Trading Rewards + +Governance approves a **TradingRewardCampaignLaunchProposal** which specifies: + +- The first campaign's starting timestamp +- The **TradingRewardCampaignInfo** which specifies + - The campaign duration in seconds + - The accepted trading fee quote currency denoms + - The optional market-specific **boost** info + - The disqualified marketIDs for markets in which trades will not earn rewards +- The **CampaignRewardPools** which specifies the maximum epoch rewards that constitute the trading rewards pool for each successive campaign + +During a given campaign, the exchange will record each trader's cumulative trading reward points obtained from trading volume (with boosts applied, if applicable) from all eligible markets, i.e., markets with a matching quote currency that are not in the disqualified list. + +At the end of each campaign, i.e., after the `campaign starting timestamp + campaign duration` has elapsed, each trader will receive a pro-rata percentage of the trading rewards pool based off their trading rewards points from that campaign epoch. + +Campaigns will not auto-rollover. If there are no additional campaigns defined inside **CampaignRewardPools**, the trading reward campaigns will finish. + +## Fee Discounts + +Governance approves a **FeeDiscountProposal** which defines a fee discount **schedule** which specifies fee discount **tiers** which each specify the maker and taker discounts rates a trader will receive if they satisfy the specified minimum INJ staked amount AND have had at least the specified trading volume (based on the specified **quote denoms**) over the specified time period (`bucket count * bucket duration seconds`, which should equal 30 days). The schedule also specifies a list of disqualified marketIDs for markets whose trading volume will not count towards the volume contribution. + +- Spot markets where the base and quote are both in the accepted quote currencies list will not be rewarded (e.g. the USDC/USDT spot market). +- Maker fills in markets with negative maker fees will NOT give the trader any fee discounts. +- If the fee discount proposal was passed less than 30 days ago, i.e. `BucketCount * BucketDuration` hasn't passed yet since the creation of the proposal, the fee volume requirement is ignored so we don't unfairly penalize market makers who onboard immediately. + +Internally the trading volumes are stored in buckets, typically 30 buckets each lasting 24 hours. When a bucket is older than 30 days, it gets removed. Additionally for performance reasons there is a cache for retrieving the fee discount tier for an account. This cache is updated every 24 hours. diff --git a/.gitbook/developers/modules/injective/exchange/03_state.md b/.gitbook/developers/modules/injective/exchange/03_state.md new file mode 100644 index 00000000..719cc7b2 --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/03_state.md @@ -0,0 +1,594 @@ +--- +sidebar_position: 4 +title: State +--- + +# State + +Genesis state defines the initial state of the module to be used to setup the module. + +```go +// GenesisState defines the exchange module's genesis state. +type GenesisState struct { + // params defines all the parameters of related to exchange. + Params Params + // accounts is an array containing the genesis trade pairs + SpotMarkets []*SpotMarket + // accounts is an array containing the genesis derivative markets + DerivativeMarkets []*DerivativeMarket + // spot_orderbook defines the spot exchange limit orderbook active at genesis. + SpotOrderbook []SpotOrderBook + // derivative_orderbook defines the derivative exchange limit orderbook active at genesis. + DerivativeOrderbook []DerivativeOrderBook + // balances defines the exchange users balances active at genesis. + Balances []Balance + // positions defines the exchange derivative positions at genesis + Positions []DerivativePosition + // subaccount_trade_nonces defines the subaccount trade nonces for the subaccounts at genesis + SubaccountTradeNonces []SubaccountNonce + // expiry_futures_market_info defines the market info for the expiry futures markets at genesis + ExpiryFuturesMarketInfoState []ExpiryFuturesMarketInfoState + // perpetual_market_info defines the market info for the perpetual derivative markets at genesis + PerpetualMarketInfo []PerpetualMarketInfo + // perpetual_market_funding_state defines the funding state for the perpetual derivative markets at genesis + PerpetualMarketFundingState []PerpetualMarketFundingState + // derivative_market_settlement_scheduled defines the scheduled markets for settlement at genesis + DerivativeMarketSettlementScheduled []DerivativeMarketSettlementInfo + // sets spot markets as enabled + IsSpotExchangeEnabled bool + // sets derivative markets as enabled + IsDerivativesExchangeEnabled bool + // the current trading reward campaign info + TradingRewardCampaignInfo *TradingRewardCampaignInfo + // the current and upcoming trading reward campaign pools + TradingRewardPoolCampaignSchedule []*CampaignRewardPool + // the current and upcoming trading reward account points + TradingRewardCampaignAccountPoints []*TradingRewardCampaignAccountPoints + // the current and upcoming trading reward campaign pending pools + PendingTradingRewardPoolCampaignSchedule []*CampaignRewardPool + // the pending trading reward account points + PendingTradingRewardCampaignAccountPoints []*TradingRewardCampaignAccountPendingPoints + // the fee discount schedule + FeeDiscountSchedule *FeeDiscountSchedule + // the cached fee discount account tiers with TTL + FeeDiscountAccountTierTtl []*FeeDiscountAccountTierTTL + // the fee discount paid by accounts in all buckets + FeeDiscountBucketFeesPaidAccounts []*FeeDiscountBucketFeesPaidAccounts + // sets the first fee cycle as finished + IsFirstFeeCycleFinished bool +} +``` + +## Params + +`Params` is a module-wide configuration that stores system parameters and defines overall functioning of the exchange module. +This configuration is modifiable by governance using params update proposal natively supported by `gov` module. + +It defines default fee objects to be used for spot and derivative markets and funding parameters for derivative markets and instant listing fees. + +Protobuf interface for the `exchange` module params store. + +```go +type Params struct { + // spot_market_instant_listing_fee defines the expedited fee in INJ required to create a spot market by bypassing governance + SpotMarketInstantListingFee types.Coin + // derivative_market_instant_listing_fee defines the expedited fee in INJ required to create a derivative market by bypassing governance + DerivativeMarketInstantListingFee types.Coin + // default_spot_maker_fee defines the default exchange trade fee for makers on a spot market + DefaultSpotMakerFeeRate math.LegacyDec + // default_spot_taker_fee_rate defines the default exchange trade fee rate for takers on a new spot market + DefaultSpotTakerFeeRate math.LegacyDec + // default_derivative_maker_fee defines the default exchange trade fee for makers on a new derivative market + DefaultDerivativeMakerFeeRate math.LegacyDec + // default_derivative_taker_fee defines the default exchange trade fee for takers on a new derivative market + DefaultDerivativeTakerFeeRate math.LegacyDec + // default_initial_margin_ratio defines the default initial margin ratio on a new derivative market + DefaultInitialMarginRatio math.LegacyDec + // default_maintenance_margin_ratio defines the default maintenance margin ratio on a new derivative market + DefaultMaintenanceMarginRatio math.LegacyDec + // default_funding_interval defines the default funding interval on a derivative market + DefaultFundingInterval int64 + // funding_multiple defines the timestamp multiple that the funding timestamp should be a multiple of + FundingMultiple int64 + // relayer_fee_share_rate defines the trade fee share percentage that goes to relayers + RelayerFeeShareRate math.LegacyDec + // default_hourly_funding_rate_cap defines the default maximum absolute value of the hourly funding rate + DefaultHourlyFundingRateCap math.LegacyDec + // hourly_interest_rate defines the hourly interest rate + DefaultHourlyInterestRate math.LegacyDec + // max_derivative_order_side_count defines the maximum number of derivative active orders a subaccount can have for a given orderbook side + MaxDerivativeOrderSideCount uint32 + // inj_reward_staked_requirement_threshold defines the threshold on INJ rewards after which one also needs staked INJ to receive more + InjRewardStakedRequirementThreshold github_com_cosmos_cosmos_sdk_types.Int + // the trading_rewards_vesting_duration defines the vesting times for trading rewards + TradingRewardsVestingDuration int64 +} +``` + +## Balance + +`Balance` is to manage balances of accounts. The module is storing the whole balance in the module account, while the balance of each account is managed just as a record. + +The `Balance` object is stored by `subaccount_id` and `denom`. + +```go +message Balance { + SubaccountId string + Denom string + Deposits *Deposit +} + +// An subaccount's deposit for a given base currency +type Deposit struct { + AvailableBalance math.LegacyDec + TotalBalance math.LegacyDec +} + +type SubaccountDeposit { + SubaccountId []byte + Deposit *Deposit +} +``` + +## SubaccountNonce + +`SubaccountNonce` is used to express unique order hashes. + +```go +type SubaccountNonce struct { + SubaccountId string + SubaccountTradeNonce SubaccountTradeNonce +} +``` + +## Order + +There are a number of structures used to store the orders into the store. + +```go +type OrderInfo struct { + // bytes32 subaccount ID that created the order + SubaccountId string + // address fee_recipient address that will receive fees for the order + FeeRecipient string + // price of the order + Price math.LegacyDec + // quantity of the order + Quantity math.LegacyDec +} + +type SubaccountOrderbookMetadata struct { + VanillaLimitOrderCount uint32 + ReduceOnlyLimitOrderCount uint32 + // AggregateReduceOnlyQuantity is the aggregate fillable quantity of the subaccount's reduce-only limit orders in the given direction. + AggregateReduceOnlyQuantity math.LegacyDec + // AggregateVanillaQuantity is the aggregate fillable quantity of the subaccount's vanilla limit orders in the given direction. + AggregateVanillaQuantity math.LegacyDec +} + +type SubaccountOrder struct { + // price of the order + Price math.LegacyDec + // the amount of the quantity remaining fillable + Quantity math.LegacyDec + IsReduceOnly bool + Cid string +} + +type MarketOrderIndicator struct { + // market_id represents the unique ID of the market + MarketId string + IsBuy bool +} +``` + +## SpotMarket + +`SpotMarket` is the structure to store all the required information and state for a spot market. +Spot markets are stored by hash of the market to query the market efficiently. + +```go +// An object describing trade pair of two assets. +type SpotMarket struct { + // A name of the pair in format AAA/BBB, where AAA is base asset, BBB is quote asset. + Ticker string + // Coin denom used for the base asset + BaseDenom string + // Coin used for the quote asset + QuoteDenom string + // maker_fee_rate defines the fee percentage makers pay when trading + MakerFeeRate math.LegacyDec + // taker_fee_rate defines the fee percentage takers pay when trading + TakerFeeRate math.LegacyDec + // relayer_fee_share_rate defines the percentage of the transaction fee shared with the relayer in a derivative market + RelayerFeeShareRate math.LegacyDec + // Unique market ID. + MarketId string + // Status of the market + Status MarketStatus + // min_price_tick_size defines the minimum tick size that the price required for orders in the market + MinPriceTickSize math.LegacyDec + // min_quantity_tick_size defines the minimum tick size of the quantity required for orders in the market + MinQuantityTickSize math.LegacyDec +} +``` + +## SpotOrderBook + +`SpotOrderBook` is a structure to store spot limit orders for a specific market. +Two objects are created, one for buy orders and one for sell orders. + +```go +// Spot Exchange Limit Orderbook +type SpotOrderBook struct { + MarketId string + IsBuySide bool + Orders []*SpotLimitOrder +} + +type SpotOrder struct { + // market_id represents the unique ID of the market + MarketId string + // order_info contains the information of the order + OrderInfo OrderInfo + // order types + OrderType OrderType + // trigger_price is the trigger price used by stop/take orders + TriggerPrice *math.LegacyDec +} + +// A valid Spot limit order with Metadata. +type SpotLimitOrder struct { + // order_info contains the information of the order + OrderInfo OrderInfo + // order types + OrderType OrderType + // the amount of the quantity remaining fillable + Fillable math.LegacyDec + // trigger_price is the trigger price used by stop/take orders + TriggerPrice *math.LegacyDec + OrderHash []byte +} + +// A valid Spot market order with Metadata. +type SpotMarketOrder struct { + // order_info contains the information of the order + OrderInfo OrderInfo + BalanceHold math.LegacyDec + OrderHash []byte +} +``` + +## DerivativeMarket + +`DerivativeMarket` is the structure to store all the required information and state for a derivative market. +Derivative markets are stored by hash of the market to query the market efficiently. + +```go +// An object describing a derivative market in the Injective Futures Protocol. +type DerivativeMarket struct { + // Ticker for the derivative contract. + Ticker string + // Oracle base currency + OracleBase string + // Oracle quote currency + OracleQuote string + // Oracle type + OracleType types1.OracleType + // Scale factor for oracle prices. + OracleScaleFactor uint32 + // Address of the quote currency denomination for the derivative contract + QuoteDenom string + // Unique market ID. + MarketId string + // initial_margin_ratio defines the initial margin ratio of a derivative market + InitialMarginRatio math.LegacyDec + // maintenance_margin_ratio defines the maintenance margin ratio of a derivative market + MaintenanceMarginRatio math.LegacyDec + // maker_fee_rate defines the maker fee rate of a derivative market + MakerFeeRate math.LegacyDec + // taker_fee_rate defines the taker fee rate of a derivative market + TakerFeeRate math.LegacyDec + // relayer_fee_share_rate defines the percentage of the transaction fee shared with the relayer in a derivative market + RelayerFeeShareRate math.LegacyDec + // true if the market is a perpetual market. false if the market is an expiry futures market + IsPerpetual bool + // Status of the market + Status MarketStatus + // min_price_tick_size defines the minimum tick size that the price and margin required for orders in the market + MinPriceTickSize math.LegacyDec + // min_quantity_tick_size defines the minimum tick size of the quantity required for orders in the market + MinQuantityTickSize math.LegacyDec +} +``` + +## DerivativeOrderBook + +`DerivativeOrderBook` is a structure to store derivative limit orders for a specific market. +Two objects are created, one for buy orders and one for sell orders. + +```go +// Spot Exchange Limit Orderbook +type DerivativeOrderBook struct { + MarketId string + IsBuySide bool + Orders []*DerivativeLimitOrder +} + +type DerivativeOrder struct { + // market_id represents the unique ID of the market + MarketId string + // order_info contains the information of the order + OrderInfo OrderInfo + // order types + OrderType OrderType + // margin is the margin used by the limit order + Margin math.LegacyDec + // trigger_price is the trigger price used by stop/take orders + TriggerPrice *math.LegacyDec +} + +// A valid Derivative limit order with Metadata. +type DerivativeLimitOrder struct { + // order_info contains the information of the order + OrderInfo OrderInfo + // order types + OrderType OrderType + // margin is the margin used by the limit order + Margin math.LegacyDec + // the amount of the quantity remaining fillable + Fillable math.LegacyDec + // trigger_price is the trigger price used by stop/take orders + TriggerPrice *math.LegacyDec + OrderHash []byte +} + +// A valid Derivative market order with Metadata. +type DerivativeMarketOrder struct { + // order_info contains the information of the order + OrderInfo OrderInfo + // order types + OrderType OrderType + Margin math.LegacyDec + MarginHold math.LegacyDec + // trigger_price is the trigger price used by stop/take orders + TriggerPrice *math.LegacyDec + OrderHash []byte +} + +type DerivativeMarketOrderCancel struct { + MarketOrder *DerivativeMarketOrder + CancelQuantity math.LegacyDec +} +``` + +## DerivativePosition + +`DerivativePosition` is a structure to store derivative positions for a subaccount on a specific market. + +**Note:** Derivative orders represent intent while positions represent possession. + +```go +type Position struct { + IsLong bool + Quantity math.LegacyDec + EntryPrice math.LegacyDec + Margin math.LegacyDec + CumulativeFundingEntry math.LegacyDec +} + +type PositionDelta struct { + IsLong bool + ExecutionQuantity math.LegacyDec + ExecutionMargin math.LegacyDec + ExecutionPrice math.LegacyDec +} + +type DerivativePosition struct { + SubaccountId string + MarketId string + Position *Position +} + +type SubaccountPosition struct { + Position *Position + SubaccountId []byte +} +``` + +## ExpiryFuturesMarketInfo + +`ExpiryFuturesMarketInfo` is a structure to keep the information of expiry futures market. +It is stored by the id of the market. + +```go +type ExpiryFuturesMarketInfo struct { + // market ID. + MarketId string + // expiration_timestamp defines the expiration time for a time expiry futures market. + ExpirationTimestamp int64 + // expiration_twap_start_timestamp defines the start time of the TWAP calculation window + TwapStartTimestamp int64 + // expiration_twap_start_price_cumulative defines the cumulative price for the start of the TWAP window + ExpirationTwapStartPriceCumulative math.LegacyDec + // settlement_price defines the settlement price for a time expiry futures market. + SettlementPrice math.LegacyDec +} +``` + +## PerpetualMarketInfo + +`PerpetualMarketInfo` is a structure to keep the information of perpetual market. + +```go +type PerpetualMarketInfo struct { + // market ID. + MarketId string + // hourly_funding_rate_cap defines the maximum absolute value of the hourly funding rate + HourlyFundingRateCap math.LegacyDec + // hourly_interest_rate defines the hourly interest rate + HourlyInterestRate math.LegacyDec + // next_funding_timestamp defines the next funding timestamp in seconds of a perpetual market + NextFundingTimestamp int64 + // funding_interval defines the next funding interval in seconds of a perpetual market. + FundingInterval int64 +} +``` + +## PerpetualMarketFunding + +`PerpetualMarketFunding` is a structure to manage perpetual market fundings info. + +```go +type PerpetualMarketFunding struct { + // cumulative_funding defines the cumulative funding of a perpetual market. + CumulativeFunding math.LegacyDec + // cumulative_price defines the cumulative price for the current hour up to the last timestamp + CumulativePrice math.LegacyDec + LastTimestamp int64 +} +``` + +## Trading Rewards + +### CampaignRewardPool + +`CampaignRewardPool` is a structure to be used for getting the upcoming trading reward pools. + +```go +type CampaignRewardPool struct { + StartTimestamp int64 + // max_campaign_rewards are the maximum reward amounts to be disbursed at the end of the campaign + MaxCampaignRewards sdk.Coins +} +``` + +### TradingRewardCampaignInfo + +`TradingRewardCampaignInfo` is a structure to be used for getting the trading reward campaign info. + +```go +type TradingRewardCampaignInfo struct { + // number of seconds of the duration of each campaign + CampaignDurationSeconds int64 + // the trading fee quote denoms which will be counted for the rewards + QuoteDenoms []string + // the optional boost info for markets + TradingRewardBoostInfo *TradingRewardCampaignBoostInfo + // the marketIDs which are disqualified from being rewarded + DisqualifiedMarketIds []string +} + +type TradingRewardCampaignBoostInfo struct { + BoostedSpotMarketIds []string + SpotMarketMultipliers []PointsMultiplier + BoostedDerivativeMarketIds []string + DerivativeMarketMultipliers []PointsMultiplier +} + +type PointsMultiplier struct { + MakerPointsMultiplier math.LegacyDec + TakerPointsMultiplier math.LegacyDec +} +``` + +## FeeDiscountProposal + +`FeeDiscountProposal` is a structure to be used for proposing a new fee discount schedule and durations. + +```go +type FeeDiscountSchedule struct { + // the bucket count, e.g., 30 + BucketCount uint64 + // the bucket duration, e.g., 1 day + BucketDuration int64 + // the trading fee quote denoms which will be counted for the fee paid contribution + QuoteDenoms []string + // the fee discount tiers + TierInfos []*FeeDiscountTierInfo + // the marketIDs which are disqualified from contributing to the fee paid amount + DisqualifiedMarketIds []string +} + +type FeeDiscountTierInfo struct { + MakerDiscountRate math.LegacyDec + TakerDiscountRate math.LegacyDec + StakedAmount math.Int + FeePaidAmount math.LegacyDec +} +``` + +## DerivativeMarketSettlementInfo + +`DerivativeMarketSettlementInfo` is a structure to be used for the scheduled markets for settlement. + +```go +type DerivativeMarketSettlementInfo struct { + // market ID. + MarketId string + // settlement_price defines the settlement price + SettlementPrice math.LegacyDec + // starting_deficit defines starting deficit + StartingDeficit math.LegacyDec +} +``` + +## TradeLog + +Trade logs are emitted in events to track the trading history. + +```go +type TradeLog struct { + Quantity math.LegacyDec + Price math.LegacyDec + // bytes32 subaccount ID that executed the trade + SubaccountId []byte + Fee math.LegacyDec + OrderHash []byte +} + +type DerivativeTradeLog struct { + SubaccountId []byte + PositionDelta *PositionDelta + Payout math.LegacyDec + Fee math.LegacyDec + OrderHash []byte +} +``` + +## Enums + +Enums are used to describe the order types, execution types and market status. + +```protobuf +enum OrderType { + UNSPECIFIED = 0 [(gogoproto.enumvalue_customname) = "UNSPECIFIED"]; + BUY = 1 [(gogoproto.enumvalue_customname) = "BUY"]; + SELL = 2 [(gogoproto.enumvalue_customname) = "SELL"]; + STOP_BUY = 3 [(gogoproto.enumvalue_customname) = "STOP_BUY"]; + STOP_SELL = 4 [(gogoproto.enumvalue_customname) = "STOP_SELL"]; + TAKE_BUY = 5 [(gogoproto.enumvalue_customname) = "TAKE_BUY"]; + TAKE_SELL = 6 [(gogoproto.enumvalue_customname) = "TAKE_SELL"]; + BUY_PO = 7 [(gogoproto.enumvalue_customname) = "BUY_PO"]; + SELL_PO = 8 [(gogoproto.enumvalue_customname) = "SELL_PO"]; + BUY_ATOMIC = 9 [ (gogoproto.enumvalue_customname) = "BUY_ATOMIC" ]; + SELL_ATOMIC = 10 [ (gogoproto.enumvalue_customname) = "SELL_ATOMIC" ]; +} + +enum MarketStatus { + Unspecified = 0; + Active = 1; + Paused = 2; + Suspended = 3; + Demolished = 4; + Expired = 5; +} + +enum ExecutionType { + UnspecifiedExecutionType = 0; + Market = 1; + LimitFill = 2; + LimitMatchRestingOrder = 3; + LimitMatchNewOrder = 4; +} +``` diff --git a/.gitbook/developers/modules/injective/exchange/04_state_transitions.md b/.gitbook/developers/modules/injective/exchange/04_state_transitions.md new file mode 100644 index 00000000..99b858ee --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/04_state_transitions.md @@ -0,0 +1,447 @@ +--- +sidebar_position: 5 +title: State Transitions +--- + +# State Transitions + +This document describes the state transition operations pertaining to: + +- Deposit into exchange module account +- Withdraw from exchange module account +- Instant spot market launch +- Instant perpetual market launch +- Instant expiry futures market launch +- Spot limit order creation +- Batch creation of spot limit orders +- Spot market order creation +- Cancel spot order +- Batch cancellation of spot order +- Derivative limit order creation +- Batch derivative limit order creation +- Derivative market order creation +- Cancel derivative order +- Batch cancellation of derivative orders +- Transfer between subaccounts +- Transfer to external account +- Liquidating a position +- Increasing position margin +- Spot market param update proposal +- Exchange enable proposal +- Spot market launch proposal +- Perpetual market launch proposal +- Expiry futures market launch proposal +- Derivative market param update proposal +- Trading rewards launch proposal +- Trading rewards update proposal +- Begin-blocker +- End-blocker + +## Deposit into exchange module account + +Deposit action is carried out by `MsgDeposit` which consists of `Sender`, `SubaccountId` and `Amount` fields. + +**Note:** `SubaccountId` is optional and if it's not available, it's calculated dynamically from `Sender` address. + +**Steps** + +- Check that the denom specified in `msg.Amount` is a valid denom which exists in bank supply +- Send coins from individual account to `exchange` module account and if fail, just revert +- Get hash type of `subaccountID` from `msg.SubaccountId`, if it's zero subaccount, calculate dynamically from `msg.Sender` by using `SdkAddressToSubaccountID` +- Increment deposit amount for the `subaccountID` by `msg.Amount` +- Emit event for `EventSubaccountDeposit` with `msg.Sender`, `subaccountID` and `msg.Amount` + +## Withdraw from exchange module account + +Withdraw action is carried out by `MsgWithdraw` which consists of `Sender`, `SubaccountId` and `Amount` fields. + +**Note:** The ownership of `msg.SubaccountId` by `msg.Sender` is validated on `msg.ValidateBasic` function. + +**Steps** + +- Get hash type of `subaccountID` from `msg.SubaccountId` +- Check the denom specified in `msg.Amount` is a valid denom which exists in bank supply +- Decrement withdraw amount from `subaccountID` by `msg.Amount`, if fail, revert +- Send coins from `exchange` module to `msg.Sender` +- Emit event for `EventSubaccountWithdraw` with `subaccountID`, `msg.Sender`, and `msg.Amount` + +## Instant spot market launch + +Instant spot market launch action is carried out by `MsgInstantSpotMarketLaunch` which consists of `Sender`, `Ticker`, `BaseDenom`, `QuoteDenom`, `MinPriceTickSize` and `MinQuantityTickSize` fields. + +**Steps** + +- Calculate `marketID` from `msg.BaseDenom` and `msg.QuoteDenom` +- Check if same market launch proposal exists by `marketID` and revert if already exists +- Launch spot market with `msg.Ticker`, `msg.BaseDenom`, `msg.QuoteDenom`, `msg.MinPriceTickSize`, `msg.MinQuantityTickSize` and revert if fail +- Send instant listing fee(params.SpotMarketInstantListingFee) from `msg.Sender` to `exchange` module account +- Lastly send the instant listing fee to the community spend pool + +## Instant perpetual market launch + +Instant perpetual market launch action is carried out by `MsgInstantPerpetualMarketLaunch` which consists of `Sender`, `Ticker`, `QuoteDenom`, `OracleBase`, `OracleQuote`, `OracleScaleFactor`, `OracleType`, `MakerFeeRate`, `TakerFeeRate`, `InitialMarginRatio`, `MaintenanceMarginRatio`, `MinPriceTickSize` and `MinQuantityTickSize` fields. + +**Steps** + +- Calculate `marketID` from `msg.Ticker`, `msg.QuoteDenom`, `msg.OracleBase`, `msg.OracleQuote` and `msg.OracleType`. +- Check if same market launch proposal exists by `marketID` and revert if already exists +- Send instant listing fee(params.DerivativeMarketInstantListingFee) from `msg.Sender` to `exchange` module account +- Launch perpetual market with required params on `msg` object and revert if fail +- Lastly send the instant listing fee to the community spend pool + +## Instant expiry futures market launch + +Instant expiry futures market launch action is carried out by `MsgInstantExpiryFuturesMarketLaunch` which consists of `Sender`, `Ticker`, `QuoteDenom`, `OracleBase`, `OracleQuote`, `OracleScaleFactor`, `OracleType`, `Expiry`, `MakerFeeRate`, `TakerFeeRate`, `InitialMarginRatio`, `MaintenanceMarginRatio`, `MinPriceTickSize` and `MinQuantityTickSize` fields. + +**Steps** + +- Calculate `marketID` from `msg.Ticker`, `msg.QuoteDenom`, `msg.OracleBase`, `msg.OracleQuote`, `msg.OracleType` and `msg.Expiry`. +- Check if same market launch proposal exists by `marketID` and revert if already exists +- Send instant listing fee(params.DerivativeMarketInstantListingFee) from `msg.Sender` to `exchange` module account +- Launch expiry futures market with required params on `msg` object and revert if fail +- Trigger `EventExpiryFuturesMarketUpdate` event with market info +- Lastly send the instant listing fee to the community spend pool + +## Spot limit order creation + +Spot limit order creation is carried out by `MsgCreateSpotLimitOrder` which consists of `Sender` and `Order`. + +**Steps** + +- Check spot exchange is enabled to make an order on spot market and if not revert +- Check order's price and quantity tick sizes fits market's min quantity and price tick size +- Increment subaccount's `TradeNonce` +- Reject if spot market id does not reference an active spot market +- Calculate unique order hash with `TradeNonce` +- Reject if the subaccount's available deposits does not have at least the required funds for the trade +- Decrement the available balance by the funds amount needed to fund the order +- Store the order in the transient limit order store and transient market indicator store + +**Note:** The order in transient store is executed on endblocker or if not, put on long-live store. + +## Batch creation of spot limit orders + +Batch creation of spot limit orders is carried out by `MsgBatchCreateSpotLimitOrders` which consists of `Sender` and `Orders`. + +**Steps** + +- Loop over the `msg.Orders` and create spot limit order as in `MsgCreateSpotLimitOrder` + +## Spot market order creation + +Spot market order creation is carried out by `MsgCreateSpotMarketOrder` which consists of `Sender` and `Order`. + +**Steps** + +- Check spot exchange is enabled to make an order on spot market and if not revert +- Check order's price and quantity tick sizes fits market's min quantity and price tick size +- Increment subaccount's `TradeNonce` +- Reject if spot market id does not reference an active spot market +- Calculate unique order hash with `TradeNonce` +- Check available balance to fund the market order +- Calculate the worst acceptable price for the market order +- Decrement deposit's AvailableBalance by the balance hold +- Store the order in the transient spot market order store and transient market indicator store + +## Cancel spot order + +Spot order cancellation is carried out by `MsgCancelSpotOrder` which consists of `Sender` and `MarketId`, `SubaccountId` and `OrderHash`. + +**Steps** + +- Check spot exchange is enabled to execute the action and if not revert +- Reject if spot market id does not reference an active, suspended or demolished spot market +- Check spot limit order exists by `marketID`, `subaccountID` and `orderHash` +- Add back the margin hold to available balance +- Increment the available balance margin hold +- Delete the order state from ordersStore and ordersIndexStore +- Emit `EventCancelSpotOrder` event with marketID and order info + +## Batch cancellation of spot orders + +Batch cancellation of spot orders is carried out by `MsgBatchCancelSpotOrders` which consists of `Sender` and `Data`. + +**Steps** + +- Loop over the `msg.Data` and cancel spot order as in `MsgCancelSpotOrder` + +## Derivative limit order creation + +Derivative limit order creation is carried out by `MsgCreateDerivativeLimitOrder` which consists of `Sender` and `Order`. + +**Steps** + +- Check derivative exchange is enabled to make an order on derivative market and if not revert +- Reject if market order is already placed on the market by `subaccountID` (**Note:** Can't the market order and limit order core exist?) +- Get derivative market and markPrice by `marketID` +- Get orderbook metadata (`SubaccountOrderbookMetadata`) the for specified `marketID` and `subaccountID` +- Ensure limit order is valid: + - Market config (market id and tick sizes) + - Subaccount trade nonce + - Subaccount max order count + - If reduce-only order: + - Position with valid quantity and opposite direction exists + - If order would result in other reduce-only orders becoming stale, reject it + - If limit order: + - Enough subaccount deposits for margin hold + - If order is in opposite direction of existing position and results in other reduce-only orders becoming stale, cancel the stale reduce-only orders +- Store the order in the transient limit order store and transient market indicator store +- Update orderbook metadata for subaccount + +## Batch creation of derivative limit orders + +Batch creation of derivative limit orders is carried out by `MsgBatchCreateDerivativeLimitOrders` which consists of `Sender` and `Orders`. + +**Steps** + +- Loop over the `msg.Orders` and create derivative limit order as in `MsgCreateDerivativeLimitOrder` + +## Derivative market order creation + +Derivative market order creation is carried out by `MsgCreateDerivativeMarketOrder` which consists of `Sender` and `Order`. + +**Steps** + +- Check derivative exchange is enabled to make an order on derivative market and if not revert +- Check if `SubaccountID` that is going to make new order has limit derivative order or market order and reject. **Note:** Perpetual market can't place two market orders or both limit / market orders at the same time? +- Check order's price and quantity tick sizes fits market's min quantity and price tick size +- Increment Subaccount's `TradeNonce` +- Reject if derivative market id does not reference an active derivative market +- Calculate unique order hash with `TradeNonce` +- Check that the market order worst price reaches the best opposing resting orderbook price +- Check Order/Position Margin amount +- 1. If it's reduce only order +- A. Check if position for `subaccountID` on the market is not nil +- B. Check that the order can close the position +- C. Reject if position.quantity - AggregateReduceOnlyQuantity - order.quantity < 0 +- D. Set MarginHold as zero for no margin hold for selling positions +- 2. If it's not reduce only order +- A. Check available balance to fund the market order +- B. Reject if the subaccount's available deposits does not have at least the required funds for the trade +- C. Decrement deposit's AvailableBalance by the balance hold +- For an opposing position, if AggregateVanillaQuantity > position.quantity - AggregateReduceOnlyQuantity - order.FillableQuantity, the new reduce-only order might invalidate some existing reduce-only orders or itself be invalid, and do operations for that. +- Store the order in the transient derivative market order store and transient market indicator store + +## Cancel derivative order + +Derivative order cancellation is carried out by `MsgCancelDerivativeOrder` which consists of `Sender`, `MarketId`, `SubaccountId` and `OrderHash`. + +**Steps** + +- Check derivative exchange is enabled to execute the operation and if not revert +- Reject if derivative market id does not reference an active derivative market +- Check resting derivative limit order exists by `marketID`, `subaccountID` and `orderHash` +- Add back the margin hold to available balance +- Skip cancelling limit orders if their type shouldn't be cancelled +- Delete the order state from ordersStore, ordersIndexStore and subaccountOrderStore +- Update orderbook metadata for subaccount +- Emit `EventCancelDerivativeOrder` event with marketID and order info + +## Batch cancellation of derivative orders + +Batch cancellation of derivative orders is carried out by `MsgBatchCancelDerivativeOrders` which consists of `Sender` and `Data`. + +**Steps** + +- Loop over the `msg.Data` and cancel spot order as in `MsgCancelDerivativeOrder` + +## Batch order updates + +Batch updating orders is carried out by `MsgBatchUpdateOrders` which consists of `Sender` and `Orders`. + +**Steps** + +- Cancel all orders in all market id specified by `SpotMarketIdsToCancelAll` and `DerivativeMarketIdsToCancelAll` for specified subaccount id +- Loop over the `msg.SpotOrdersToCancel` and cancel spot limit order as in `MsgCancelSpotOrder`. If the cancel fails, continue to next order. The success of cancellations is reflected in the `MsgBatchUpdateOrdersResponse` as `SpotCancelSuccess`. +- Loop over the `msg.DerivativeOrdersToCancel` and cancel derivative limit order as in `MsgCancelDerivativeOrder`. If the cancel fails, continue to next order. The success of cancellations is reflected in the `MsgBatchUpdateOrdersResponse` as `DerivativeCancelSuccess`. +- Loop over the `msg.SpotOrdersToCreate` and create spot limit order as in `MsgCreateSpotOrder`. If the creation fails, continue to next order. Successful creations are reflected in the `MsgBatchUpdateOrdersResponse` as `SpotOrderHashes`. +- Loop over the `msg.DerivativeOrdersToCreate` and create derivative limit order as in `MsgCreateDerivativeOrder`. If the creation fails, continue to next order. Successful creations are reflected in the `MsgBatchUpdateOrdersResponse` as `DerivativeOrderHashes`. + +## Transfer between subaccounts + +Transfer between subaccounts is executed by `MsgSubaccountTransfer` which consists of `Sender`, `SourceSubaccountId`, `DestinationSubaccountId` and `Amount`. + +**Steps** + +- Withdraw deposit from `msg.SourceSubaccountId` for `msg.Amount`, if fail revert transaction +- Increment deposit of `msg.DestinationSubaccountId` by `msg.Amount` +- Emit event for `EventSubaccountBalanceTransfer` with `SrcSubaccountId`, `DstSubaccountId` and `msg.Amount` + +**Note:** With subaccount transfer, no need to transfer actual coins from bank module but changing the records are enough. + +## Transfer to external account + +Transfer to external account is executed by `MsgExternalTransfer` which consists of `Sender`, `SourceSubaccountId`, `DestinationSubaccountId` and `Amount`. + +**Steps** + +- Withdraw deposit from `msg.SourceSubaccountId` for `msg.Amount`, if fail revert transaction +- Increment deposit of `msg.DestinationSubaccountId` by `msg.Amount` +- Emit event for `EventSubaccountBalanceTransfer` with `SrcSubaccountId`, `DstSubaccountId` and `msg.Amount` + +**Note:** With subaccount transfer, no need to transfer actual coins from bank module but changing the records are enough. + +1. Event should be different for subaccount transfer and external transfer. +2. There's no difference in subaccount transfer and external transfer, still need to keep different messages? + +## Liquidating a position + +Liquidating a position is executed by `MsgLiquidatePosition` which consists of `Sender`, `SubaccountId`, `MarketId` and `Order`. + +**Steps** + +- Check derivative exchange is enabled to liquidate a position on derivative market and if not revert +- Reject if derivative market id does not reference an active derivative market +- Get derivative market and markPrice by `marketID` +- Get position for `marketID` and `subaccountID` +- Calculate `liquidationPrice` and `bankruptcyPrice` from the position info +- Determine vaporize or liquidate and if not all of them, revert +- Cancel all reduce-only limit orders created by the position holder in the given market +- Apply funding and update position +- Cancel all market orders created by the position holder in the given market +- Check and increment subaccount nonce, compute order hash +- Calculate `liquidationOrder` hash +- Set the liquidation order into the storage +- Execute liquidation by matching position and liquidation order +- Handle differently based on the payout is positive or negative (insurance fund is involved here in calculation) + - Positive Payout: + 1. Send half of the payout to liquidator (incentive for running liquidator bots) + 2. Send the other half to the insurance fund (incentive for participating in insurance funds) + - Negative Payout - Four levels of escalation to retrieve the funds: + 1. From trader's available balance + 2. From trader's locked balance by cancelling his vanilla limit orders + 3. From the insurance fund + 4. Not enough funds available. Pause the market and add markets to the storage to be settled in next block, see `BeginBlocker` specs. +- If market is a perpetual market, upgrade VWAP data based on liquidation price and quantity +- If there's remaining in liquidation order, return back remains by cancelling order + +## Increasing position margin + +Increasing position margin is executed by `MsgIncreasePositionMargin` which consists of `Sender`, `SourceSubaccountId`, `DestinationSubaccountId`, `MarketId` and `Amount`. + +**Steps** + +- Check derivative exchange is enabled to increase position margin on derivative market and if not revert +- Reject if derivative market id does not reference an active derivative market +- Get deposit of `sourceSubaccountID` +- If `deposit.AvailableBalance` is lower than `msg.Amount`, revert +- Get position by `marketID` and `destinationSubaccountID` and if not exist, revert +- Reduce deposit amount of `sourceSubaccountID` by `msg.Amount` +- Increase position margin by `msg.Amount` and update position in the store + +## Exchange enable proposal + +The enable of market type is done by `ExchangeEnableProposal` which consists of `Title`, `Description` and `ExchangeType`. + +**Steps** + +- `ValidateBasic` for proposal +- If `p.ExchangeType` is spot market, enable spot exchange +- If `p.ExchangeType` is derivative market, enable derivative market + +## Spot market launch proposal + +Launch of spot market is handled by `SpotMarketLaunchProposal` which consists of `Title`, `Description`, `Ticker`, `BaseDenom`, `QuoteDenom`, `MinPriceTickSize` and `MinQuantityTickSize` fields. + +**Steps** + +- `ValidateBasic` for proposal +- Validate `BaseDenom` and `QuoteDenom` are valid +- Validate if same market does not exist by `msg.BaseDenom` and `msg.QuoteDenom` +- Calculate RelayerFeeShareRate based on exchange module params. **Note:** for INJ currency, relayer share rate is set to 100% +- Save spot market with calculated `ticker`, `baseDenom`, `quoteDenom`, `exchangeParams.DefaultSpotMakerFeeRate`, `exchangeParams.DefaultSpotTakerFeeRate`, `relayerFeeShareRate`, `minPriceTickSize`, `minQuantityTickSize`, `marketID`, and `MarketStatus_Active`. + +## Perpetual market launch proposal + +Perpetual market launch is handled by `PerpetualMarketLaunchProposal` which consists of `Title`, `Description`, `Ticker`, `QuoteDenom`, `OracleBase`, `OracleQuote`, `OracleScaleFactor`, `OracleType`, `MakerFeeRate`, `TakerFeeRate`, `InitialMarginRatio`, `MaintenanceMarginRatio`, `MinPriceTickSize` and `MinQuantityTickSize` fields. + +**Steps** + +- `ValidateBasic` for proposal +- Validate `quoteDenom`. +- Calculate `marketID` from `ticker`, `quoteDenom`, `oracleBase`, `oracleQuote`, `oracleType` +- Validate active or inactive perpetual market for `marketID` does not exist +- Try getting derivative market price to check price oracle by `oracleBase`, `oracleQuote`, `oracleScaleFactor`, `oracleType` +- Validate insurance fund exist for `marketID` +- Calculate `defaultFundingInterval`, `nextFundingTimestamp`, `relayerFeeShareRate` from `exchange` module params +- Execute `SetDerivativeMarketWithInfo` to set market info into the storage with `market`, `marketInfo` and `funding` objects + +## Expiry futures market launch proposal + +Expiry futures market launch is handled by `ExpiryFuturesMarketLaunchProposal` which consists of `Title`, `Description`, `Ticker`, `QuoteDenom`, `OracleBase`, `OracleQuote`, `OracleScaleFactor`, `OracleType`, `Expiry`, `MakerFeeRate`, `TakerFeeRate`, `InitialMarginRatio`, `MaintenanceMarginRatio`, `MinPriceTickSize` and `MinQuantityTickSize` fields. + +**Steps** + +- `ValidateBasic` for proposal +- Validate `quoteDenom` +- Calculate `marketID` from `p.Ticker`, `p.QuoteDenom`, `p.OracleBase`, `p.OracleQuote`, `p.OracleType` and `p.Expiry` +- Validate active or inactive expiry futures market for `marketID` does not exist +- If expiry time passed `ctx.BlockTime()` already, revert +- Try getting derivative market price to check price oracle by `oracleBase`, `oracleQuote`, `oracleScaleFactor`, `oracleType` +- Validate insurance fund exist for `marketID` +- Calculate RelayerFeeShareRate based on exchange module params. **Note:** for INJ currency, relayer share rate is set to 100% +- Execute `SetDerivativeMarketWithInfo` to set market info into the storage with `market`, `marketInfo` objects **Note:** TwapStartTimestamp is set to `expiry - thirtyMinutesInSeconds`. + +## Spot market param update proposal + +The update of spot market param is handled by `SpotMarketParamUpdateProposal` which consists of `Title`, `Description`, `MarketId`, `MakerFeeRate`, `TakerFeeRate`, `RelayerFeeShareRate`, `MinPriceTickSize`, `MinQuantityTickSize` and `Status`. + +**Steps** + +- `ValidateBasic` for proposal +- Get spot market by `p.MarketId` and if not exist, revert +- Reset the params for `MakerFeeRate`, `TakerFeeRate`, `RelayerFeeShareRate`, `MinPriceTickSize`, `MinQuantityTickSize` and `Status` if not empty, if empty keep as it is. +- Validate `MakerFeeRate` is bigger than `TakerFeeRate`. + +## Derivative market param update proposal + +Derivative market param update is handled by `DerivativeMarketParamUpdateProposal` which consists of `Title`, `Description`, `MarketId`, `InitialMarginRatio`, `MaintenanceMarginRatio`, `MakerFeeRate`, `TakerFeeRate`, `RelayerFeeShareRate`, `MinPriceTickSize`, `MinQuantityTickSize` and `Status`. + +**Steps** + +- `ValidateBasic` for proposal +- Validate Derivative market exists by `p.MarketId` and if not exist, revert +- Reset the params for `InitialMarginRatio`, `MaintenanceMarginRatio`, `MakerFeeRate`, `TakerFeeRate`, `RelayerFeeShareRate`, `MinPriceTickSize`, `MinQuantityTickSize` and `Status` if not empty, if empty keep as it is. +- Validate `MakerFeeRate` is bigger than `TakerFeeRate`. +- Validate `InitialMarginRatio` is bigger than `MaintenanceMarginRatio`. +- Schedule Derivative market param update and update finalization on Endblocker - **Note:** this is due to the orders update for derivative market param update - should make sure nothing panics here. + +## Trading Rewards Campaign Launch Proposal + +**Steps** + +- `ValidateBasic` for proposal +- No existing campaign may exist. +- Campaign start timestamps must be in the future. +- Campaign quote denoms must exist. +- All start timestamps must match the duration. +- Set Campaign Data (Reward Pools, Info, Market Qualifications and Market Point Multipliers) +- Emit `EventTradingRewardCampaignUpdate` + +## Trading Rewards Campaign Update Proposal + +**Steps** + +- `ValidateBasic` for proposal +- All `StartTimestamp` inside `CampaignRewardPoolsUpdates` must equal an existing campaign. +- `CampaignDurationSeconds` cannot be modified, but must match the current campaign. +- `CampaignRewardPoolsUpdates` cannot modify the current campaign and may contain nil values to delete a reward pool. +- Campaign start timestamps from `CampaignRewardPoolsAdditions` must be in the future. +- Any campaign quote denoms must exist. +- Delete Current Campaign Data (Info, Market Qualifications and Market Point Multipliers) +- Set Campaign Data (Info, Market Qualifications and Market Point Multipliers) +- Set Reward Pool Updates +- Set Reward Pool Additions +- Emit `EventTradingRewardCampaignUpdate` + +## Fee Discount Schedule Proposal + +**Steps** + +- `ValidateBasic` for proposal +- If Current Fee Discount Schedule exists, delete it along with Market Qualifications +- Defined quote denoms must exist. +- If a restart of the fee cycle is required (bucket count, bucket duration or quote denoms changed), delete all account fee buckets and restart cycle. +- Set the first fee paid bucket timestamp as the current block time +- Set New Fee Discount Schedule, delete it along with Market Qualifications +- Set New Market Qualifications diff --git a/.gitbook/developers/modules/injective/exchange/05_messages.md b/.gitbook/developers/modules/injective/exchange/05_messages.md new file mode 100644 index 00000000..75ad01c5 --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/05_messages.md @@ -0,0 +1,443 @@ +--- +sidebar_position: 6 +title: Messages +--- + +# Messages + +In this section we describe the processing of the exchange messages and the corresponding updates to the state. All +created/modified state objects specified by each message are defined within the [State Transitions](./04_state_transitions.md) +section. + +## Msg/Deposit + +`MsgDeposit` defines a SDK message for transferring coins from the sender's bank balance into the subaccount's exchange deposits. + +```go +type MsgDeposit struct { + Sender string + // (Optional) bytes32 subaccount ID to deposit funds into. If empty, the coin will be deposited to the sender's default + // subaccount address. + SubaccountId string + Amount types.Coin +} +``` + +**Fields description** + +- `Sender` field describes the address who deposits. +- `SubaccountId` describes the ID of a sub-account to receive a deposit. +- `Amount` specifies the deposit amount. + +## Msg/Withdraw + +`MsgWithdraw` defines a SDK message for withdrawing coins from a subaccount's deposits to the user's bank balance. + +```go +type MsgWithdraw struct { + Sender string + // bytes32 subaccount ID to withdraw funds from + SubaccountId string + Amount types.Coin +} +``` + +**Fields description** + +- `Sender` field describes the address to receive withdrawal. +- `SubaccountId` describes the ID of a sub-account to withdraw from. +- `Amount` specifies the withdrawal amount. + +## Msg/InstantSpotMarketLaunch + +`MsgInstantSpotMarketLaunch` defines a SDK message for creating a new spot market by paying listing fee without governance. The fee is sent to the community spend pool. + +```go +type MsgInstantSpotMarketLaunch struct { + Sender string + Ticker string + BaseDenom string + QuoteDenom string + MinPriceTickSize math.LegacyDec + MinQuantityTickSize math.LegacyDec + MinNotional math.LegacyDec +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Ticker` describes the ticker for the spot market. +- `BaseDenom` specifies the type of coin to use as the base currency. +- `QuoteDenom` specifies the type of coin to use as the quote currency. +- `MinPriceTickSize` defines the minimum tick size of the order's price. +- `MinQuantityTickSize` defines the minimum tick size of the order's quantity. + +## Msg/InstantPerpetualMarketLaunch + +`MsgInstantPerpetualMarketLaunch` defines a SDK message for creating a new perpetual futures market by paying listing fee without governance. The fee is sent to the community spend pool. + +```go +type MsgInstantPerpetualMarketLaunch struct { + Sender string + Ticker string + QuoteDenom string + OracleBase string + OracleQuote string + OracleScaleFactor uint32 + OracleType types1.OracleType + MakerFeeRate math.LegacyDec + TakerFeeRate math.LegacyDec + InitialMarginRatio math.LegacyDec + MaintenanceMarginRatio math.LegacyDec + MinPriceTickSize math.LegacyDec + MinQuantityTickSize math.LegacyDec + MinNotional math.LegacyDec +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Ticker` field describes the ticker for the derivative market. +- `QuoteDenom` field describes the type of coin to use as the base currency. +- `OracleBase` field describes the oracle base currency. +- `OracleQuote` field describes the oracle quote currency. +- `OracleScaleFactor` field describes the scale factor for oracle prices. +- `OracleType` field describes the oracle type. +- `MakerFeeRate` field describes the trade fee rate for makers on the derivative market. +- `TakerFeeRate` field describes the trade fee rate for takers on the derivative market. +- `InitialMarginRatio` field describes the initial margin ratio for the derivative market. +- `MaintenanceMarginRatio` field describes the maintenance margin ratio for the derivative market. +- `MinPriceTickSize` field describes the minimum tick size of the order's price and margin. +- `MinQuantityTickSize` field describes the minimum tick size of the order's quantity. + +## Msg/InstantExpiryFuturesMarketLaunch + +`MsgInstantExpiryFuturesMarketLaunch` defines a SDK message for creating a new expiry futures market by paying listing fee without governance. The fee is sent to the community spend pool. + +```go +type MsgInstantExpiryFuturesMarketLaunch struct { + Sender string + Ticker string + QuoteDenom string + OracleBase string + OracleQuote string + OracleType types1.OracleType + OracleScaleFactor uint32 + Expiry int64 + MakerFeeRate math.LegacyDec + TakerFeeRate math.LegacyDec + InitialMarginRatio math.LegacyDec + MaintenanceMarginRatio math.LegacyDec + MinPriceTickSize math.LegacyDec + MinQuantityTickSize math.LegacyDec + MinNotional math.LegacyDec +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Ticker` field describes the ticker for the derivative market. +- `QuoteDenom` field describes the type of coin to use as the quote currency. +- `OracleBase` field describes the oracle base currency. +- `OracleQuote` field describes the oracle quote currency. +- `OracleScaleFactor` field describes the scale factor for oracle prices. +- `OracleType` field describes the oracle type. +- `Expiry` field describes the expiration time of the market. +- `MakerFeeRate` field describes the trade fee rate for makers on the derivative market. +- `TakerFeeRate` field describes the trade fee rate for takers on the derivative market. +- `InitialMarginRatio` field describes the initial margin ratio for the derivative market. +- `MaintenanceMarginRatio` field describes the maintenance margin ratio for the derivative market. +- `MinPriceTickSize` field describes the minimum tick size of the order's price and margin. +- `MinQuantityTickSize` field describes the minimum tick size of the order's quantity. + +## Msg/CreateSpotLimitOrder + +`MsgCreateSpotLimitOrder` defines a SDK message for creating a new spot limit order. + +```go +type MsgCreateSpotLimitOrder struct { + Sender string + Order SpotOrder +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Order` field describes the order info. + +## Msg/BatchCreateSpotLimitOrders + +`MsgBatchCreateSpotLimitOrders` defines a SDK message for creating a new batch of spot limit orders. + +```go +type MsgBatchCreateSpotLimitOrders struct { + Sender string + Orders []SpotOrder +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Orders` field describes the orders info. + +## Msg/CreateSpotMarketOrder + +`MsgCreateSpotMarketOrder` defines a SDK message for creating a new spot market order. + +```go +type MsgCreateSpotMarketOrder struct { + Sender string + Order SpotOrder +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Order` field describes the order info. + +## Msg/CancelSpotOrder + +`MsgCancelSpotOrder` defines the message to cancel a spot order. + +```go +type MsgCancelSpotOrder struct { + Sender string + MarketId string + SubaccountId string + OrderHash string + Cid string +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `MarketId` field describes the id of the market where the order is placed. +- `SubaccountId` field describes the subaccount id that placed the order. +- `OrderHash` field describes the hash of the order. + +## Msg/BatchCancelSpotOrders + +`MsgBatchCancelSpotOrders` defines the message to cancel the spot orders in batch. + +```go +type MsgBatchCancelSpotOrders struct { + Sender string + Data []OrderData +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Data` field describes the orders to cancel. + +## Msg/CreateDerivativeLimitOrder + +`MsgCreateDerivativeLimitOrder` defines the message to create a derivative limit order. + +```go +type MsgCreateDerivativeLimitOrder struct { + Sender string + Order DerivativeOrder +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Order` field describes the order info. + +## Batch creation of derivative limit orders + +`MsgBatchCreateDerivativeLimitOrders` describes the batch creation of derivative limit orders. + +```go +type MsgBatchCreateDerivativeLimitOrders struct { + Sender string + Orders []DerivativeOrder +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Orders` field describes the orders info. + +## Msg/CreateDerivativeMarketOrder + +`MsgCreateDerivativeMarketOrder` is a message to create a derivative market order. + +```go +// A Cosmos-SDK MsgCreateDerivativeMarketOrder +type MsgCreateDerivativeMarketOrder struct { + Sender string + Order DerivativeOrder +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Order` field describes the order info. + +## Msg/CancelDerivativeOrder + +`MsgCancelDerivativeOrder` is a message to cancel a derivative order. + +```go +type MsgCancelDerivativeOrder struct { + Sender string + MarketId string + SubaccountId string + OrderHash string + OrderMask int32 + Cid string +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `MarketId` field describes the id of the market where the order is placed. +- `SubaccountId` field describes the subaccount id that placed the order. +- `OrderHash` field describes the hash of the order. + +## Msg/BatchCancelDerivativeOrders + +`MsgBatchCancelDerivativeOrders` is a message to cancel derivative orders in batch. + +```go +type MsgBatchCancelDerivativeOrders struct { + Sender string + Data []OrderData +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `Data` field describes the orders to cancel. + +## Msg/SubaccountTransfer + +`MsgSubaccountTransfer` is a message to transfer balance between sub-accounts. + +```go +type MsgSubaccountTransfer struct { + Sender string + SourceSubaccountId string + DestinationSubaccountId string + Amount types.Coin +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `SourceSubaccountId` field describes a source subaccount to send coins from. +- `DestinationSubaccountId` field describes a destination subaccount to send coins to. +- `Amount` field describes the amount of coin to send. + +## Msg/ExternalTransfer + +`MsgExternalTransfer` is a message to transfer balance from one of source account to external sub-account. + +```go +type MsgExternalTransfer struct { + Sender string + SourceSubaccountId string + DestinationSubaccountId string + Amount types.Coin +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `SourceSubaccountId` field describes a source subaccount to send coins from. +- `DestinationSubaccountId` field describes a destination subaccount to send coins to. +- `Amount` field describes the amount of coin to send. + +## Msg/LiquidatePosition + +`MsgLiquidatePosition` describes a message to liquidate an account's position + +```go +type MsgLiquidatePosition struct { + Sender string + SubaccountId string + MarketId string + // optional order to provide for liquidation + Order *DerivativeOrder +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `SubaccountId` field describes a subaccount to receive liquidation amount. +- `MarketId` field describes a market where the position is in. +- `Order` field describes the order info. + +## Msg/IncreasePositionMargin + +`MsgIncreasePositionMargin` describes a message to increase margin of an account. + +```go +// A Cosmos-SDK MsgIncreasePositionMargin +type MsgIncreasePositionMargin struct { + Sender string + SourceSubaccountId string + DestinationSubaccountId string + MarketId string + // amount defines the amount of margin to add to the position + Amount math.LegacyDec +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `SourceSubaccountId` field describes a source subaccount to send balance from. +- `DestinationSubaccountId` field describes a destination subaccount to receive balance. +- `MarketId` field describes a market where positions are in. +- `Amount` field describes amount to increase. + + + +## Msg/BatchUpdateOrders + +`MsgBatchUpdateOrders` allows for the atomic cancellation and creation of spot and derivative limit orders, along with a new order cancellation mode. Upon execution, order cancellations (if any) occur first, followed by order creations (if any). + +```go +// A Cosmos-SDK MsgBatchUpdateOrders +// SubaccountId only used for the spot_market_ids_to_cancel_all and derivative_market_ids_to_cancel_all. +type MsgBatchUpdateOrders struct { + Sender string + SubaccountId string + SpotMarketIdsToCancelAll []string + DerivativeMarketIdsToCancelAll []string + SpotOrdersToCancel []OrderData + DerivativeOrdersToCancel []OrderData + SpotOrdersToCreate []SpotOrder + DerivativeOrdersToCreate []DerivativeOrder +} +``` + +**Fields description** + +- `Sender` field describes the creator of this msg. +- `SubaccountId` field describes the sender's sub-account ID. +- `SpotMarketIdsToCancelAll` field describes a list of spot market IDs for which the sender wants to cancel all open orders. +- `DerivativeMarketIdsToCancelAll` field describes a list of derivative market IDs for which the sender wants to cancel all open orders. +- `SpotOrdersToCancel` field describes specific spot orders the sender wants to cancel. +- `DerivativeOrdersToCancel` field describes specific derivative orders the sender wants to cancel. +- `SpotOrdersToCreate` field describes spot orders the sender wants to create. +- `DerivativeOrdersToCreate` field describes derivative orders the sender wants to create. diff --git a/.gitbook/developers/modules/injective/exchange/06_proposals.md b/.gitbook/developers/modules/injective/exchange/06_proposals.md new file mode 100644 index 00000000..b0e1a33a --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/06_proposals.md @@ -0,0 +1,404 @@ +--- +sidebar_position: 7 +title: Governance Proposals +--- + +# Governance Proposals + +## Proposal/SpotMarketParamUpdate + +`SpotMarketParamUpdateProposal` defines an SDK message to propose an update of spot market params. + +```go +type SpotMarketParamUpdateProposal struct { + Title string + Description string + MarketId string + MakerFeeRate *math.LegacyDec + TakerFeeRate *math.LegacyDec + RelayerFeeShareRate *math.LegacyDec + MinPriceTickSize *math.LegacyDec + MinQuantityTickSize *math.LegacyDec + MinNotional *math.LegacyDec + Status MarketStatus +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `MarketId` describes the id of the market to change params. +- `MakerFeeRate` describes the target fee rate for makers. +- `TakerFeeRate` describes the target fee rate for takers. +- `RelayerFeeShareRate` describes the relayer fee share rate. +- `MinPriceTickSize` defines the minimum tick size of the order's price. +- `MinQuantityTickSize` defines the minimum tick size of the order's quantity. +- `Status` describes the target status of the market. + +## Proposal/ExchangeEnable + +`ExchangeEnableProposal` defines a message to propose enable of specific exchange type. + +```go +type ExchangeEnableProposal struct { + Title string + Description string + ExchangeType ExchangeType +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `ExchangeType` describes the type of exchange, spot or derivatives. + + +## Proposal/BatchExchangeModification + +`BatchExchangeModificationProposal` defines a message to batch multiple proposals in the exchange module. + +```go +type BatchExchangeModificationProposal struct { + Title string + Description string + SpotMarketParamUpdateProposal []*SpotMarketParamUpdateProposal + DerivativeMarketParamUpdateProposal []*DerivativeMarketParamUpdateProposal + SpotMarketLaunchProposal []*SpotMarketLaunchProposal + PerpetualMarketLaunchProposal []*PerpetualMarketLaunchProposal + ExpiryFuturesMarketLaunchProposal []*ExpiryFuturesMarketLaunchProposal + TradingRewardCampaignUpdateProposal *TradingRewardCampaignUpdateProposal +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `SpotMarketParamUpdateProposal` describes the SpotMarketParamUpdateProposal. +- `DerivativeMarketParamUpdateProposal` describes the DerivativeMarketParamUpdateProposal. +- `SpotMarketLaunchProposal` describes the SpotMarketLaunchProposal. +- `PerpetualMarketLaunchProposal` describes the PerpetualMarketLaunchProposal. +- `ExpiryFuturesMarketLaunchProposal` describes the ExpiryFuturesMarketLaunchProposal. +- `TradingRewardCampaignUpdateProposal` describes the TradingRewardCampaignUpdateProposal. + + +## Proposal/SpotMarketLaunch + +`SpotMarketLaunchProposal` defines an SDK message for proposing a new spot market through governance. + +```go +type SpotMarketLaunchProposal struct { + Title string + Description string + Ticker string + BaseDenom string + QuoteDenom string + MinPriceTickSize math.LegacyDec + MinQuantityTickSize math.LegacyDec + MinNotional math.LegacyDec + MakerFeeRate math.LegacyDec + TakerFeeRate math.LegacyDec +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `Ticker` describes the ticker for the spot market. +- `BaseDenom` specifies the type of coin to use as the base currency. +- `QuoteDenom` specifies the type of coin to use as the quote currency. +- `MinPriceTickSize` defines the minimum tick size of the order's price. +- `MinQuantityTickSize` defines the minimum tick size of the order's quantity. +- `MakerFeeRate` field describes the trade fee rate for makers on the derivative market. +- `TakerFeeRate` field describes the trade fee rate for takers on the derivative market. + +## Proposal/PerpetualMarketLaunch + +`PerpetualMarketLaunchProposal` defines an SDK message for proposing a new perpetual futures market through governance. + +```go +type PerpetualMarketLaunchProposal struct { + Title string + Description string + Ticker string + QuoteDenom string + OracleBase string + OracleQuote string + OracleScaleFactor uint32 + OracleType types1.OracleType + InitialMarginRatio math.LegacyDec + MaintenanceMarginRatio math.LegacyDec + MakerFeeRate math.LegacyDec + TakerFeeRate math.LegacyDec + MinPriceTickSize math.LegacyDec + MinQuantityTickSize math.LegacyDec +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `Ticker` field describes the ticker for the derivative market. +- `QuoteDenom` field describes the type of coin to use as the base currency. +- `OracleBase` field describes the oracle base currency. +- `OracleQuote` field describes the oracle quote currency. +- `OracleScaleFactor` field describes the scale factor for oracle prices. +- `OracleType` field describes the oracle type. +- `MakerFeeRate` field describes the trade fee rate for makers on the derivative market. +- `TakerFeeRate` field describes the trade fee rate for takers on the derivative market. +- `InitialMarginRatio` field describes the initial margin ratio for the derivative market. +- `MaintenanceMarginRatio` field describes the maintenance margin ratio for the derivative market. +- `MinPriceTickSize` field describes the minimum tick size of the order's price and margin. +- `MinQuantityTickSize` field describes the minimum tick size of the order's quantity. + +## Expiry futures market launch proposal + +```go +// ExpiryFuturesMarketLaunchProposal defines an SDK message for proposing a new expiry futures market through governance +type ExpiryFuturesMarketLaunchProposal struct { + Title string + Description string + // Ticker for the derivative market. + Ticker string + // type of coin to use as the quote currency + QuoteDenom string + // Oracle base currency + OracleBase string + // Oracle quote currency + OracleQuote string + // Scale factor for oracle prices. + OracleScaleFactor uint32 + // Oracle type + OracleType types1.OracleType + // Expiration time of the market + Expiry int64 + // initial_margin_ratio defines the initial margin ratio for the derivative market + InitialMarginRatio math.LegacyDec + // maintenance_margin_ratio defines the maintenance margin ratio for the derivative market + MaintenanceMarginRatio math.LegacyDec + // maker_fee_rate defines the exchange trade fee for makers for the derivative market + MakerFeeRate math.LegacyDec + // taker_fee_rate defines the exchange trade fee for takers for the derivative market + TakerFeeRate math.LegacyDec + // min_price_tick_size defines the minimum tick size of the order's price and margin + MinPriceTickSize math.LegacyDec + // min_quantity_tick_size defines the minimum tick size of the order's quantity + MinQuantityTickSize math.LegacyDec + // min_notional defines the minimum notional (in quote asset) required for orders in the market + MinNotional math.LegacyDec +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `Ticker` field describes the ticker for the derivative market. +- `QuoteDenom` field describes the type of coin to use as the quote currency. +- `OracleBase` field describes the oracle base currency. +- `OracleQuote` field describes the oracle quote currency. +- `OracleScaleFactor` field describes the scale factor for oracle prices. +- `OracleType` field describes the oracle type. +- `Expiry` field describes the expiration time of the market. +- `MakerFeeRate` field describes the trade fee rate for makers on the derivative market. +- `TakerFeeRate` field describes the trade fee rate for takers on the derivative market. +- `InitialMarginRatio` field describes the initial margin ratio for the derivative market. +- `MaintenanceMarginRatio` field describes the maintenance margin ratio for the derivative market. +- `MinPriceTickSize` field describes the minimum tick size of the order's price and margin. +- `MinQuantityTickSize` field describes the minimum tick size of the order's quantity. + +## Binary options market launch proposal + +```go +type BinaryOptionsMarketLaunchProposal struct { + Title string + Description string + // Ticker for the derivative contract. + Ticker string + // Oracle symbol + OracleSymbol string + // Oracle Provider + OracleProvider string + // Oracle type + OracleType types1.OracleType + // Scale factor for oracle prices. + OracleScaleFactor uint32 + // expiration timestamp + ExpirationTimestamp int64 + // expiration timestamp + SettlementTimestamp int64 + // admin of the market + Admin string + // Address of the quote currency denomination for the binary options contract + QuoteDenom string + // maker_fee_rate defines the maker fee rate of a binary options market + MakerFeeRate math.LegacyDec + // taker_fee_rate defines the taker fee rate of a derivative market + TakerFeeRate math.LegacyDec + // min_price_tick_size defines the minimum tick size that the price and margin required for orders in the market + MinPriceTickSize math.LegacyDec + // min_quantity_tick_size defines the minimum tick size of the quantity required for orders in the market + MinQuantityTickSize math.LegacyDec +} +``` + +## Binary options market param update + +```go +type BinaryOptionsMarketParamUpdateProposal struct { + Title string + Description string + MarketId string + // maker_fee_rate defines the exchange trade fee for makers for the derivative market + MakerFeeRate *math.LegacyDec + // taker_fee_rate defines the exchange trade fee for takers for the derivative market + TakerFeeRate *math.LegacyDec + // relayer_fee_share_rate defines the relayer fee share rate for the derivative market + RelayerFeeShareRate *math.LegacyDec + // min_price_tick_size defines the minimum tick size of the order's price and margin + MinPriceTickSize *math.LegacyDec + // min_quantity_tick_size defines the minimum tick size of the order's quantity + MinQuantityTickSize *math.LegacyDec + // min_notional defines the minimum notional for orders + MinNotional *math.LegacyDec + // expiration timestamp + ExpirationTimestamp int64 + // expiration timestamp + SettlementTimestamp int64 + // new price at which market will be settled + SettlementPrice *math.LegacyDec + // admin of the market + Admin string + Status MarketStatus + OracleParams *ProviderOracleParams +} +``` + +## Proposal/DerivativeMarketParamUpdate + +```go +type OracleParams struct { + // Oracle base currency + OracleBase string + // Oracle quote currency + OracleQuote string + // Scale factor for oracle prices. + OracleScaleFactor uint32 + // Oracle type + OracleType types1.OracleType +} + +type DerivativeMarketParamUpdateProposal struct { + Title string + Description string + MarketId string + InitialMarginRatio *math.LegacyDec + MaintenanceMarginRatio *math.LegacyDec + MakerFeeRate *math.LegacyDec + TakerFeeRate *math.LegacyDec + RelayerFeeShareRate *math.LegacyDec + MinPriceTickSize *math.LegacyDec + MinQuantityTickSize *math.LegacyDec + MinNotional *math.LegacyDec + HourlyInterestRate *math.LegacyDec + HourlyFundingRateCap *math.LegacyDec + Status MarketStatus + OracleParams *OracleParams +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `MarketId` describes the id of the market to change params. +- `InitialMarginRatio` describes the target initial margin ratio. +- `MaintenanceMarginRatio` describes the target maintenance margin ratio. +- `MakerFeeRate` describes the target fee rate for makers. +- `TakerFeeRate` describes the target fee rate for takers. +- `RelayerFeeShareRate` describes the relayer fee share rate. +- `MinPriceTickSize` defines the minimum tick size of the order's price. +- `MinQuantityTickSize` defines the minimum tick size of the order's quantity. +- `Status` describes the target status of the market. +- `OracleParams` describes the new oracle parameters. + +## Proposal/TradingRewardCampaignLaunch + +`TradingRewardCampaignLaunchProposal` defines an SDK message for proposing to launch a new trading reward campaign. + +```go +type TradingRewardCampaignLaunchProposal struct { + Title string + Description string + CampaignInfo *TradingRewardCampaignInfo + CampaignRewardPools []*CampaignRewardPool +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `CampaignInfo` describes the CampaignInfo. +- `CampaignRewardPools` describes the CampaignRewardPools. + +## Proposal/TradingRewardCampaignUpdate + +`TradingRewardCampaignUpdateProposal` defines an SDK message for proposing to update an existing trading reward campaign. + +```go +type TradingRewardCampaignUpdateProposal struct { + Title string + Description string + CampaignInfo *TradingRewardCampaignInfo + CampaignRewardPoolsAdditions []*CampaignRewardPool + CampaignRewardPoolsUpdates []*CampaignRewardPool +} +``` + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `CampaignRewardPoolsAdditions` describes the CampaignRewardPoolsAdditions. +- `CampaignRewardPoolsUpdates` describes the CampaignRewardPoolsUpdates. + +## Proposal/FeeDiscount + +`FeeDiscountProposal` defines an SDK message for proposing to launch or update a fee discount schedule. + +```go +type FeeDiscountProposal struct { + Title string + Description string + Schedule *FeeDiscountSchedule +} +``` + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `Schedule` describes the Fee discount schedule. + +## Proposal/TradingRewardPendingPointsUpdate + +`TradingRewardPendingPointsUpdateProposal` defines an SDK message to update reward points for certain addresses during the vesting period. + +```go +type TradingRewardPendingPointsUpdateProposal struct { + Title string + Description string + PendingPoolTimestamp int64 + RewardPointUpdates *[]RewardPointUpdate +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `PendingPoolTimestamp` describes timestamp of the pending pool. +- `RewardPointUpdates` describes the RewardPointUpdate. + + diff --git a/.gitbook/developers/modules/injective/exchange/07_begin_block.md b/.gitbook/developers/modules/injective/exchange/07_begin_block.md new file mode 100644 index 00000000..6d0f1bf8 --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/07_begin_block.md @@ -0,0 +1,74 @@ +--- +sidebar_position: 8 +title: BeginBlocker +--- + +# BeginBlocker + +The exchange [BeginBlocker](https://docs.cosmos.network/master/building-modules/beginblock-endblock.html) runs at the start of every block in our defined order as the last module. + +### 1. Process Hourly Fundings + +1. Check the first to receive funding payments market. If the first market is not yet due to receive fundings (funding timestamp not reached), skip all fundings. +2. Otherwise go through each market one by one: + 1. Skip market if funding timestamp is not yet reached. + 2. Compute funding as `twap + hourlyInterestRate` where $\mathrm{twap = \frac{cumulativePrice}{timeInterval * 24}}$ with $\mathrm{timeInterval = lastTimestamp - startingTimestamp}$. The `cumulativePrice` is previously calculated with every trade as the time weighted difference between VWAP and mark price: $\mathrm{\frac{VWAP - markPrice}{markPrice} * timeElapsed}$. + 3. Cap funding if required to the maximum defined by `HourlyFundingRateCap`. + 4. Set next funding timestamp. + 5. Emit `EventPerpetualMarketFundingUpdate`. + +### 2. Process Markets Scheduled to Settle + +For each market in the list of markets to settle: + +1. Settle market with zero closing fee and current mark price. + 1. Run socialized loss. This will calculate the total amount of funds missing in all of the market and then reduce the payout proportionally for each profitable position. For example a market with a total amount of 100 USDT missing funds and 10 profitable positions with identical quantity would result in a payout reduction of 10 USDT for each of the positions. + 2. All positions are forcibly closed. +2. Delete from storage. + +### 3. Process Matured Expiry Future Markets + +For each time expiry market, iterate through starting with first to expire: + +1. If market is premature, stop iteration. +2. If market is disabled, delete market from storage and go to next market. +3. Get cumulative price for the market from oracle. +4. If market is starting maturation, store `startingCumulativePrice` for market. +5. If market is matured, calculate the settlement price as $\mathrm{twap = (currentCumulativePrice - startingCumulativePrice) / twapWindow}$ and add to list of markets to be settled. +6. Settle all matured markets with defined closing fee and settlement price. The procedure is identical to the previous process of settling (see above). Note that the socialized loss is an optional step. In the regular case a market will not require any socialized loss. +7. Delete any settled markets from storage. + +### 4. Process Trading Rewards + +1. Check if the current trading rewards campaign is finished. +2. If the campaign is finished, distribute reward tokens to eligible traders. + + 1. Compute the available reward for each reward denom as `min(campaignRewardTokens, communityPoolRewardTokens)` + 2. Get the trader rewards based on the trading share from the respective trader calculated as `accountPoints * totalReward / totalTradingRewards`. + 3. Send reward tokens from community pool to trader. + 4. Reset total and all account trading reward points. + 5. Delete the current campaign ending timestamp. + +3. If a new campaign is launched, set the next current campaign ending timestamp as `CurrentCampaignStartTimestamp + CampaignDurationSeconds`. +4. If no current campaign is ongoing and no new campaigns are launched, delete campaign info, market qualifications and market multipliers from storage. + +### 5. Process Fee Discount Buckets + +- If the oldest bucket's end timestamp is older than the `block.timestamp - bucketCount * bucketDuration`: + - Prune the oldest bucket + - Iterate over all `bucketStartTimestamp + account → FeesPaidAmount`: + - Subtract the `FeesPaidAmount` from each account's `totalPastBucketFeesPaidAmount` + - Delete the account's `account → {tier, TTL timestamp}`. Note that this technically isn't necessary for correctness since we check the TTL timestamps in the Endblocker but is a state pruning strategy. + - Update the `CurrBucketStartTimestamp ← CurrBucketStartTimestamp + BucketDuration`. + +``` +bucket count 5 and with 100 sec duration + +120 220 320 420 520 220 320 420 520 620 + | | | | | | --> | | | | | | + 1 2 3 4 5 1 2 3 4 5 + +Current block.timestamp of 621: +621 - 5*100 = 121 +120 is older than 121, so prune the last bucket and create a new bucket. +``` diff --git a/.gitbook/developers/modules/injective/exchange/08_end_block.md b/.gitbook/developers/modules/injective/exchange/08_end_block.md new file mode 100644 index 00000000..b536c118 --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/08_end_block.md @@ -0,0 +1,78 @@ +--- +sidebar_position: 9 +title: EndBlocker +--- + +# EndBlocker + +The exchange [EndBlocker](https://docs.cosmos.network/master/building-modules/beginblock-endblock.html) runs at the end of every block in our defined order after governance and staking modules, and before the peggy, auction and insurance modules. It is particularly important that the governance module's EndBlocker runs before the exchange module's. + +- Stage 0: Determine the fee discounts for all the accounts that have placed an order in a fee-discount supported market in the current block. +- Stage 1: Process all market orders in parallel - spot market and derivative market orders + - Markets orders are executed against the resting orderbook at the time of the beginning of the block. + - Note that market orders may be invalidated in the EndBlocker due to subsequently incoming oracle updates or limit order cancels. +- Stage 2: Persist market order execution to store + + - Spot Markets + - Persist Spot market order execution data + - Emit relevant events + - `EventBatchSpotExecution` + - Derivative Markets + - Persist Derivative market order execution data + - Emit relevant events + - `EventBatchDerivativeExecution` + - `EventCancelDerivativeOrder` + +- Stage 3: Process all limit orders in parallel - spot and derivative limit orders that are matching + - Limit orders are executed in a frequent batch auction mode to ensure fair matching prices, see below for details. + - Note that vanilla limit orders may be invalidated in the EndBlocker due to subsequently incoming oracle updates and reduce-only limit orders may be invalidated in the EndBlocker due to subsequently incoming orders which flip a position. +- Stage 4: Persist limit order matching execution + new limit orders to store + + - Spot Markets + - Persist Spot Matching execution data + - Emit relevant events + - `EventNewSpotOrders` + - `EventBatchSpotExecution` + - Derivative Markets + - Persist Derivative Matching execution data + - Emit relevant events + - `EventNewDerivativeOrders` + - `EventBatchDerivativeExecution` + - `EventCancelDerivativeOrder` + +- Stage 5: Persist perpetual market funding info +- Stage 6: Persist trading rewards total and account points. +- Stage 7: Persist new fee discount data, i.e., new fees paid additions and new account tiers. +- Stage 8: Process Spot Market Param Updates if any +- Stage 9: Process Derivative Market Param Updates if any +- Stage 10: Emit Deposit and Position Update Events + +## Order Matching: Frequent Batch Auction (FBA) + +The goal of FBA is to prevent any [Front-Running](https://www.investopedia.com/terms/f/frontrunning.asp). This is achieved by calculating a single clearing price for all matched orders in a given block. + +1. Market orders are filled first against the resting orderbook at the time of the beginning of the block. While the resting orders are filled at their respective order prices, the market orders are all filled at a uniform clearing price with the same mechanism as limit orders. For an example for the market order matching in FBA fashion, look at the API docs [here](https://api.injective.exchange/#examples-market-order-matching). +2. Likewise limit orders are filled at a uniform clearing price. New limit orders are combined with the resting orderbook and orders are matched as long as there is still negative spread. The clearing price is either + +a. the best buy/sell order in case the last matched order crosses the spread in that direction, the, +b. the mark price in case of derivative markets and the mark price is between the last matched orders or +c. the mid price. + +For an example for the limit order matching in FBA fashion, look at the API docs [here](https://api.injective.exchange/#examples-limit-order-matching). + +## Single Trade Calculations + +- For a qualifying market compute the fee discounts: + - Fee discounts are applied as refunds and the fee paid contribution is recorded. + - Relayer fees are applied AFTER the fee discount is taken. +- For a qualifying market compute the trade reward point contribution: + - Obtain the FeePaidMultiplier for maker and taker. + - Compute the trade reward point contribution. + - Trade reward points are based on the discounted trading fee. +- Calculate fee refunds (or charges). There are several reasons why an order might get a fee refund after matching: + 1. It's a limit order which is not matched or only partially matched which means it will become a resting limit order and switch from a taker to maker fee. The refund is `UnmatchedQuantity * (TakerFeeRate - MakerFeeRate)`. Note that for negative maker fees, we refund the `UnmatchedQuantity * TakerFeeRate` instead. + 2. Fee discounts are applied. We refund the difference between the original fee paid and the fee paid after the discount. + 3. The order is matched at a better price resulting in a different fee. + - For buy orders a better price means a lower price and thus a lower fee. We refund the fee price delta. + - For sell orders a better price means a higher price and thus a higher fee. We charge the fee price delta. + - You can find the respective code with an example [here](https://github.com/InjectiveLabs/injective-core/blob/80dbc4e9558847ff0354be5d19a4d8b0bba7da96/injective-chain/modules/exchange/keeper/derivative_orders_processor.go#L502). Please check the master branch for the latest chain code. diff --git a/.gitbook/developers/modules/injective/exchange/09_events.md b/.gitbook/developers/modules/injective/exchange/09_events.md new file mode 100644 index 00000000..09008054 --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/09_events.md @@ -0,0 +1,169 @@ +--- +sidebar_position: 10 +title: Events +--- + +# Events + +The exchange module emits the following events: + +```proto +message EventBatchSpotExecution { + string market_id = 1; + bool is_buy = 2; + ExecutionType executionType = 3; + repeated TradeLog trades = 4; +} + +message EventBatchDerivativeExecution { + string market_id = 1; + bool is_buy = 2; + bool is_liquidation = 3; + // nil for time expiry futures + string cumulative_funding = 4 [ + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = true + ]; + ExecutionType executionType = 5; + repeated DerivativeTradeLog trades = 6; +} + +message EventLostFundsFromLiquidation { + string market_id = 1; + bytes subaccount_id = 2; + string lost_funds_from_available_during_payout = 3 [ + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false + ]; + string lost_funds_from_order_cancels = 4 [ + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false + ]; +} + +message EventBatchDerivativePosition { + string market_id = 1; + repeated SubaccountPosition positions = 2; +} + +message EventDerivativeMarketPaused { + string market_id = 1; + string settle_price = 2; + string total_missing_funds = 3; + string missing_funds_rate = 4; +} + +message EventBinaryOptionsMarketUpdate { + BinaryOptionsMarket market = 1 [ + (gogoproto.nullable) = false + ]; +} + +message EventNewSpotOrders { + string market_id = 1; + repeated SpotLimitOrder buy_orders = 2; + repeated SpotLimitOrder sell_orders = 3; +} + +message EventNewDerivativeOrders { + string market_id = 1; + repeated DerivativeLimitOrder buy_orders = 2; + repeated DerivativeLimitOrder sell_orders = 3; +} + +message EventCancelSpotOrder { + string market_id = 1; + SpotLimitOrder order = 2 [ + (gogoproto.nullable) = false + ]; +} + +message EventSpotMarketUpdate { + SpotMarket market = 1 [ + (gogoproto.nullable) = false + ]; +} + +message EventPerpetualMarketUpdate { + DerivativeMarket market = 1 [ + (gogoproto.nullable) = false + ]; + PerpetualMarketInfo perpetual_market_info = 2[ + (gogoproto.nullable) = true + ]; + PerpetualMarketFunding funding = 3[ + (gogoproto.nullable) = true + ]; +} + +message EventExpiryFuturesMarketUpdate { + DerivativeMarket market = 1 [ + (gogoproto.nullable) = false + ]; + ExpiryFuturesMarketInfo expiry_futures_market_info = 3[ + (gogoproto.nullable) = true + ]; +} + +message EventPerpetualMarketFundingUpdate { + string market_id = 1; + PerpetualMarketFunding funding = 2[ + (gogoproto.nullable) = false + ]; + bool is_hourly_funding = 3; + string funding_rate = 4 [ + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = true + ]; + string mark_price = 5 [ + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = true + ]; +} + +message EventSubaccountDeposit { + string src_address = 1; + bytes subaccount_id = 2; + cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false]; +} + +message EventSubaccountWithdraw { + bytes subaccount_id = 1; + string dst_address = 2; + cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false]; +} + +message EventSubaccountBalanceTransfer { + string src_subaccount_id = 1; + string dst_subaccount_id = 2; + cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false]; +} + +message EventBatchDepositUpdate { + repeated DepositUpdate deposit_updates = 1; +} + +message EventCancelDerivativeOrder { + string market_id = 1; + bool isLimitCancel = 2; + DerivativeLimitOrder limit_order = 3 [ + (gogoproto.nullable) = true + ]; + DerivativeMarketOrderCancel market_order_cancel = 4 [ + (gogoproto.nullable) = true + ]; +} + +message EventFeeDiscountSchedule { + FeeDiscountSchedule schedule = 1; +} + +message EventTradingRewardCampaignUpdate { + TradingRewardCampaignInfo campaign_info = 1; + repeated CampaignRewardPool campaign_reward_pools = 2; +} + +message EventTradingRewardDistribution { + repeated AccountRewards account_rewards = 1; +} +``` diff --git a/.gitbook/developers/modules/injective/exchange/10_params.md b/.gitbook/developers/modules/injective/exchange/10_params.md new file mode 100644 index 00000000..8dcdf5d1 --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/10_params.md @@ -0,0 +1,35 @@ +--- +sidebar_position: 11 +title: Parameters +--- + +# Parameters + +The exchange module contains the following parameters: + +| Key | Type | Example | +| ------------------------------------------- | -------- | ------------------ | +| SpotMarketInstantListingFee | sdk.Coin | 100inj | +| DerivativeMarketInstantListingFee | sdk.Coin | 1000inj | +| DefaultSpotMakerFeeRate | math.LegacyDec | 0.1% | +| DefaultSpotTakerFeeRate | math.LegacyDec | 0.2% | +| DefaultDerivativeMakerFeeRate | math.LegacyDec | 0.1% | +| DefaultDerivativeTakerFeeRate | math.LegacyDec | 0.2% | +| DefaultInitialMarginRatio | math.LegacyDec | 5% | +| DefaultMaintenanceMarginRatio | math.LegacyDec | 2% | +| DefaultFundingInterval | int64 | 3600 | +| FundingMultiple | int64 | 3600 | +| RelayerFeeShareRate | math.LegacyDec | 40% | +| DefaultHourlyFundingRateCap | math.LegacyDec | 0.0625% | +| DefaultHourlyInterestRate | math.LegacyDec | 0.000416666% | +| MaxDerivativeOrderSideCount | int64 | 20 | +| InjRewardStakedRequirementThreshold | sdk.Coin | 25inj | +| TradingRewardsVestingDuration | int64 | 1209600 | +| LiquidatorRewardShareRate | math.LegacyDec | 0.05% | +| BinaryOptionsMarketInstantListingFee | sdk.Coin | 10inj | +| AtomicMarketOrderAccessLevel | string | SmartContractsOnly | +| SpotAtomicMarketOrderFeeMultiplier | math.LegacyDec | 2x | +| DerivativeAtomicMarketOrderFeeMultiplier | math.LegacyDec | 2x | +| BinaryOptionsAtomicMarketOrderFeeMultiplier | math.LegacyDec | 2x | +| MinimalProtocolFeeRate | math.LegacyDec | 0.00001% | +| IsInstantDerivativeMarketLaunchEnabled | bool | false | diff --git a/.gitbook/developers/modules/injective/exchange/11_msg_privileged_execute_contract.md b/.gitbook/developers/modules/injective/exchange/11_msg_privileged_execute_contract.md new file mode 100644 index 00000000..16995856 --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/11_msg_privileged_execute_contract.md @@ -0,0 +1,127 @@ +--- +sidebar_position: 12 +title: MsgPrivilegedExecuteContract +--- + +# MsgPrivilegedExecuteContract + +MsgPrivilegedExecuteContract defines a method for executing a Cosmwasm contract from the exchange module with privileged capabilities. + +```go +type MsgPrivilegedExecuteContract struct { + Sender string + // funds defines the user's bank coins used to fund the execution (e.g. 100inj). + Funds github_com_cosmos_cosmos_sdk_types.Coins + // contract_address defines the contract address to execute + ContractAddress string + // data defines the call data used when executing the contract + Data string +} + +``` + +**Fields description** + +- `Sender` describes the creator of this msg. +- `Funds` defines the user's bank coins used to fund the execution (e.g. 100inj). +- `ContractAddress` defines the contract address to execute. +- `Data` defines the call data used when executing the contract, see further details below. + +**Contract Interface** + +If you want to enable privileged actions on your contract, you must implement the following execute method: + +```rust +InjectiveExec { + origin: String, + name: String, + args: MyArgs, +} +``` + +- The `origin` field is the address of the user who sent the privileged action. You don't have to set this field yourself, it will be set by the exchange module. +- The `name` field is the name of the privileged action. You can define these to be whatever you want. +- The `args` field is the arguments of the privileged action. You can define these to be whatever you want. + +A complete definition of the Data string in Golang is: + +```go +type ExecutionData struct { + Origin string `json:"origin"` + Name string `json:"name"` + MyArgs interface{} `json:"args"` +} +``` + +A user can then call the privileged action by sending a `MsgPrivilegedExecuteContract` with the following data: + +```json +{ + sender: "inj...", + funds: "1000000000000000000inj", + contract_address: "inj...", + data: { + origin: "inj...", + name: "my_privileged_action", + args: { + ... + } + } +} +``` + +**Supported Privileged Actions** + +There are currently two supported privileged actions: + +```go +type PrivilegedAction struct { + SyntheticTrade *SyntheticTradeAction `json:"synthetic_trade"` + PositionTransfer *PositionTransfer `json:"position_transfer"` +} +``` + +These privileged actions must be set inside the Cosmwasm response data field, e.g.: + +```rust +let privileged_action = PrivilegedAction { + synthetic_trade: None, + position_transfer: position_transfer_action, +}; +response = response.set_data(to_binary(&privileged_action)?); +``` + +**PositionTransfer** + +The position transfer allows a contract to transfer a derivative position from its own subaccount to a user's subaccount. The position may not be liquidable. Solely the receiver pays a taker trading fee deducted from his balances. + +Currently only transfers from the contract's subaccount to a user's subaccount are supported. + +```go +type PositionTransfer struct { + MarketID common.Hash `json:"market_id"` + SourceSubaccountID common.Hash `json:"source_subaccount_id"` + DestinationSubaccountID common.Hash `json:"destination_subaccount_id"` + Quantity math.LegacyDec `json:"quantity"` +} +``` + +**SyntheticTrade** + +The synthetic trade allows a contract to execute a synthetic trade on behalf of a user for derivative markets. This is not touching the orderbook and is purely a synthetic trade. Taker trading fees still apply. The subaccount ids must be set to the contract's subaccount id and the user's subaccount id. + +```go +type SyntheticTradeAction struct { + UserTrades []*SyntheticTrade `json:"user_trades"` + ContractTrades []*SyntheticTrade `json:"contract_trades"` +} + +type SyntheticTrade struct { + MarketID common.Hash `json:"market_id"` + SubaccountID common.Hash `json:"subaccount_id"` + IsBuy bool `json:"is_buy"` + Quantity math.LegacyDec `json:"quantity"` + Price math.LegacyDec `json:"price"` + Margin math.LegacyDec `json:"margin"` +} +``` diff --git a/.gitbook/developers/modules/injective/exchange/README.md b/.gitbook/developers/modules/injective/exchange/README.md new file mode 100644 index 00000000..d9c8423d --- /dev/null +++ b/.gitbook/developers/modules/injective/exchange/README.md @@ -0,0 +1,29 @@ +# `Exchange` + +## Abstract + +The `exchange` module is the heart of the Injective Chain which enables fully decentralized spot and derivative exchange. +It is the _sine qua non_ module of the chain and integrates tightly with the `auction`, `insurance`, `oracle`, and `peggy` modules. + +The exchange protocol enables traders to create and trade on arbitrary spot and derivative markets. +The entire process of orderbook management, trade execution, order matching and settlement occurs on chain through the logic codified by the exchange module. + +The `exchange` module enables the exchange of tokens on two types of markets: + +1. `Derivative Market`: Either a `Perpetual Swap Market` or a `Futures Market`. +2. `Spot Market` + +## Contents + +1. **[Derivative Market Concepts](00_derivative_market_concepts.md)** +2. **[Spot Market Concepts](01_spot_market_concepts.md)** +3. **[Other Concepts](02_other_concepts.md)** +4. **[State](03_state.md)** +5. **[State Transitions](04_state_transitions.md)** +6. **[Messages](05_messages.md)** +7. **[Proposals](06_proposals.md)** +8. **[Begin Block](07_begin_block.md)** +9. **[End Block](08_end_block.md)** +10. **[Events](09_events.md)** +11. **[Params](10_params.md)** +12. **[MsgPrivilegedExecuteContract](11_msg_privileged_execute_contract.md)** diff --git a/.gitbook/developers/modules/injective/insurance/01_state.md b/.gitbook/developers/modules/injective/insurance/01_state.md new file mode 100644 index 00000000..b7c3402c --- /dev/null +++ b/.gitbook/developers/modules/injective/insurance/01_state.md @@ -0,0 +1,92 @@ +--- +sidebar_position: 1 +title: State +--- + +# State + +## Params + +`Params` is a module-wide configuration structure that stores system parameters and defines overall functioning of the insurance module. + +- Params: `Paramsspace("insurance") -> legacy_amino(params)` + +```go + +type Params struct { + // default_redemption_notice_period_duration defines the default minimum notice period duration that must pass after an underwriter sends + // a redemption request before the underwriter can claim his tokens + DefaultRedemptionNoticePeriodDuration time.Duration +} +``` + +## Insurance Types + +`InsuranceFund` defines all the information of the `Insurance Funds` by market. + +```go + +type InsuranceFund struct { + // deposit denomination for the given insurance fund + DepositDenom string + // insurance fund pool token denomination for the given insurance fund + InsurancePoolTokenDenom string + // redemption_notice_period_duration defines the minimum notice period duration that must pass after an underwriter sends + // a redemption request before the underwriter can claim his tokens + RedemptionNoticePeriodDuration time.Duration + // balance of fund + Balance math.Int + // total share tokens minted + TotalShare math.Int + // marketID of the derivative market + MarketId string + // ticker of the derivative market + MarketTicker string + // Oracle base currency of the derivative market + OracleBase string + // Oracle quote currency of the derivative market + OracleQuote string + // Oracle type of the derivative market + OracleType types.OracleType + // Expiration time of the derivative market. Should be -1 for perpetual markets. + Expiry int64 +} +``` + +`RedemptionSchedule` defines redemption schedules from users - redemption is not executed instantly but there's `redemption_notice_period_duration` specified per market. + +```go +type RedemptionSchedule struct { + // id of redemption schedule + Id uint64 + // marketId of redemption schedule + MarketId string + // address of the redeemer + Redeemer string + // the time after which the redemption can be claimed + ClaimableRedemptionTime time.Time + // the insurance_pool_token amount to redeem + RedemptionAmount sdk.Coin +} +``` + +Additionally, we introduce `next_share_denom_id` and `next_redemption_schedule_id` to manage insurance fund share token +denom and redemption schedules from various users. + +```go +// GenesisState defines the insurance module's genesis state. +type GenesisState struct { + // params defines all the parameters of related to insurance. + Params Params + InsuranceFunds []InsuranceFund + RedemptionSchedule []RedemptionSchedule + NextShareDenomId uint64 + NextRedemptionScheduleId uint64 +} +``` + +## Pending Redemptions + +Pending Redemptions Objects are kept to store all the information about redemption requests and to auto-withdraw when +the duration pass. + diff --git a/.gitbook/developers/modules/injective/insurance/02_state_transitions.md b/.gitbook/developers/modules/injective/insurance/02_state_transitions.md new file mode 100644 index 00000000..08b66df4 --- /dev/null +++ b/.gitbook/developers/modules/injective/insurance/02_state_transitions.md @@ -0,0 +1,124 @@ +--- +sidebar_position: 2 +title: State Transitions +--- + +# State Transitions + +This document describes the state transition operations pertaining to: + +- Creating an insurance fund +- Underwriting an insurance fund +- Request a redemption from the insurance fund +- Automatic processing of matured redemption requests + +## Creating insurance fund + +**Params description** +`Sender` field describes the creator of an insurance fund . +`Ticker`, `QuoteDenom`, `OracleBase`, `OracleQuote`, `OracleType`, `Expiry` fields describe the derivative market info +that the insurance fund associated to. +`InitialDeposit` field describes the initial deposit amount to be put on the insurance fund. + +**Steps** + +- Get `MarketId` for the insurance fund - **Note**, market could be not available yet on `exchange` and it's not an + issue +- Ensure if insurance fund associated to the `MarketId` does not exist +- Ensure if initial deposit amount is not zero +- Get `shareDenom` that is unique - it's incremented when share denom is requested for insurance fund creation or when + underwriting insurance fund that has zero balance and non-zero total share denom supply. +- Send coins from creator's account to insurance fund module account +- Create insurance fund object with `DefaultRedemptionNoticePeriodDuration` and with the params provided +- Set `Balance` of fund object to initial deposit amount +- Mint `InsuranceFundInitialSupply` (10^18) `shareDenom` tokens to creator account +- Save insurance fund object to store +- Register newly created insurance fund `shareDenom` metadata inside BankKeeper + +## Underwriting an insurance fund + +**Params description** +`Sender` field describes the underwriter of an insurance fund . +`MarketId` field describes the derivative market id to the insurance fund. +`Deposit` field describes the deposit amount to be added on the insurance fund. + +**Steps** + +- Ensure if insurance fund associated to the `MarketId` does exist +- Send underwriting tokens from sender's account to module account +- Make actions based on the status of insurance fund associated to the `MarketId`. + * A. when `Balance` and `ShareDenomSupply` are zero + 1. mint `InsuranceFundInitialSupply` (10^18) to the sender. + 2. set `Balance` to deposit amount + 3. set `ShareDenomSupply` to `InsuranceFundInitialSupply` + * B. when `Balance` is zero and `ShareDenomSupply` is not zero + 1. change `ShareDenom` of the the insurance fund to start new insurance fund from beginning. + 2. register newly created `ShareDenom` in bank keeper + 3. mint `InsuranceFundInitialSupply` (10^18) to the sender. + 4. set `Balance` to deposit amount + 5. set `ShareDenomSupply` to `InsuranceFundInitialSupply` + * C. when `Balance` is not zero and `ShareDenomSupply` is zero + 1. mint `InsuranceFundInitialSupply` (10^18) to the sender. + 2. increase `Balance` by deposit amount + 3. set `ShareDenomSupply` to `InsuranceFundInitialSupply` + * D. when both `Balance` and `ShareDenomSupply` are not zero - normal case + 1. increase `Balance` by deposit amount + 2. mint `prev_ShareDenomSupply * deposit_amount / prev_Balance` amount of `ShareDenom` to sender + 3. increase `ShareDenomSupply` with mint amount +- Save insurance fund object to store + +## Requesting a redemption from an insurance fund + +**Params description** +`Sender` field describes the redemption requester of an insurance fund . +`MarketId` field describes the derivative market id associated to the insurance fund. +`Amount` field describes the share token amount to be redeemed. + +**Steps** + +- Ensure insurance fund associated to the `MarketId` does exist +- Send `ShareDenom` to module account +- Get new redemption schedule ID +- Calculate `ClaimTime` from insurance fund's redemption notice period duration and current block time +- Calculate key to store pending redemption (redemption schedule) +- Create redemption schedule object with details +- Store redemption schedule object to store + +## Insurance fund actions on liquidation events in derivative market + +**Steps** + +- `exchange` module finds relative insurance fund from the insurance keeper. +- if `missingFund` is positive, it withdraws the amount from the insurance fund through `WithdrawFromInsuranceFund`. +- if `missingFund` is negative, it deposits the amount into the insurance fund through `DepositIntoInsuranceFund`. + +## Automatic processing of pending redemptions + +**Steps** + +Iterate all matured redemptions by sorted order by `ClaimTime` and perform the following actions: + +- If `ClaimTime` is after current block time, break early +- Ensure the insurance fund exist for matured redemption schedule +- Calculate redeem amount from share amount - `shareAmt * fund.Balance * fund.TotalShare` +- Send calculate redeem amount from module account to redeemer account +- Burn share tokens sent to the module account at the time of redemption schedule +- Delete redemption schedule object +- Reduce insurance fund's `Balance` by redeem amount +- Store updated insurance object to store + +# Hooks + +Other modules may register operations to execute when a certain event has occurred within insurance fund. These events +can be registered to execute either right `Before` or `After` the exchange event (as per the hook name). The following +hooks can registered with the exchange: + +**Note**: Hooks are not available and exchange module calls insurance keeper function directly. + +**Steps** +When liquidation event happen in derivative market + +- `exchange` module finds relative insurance fund from the insurance keeper. +- if `missingFund` is positive, it withdraws the amount from the insurance fund through `WithdrawFromInsuranceFund`. +- if `missingFund` is negative, it deposits the amount into the insurance fund through `DepositIntoInsuranceFund`. + diff --git a/.gitbook/developers/modules/injective/insurance/03_messages.md b/.gitbook/developers/modules/injective/insurance/03_messages.md new file mode 100644 index 00000000..416b1a03 --- /dev/null +++ b/.gitbook/developers/modules/injective/insurance/03_messages.md @@ -0,0 +1,95 @@ +--- +sidebar_position: 3 +title: Messages +--- + +# Messages + +In this section we describe the processing of the exchange messages and the corresponding updates to the state. All created/modified state objects specified by each message are defined within the [state](02_state_transitions.md) section. + +## Msg/CreateInsuranceFund + +`MsgCreateInsuranceFund` defines a message to create an insurance fund for a derivative market. + +```protobuf +// MsgCreateInsuranceFund a message to create an insurance fund for a derivative market. +message MsgCreateInsuranceFund { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + // Creator of the insurance fund. + string sender = 1; + // Ticker for the derivative market. + string ticker = 2; + // Coin denom to use for the market quote denom + string quote_denom = 3; + // Oracle base currency + string oracle_base = 4; + // Oracle quote currency + string oracle_quote = 5; + // Oracle type + injective.oracle.v1beta1.OracleType oracle_type = 6; + // Expiration time of the market. Should be -1 for perpetual markets. + int64 expiry = 7; + // Initial deposit of the insurance fund + cosmos.base.v1beta1.Coin initial_deposit = 8 [(gogoproto.nullable) = false]; +} +``` + +**Fields description** + +- `Sender` field describes the creator of an insurance fund . +- `Ticker`, `QuoteDenom`, `OracleBase`, `OracleQuote`, `OracleType`, `Expiry` fields describe the derivative market info + that the insurance fund corresponds to. +- `InitialDeposit` specifies the initial deposit amount used to underwrite the insurance fund. + +Disclaimer: When creating an insurance fund a small portion of shares (1%) will be reserved by the fund itself (protocol owned liquidity). A value of 1 USD is recommended as first subscription. + +Motivation behind this feature is to avoid potential rounding issues when underwriting to a fund. For example, without having protocol owned liquidity, if the original fund creator would take out most of their shares leaving but a small amount, the value of the share token could diverge drastically from the original value. The next underwriter would then have to provide a much larger deposit despite gaining the same amount of shares. + +## Msg/Underwrite + +`MsgUnderwrite` defines a message to underwrite an insurance fund + +```protobuf +// MsgUnderwrite defines a message for depositing coins to underwrite an insurance fund +message MsgUnderwrite { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + // Address of the underwriter. + string sender = 1; + // MarketID of the insurance fund. + string market_id = 2; + // Amount of quote_denom to underwrite the insurance fund. + cosmos.base.v1beta1.Coin deposit = 3 [(gogoproto.nullable) = false]; +} +``` + +**Fields description** + +- `Sender` field describes the underwriter of an insurance fund . +- `MarketId` field describes the derivative market id to the insurance fund. +- `Deposit` field describes the deposit amount to be added on the insurance fund. + +## Msg/RequestRedemption + +`MsgRequestRedemption` defines a message to request redemption from the insurance fund. + +```protobuf +// MsgRequestRedemption defines a message for requesting a redemption of the sender's insurance fund tokens +message MsgRequestRedemption { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + // Address of the underwriter requesting a redemption. + string sender = 1; + // MarketID of the insurance fund. + string market_id = 2; + // Insurance fund share token amount to be redeemed. + cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false]; +} +``` + +**Fields description** + +- `Sender` field describes the redemption requester of an insurance fund . +- `MarketId` field describes the derivative market id associated to the insurance fund. +- `Amount` field describes the share token amount to be redeemed. diff --git a/.gitbook/developers/modules/injective/insurance/04_end_block.md b/.gitbook/developers/modules/injective/insurance/04_end_block.md new file mode 100644 index 00000000..8fece042 --- /dev/null +++ b/.gitbook/developers/modules/injective/insurance/04_end_block.md @@ -0,0 +1,8 @@ +--- +sidebar_position: 4 +title: End-Block +--- + +# End-Block + +At each EndBlock, redemption requests that have matured are automatically processed, resulting in the insurance pool token for the redemption being burned and the pro-rata quote currency amount corresponding to the redemption being withdrawn from the insurance module to the underwriter's balances. More details can be found in the in Automatic withdrawal of pending redemptions in the [state transitions](./02_state_transitions.md) section. diff --git a/.gitbook/developers/modules/injective/insurance/05_events.md b/.gitbook/developers/modules/injective/insurance/05_events.md new file mode 100644 index 00000000..5add6de2 --- /dev/null +++ b/.gitbook/developers/modules/injective/insurance/05_events.md @@ -0,0 +1,39 @@ +--- +sidebar_position: 5 +title: Events +--- + +# Events + +The insurance module emits the following events: + +## Handlers + +### MsgCreateInsuranceFund + +| Type | Attribute Key | Attribute Value | +| ---------------------------------------------------- | ------------- | --------------- | +| injective.insurance.v1beta1.EventInsuranceFundUpdate | fund | {fundJSON} | + +### MsgUnderwrite + +| Type | Attribute Key | Attribute Value | +| ---------------------------------------------------- | ------------- | --------------- | +| injective.insurance.v1beta1.EventInsuranceFundUpdate | fund | {fundJSON} | + +### MsgRequestRedemption + +| Type | Attribute Key | Attribute Value | +| -------------------------------------------------- | ------------- | --------------- | +| injective.insurance.v1beta1.EventRequestRedemption | schedule | {scheduleJSON} | + + + +## EndBlocker + +| Type | Attribute Key | Attribute Value | +| ---------------------------------------------------- | ------------- | --------------- | +| injective.insurance.v1beta1.EventInsuranceFundUpdate | fund | {fundJSON} | +| injective.insurance.v1beta1.EventWithdrawRedemption | schedule | {scheduleJSON} | +| injective.insurance.v1beta1.EventWithdrawRedemption | redeem_coin | {redeemCoin} | + diff --git a/.gitbook/developers/modules/injective/insurance/06_params.md b/.gitbook/developers/modules/injective/insurance/06_params.md new file mode 100644 index 00000000..2f042a3a --- /dev/null +++ b/.gitbook/developers/modules/injective/insurance/06_params.md @@ -0,0 +1,13 @@ +--- +sidebar_position: 6 +title: Parameters +--- + +# Parameters + +The insurance module contains the following parameter: + +| Key | Type | Example | +| ----------------------------------------- | ------------- | --------------------- | +| default_redemption_notice_period_duration | time.Duration | `time.Hour * 24 * 14` | + diff --git a/.gitbook/developers/modules/injective/insurance/07_future_improvements.md b/.gitbook/developers/modules/injective/insurance/07_future_improvements.md new file mode 100644 index 00000000..44c84d94 --- /dev/null +++ b/.gitbook/developers/modules/injective/insurance/07_future_improvements.md @@ -0,0 +1,11 @@ +--- +sidebar_position: 7 +title: Future Improvements +--- + +# Future improvements + +## Precision Loss Edge Case Handling + +Insurance Fund share tokens currently have a decimal scale of `10^18`. There could be potential problems using this as user deposits amount could be various and in the future, share token's price could be very higher or lower. + diff --git a/.gitbook/developers/modules/injective/insurance/README.md b/.gitbook/developers/modules/injective/insurance/README.md new file mode 100644 index 00000000..172cdb49 --- /dev/null +++ b/.gitbook/developers/modules/injective/insurance/README.md @@ -0,0 +1,19 @@ +# `Insurance` + +## Abstract + +This paper specifies the insurance module of the Injective Chain. + +This module provides insurance funds for derivative markets in the `exchange` module of the Injective Chain to use in order to support higher leverage trading. On a high level, insurance funds for each derivative market are funded by a permissionless group of underwriters who each own a proportional claim (represented through insurance fund share tokens) over the underlying assets in the insurance fund. + +Each insurance fund grows when positions in its corresponding derivative market are liquidated with positive equity, as half of the positive equity is sent to the insurance fund upon liquidation. When a position with negative equity is liquidated (i.e. the position has surpassed bankruptcy), the insurance fund is utilized to cover the missing equity. + +## Contents + +1. **[State](01_state.md)** +2. **[State Transitions](02_state_transitions.md)** +3. **[Messages](03_messages.md)** +4. **[End Block](04_end_block.md)** +5. **[Events](05_events.md)** +6. **[Params](06_params.md)** +7. **[Future Improvements](07_future_improvements.md)** \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/ocr/01_concepts.md b/.gitbook/developers/modules/injective/ocr/01_concepts.md new file mode 100644 index 00000000..c42047f4 --- /dev/null +++ b/.gitbook/developers/modules/injective/ocr/01_concepts.md @@ -0,0 +1,60 @@ +--- +sidebar_position: 1 +title: Concepts +--- + +# Concepts + +The `ocr` module is to store chainlink's OCR information into on-chain by verified members. + +Off-chain reporting consists of N nodes (oracles), gathering data from external sources. Reports are being exchanged in a p2p fashion between oracles to get signatures of approval. A subset of nodes (transmitters) is identified by the `ocr` module on-chain, they must submit the reports to module, the first transmitter who hits the chain gets an extra reward to cover gas costs. Other transmitters are not. All oracles participating in the round are getting paid. `ocr` module stores median value from the reports. + +## OCR Terminology + +The protocol periodically sends **oracle reports** to the OCR module. The reporting protocol is comprised of three components: **pacemaker**, **report generation** and **transmission**. + +**Pacemaker** + +The pacemaker drives the report generation process which is structured in **epochs**. Each epoch has a designatd leader who the pacemaker then tasks with starting the report generation protocol. If the leader does not produce a valid report in time, the pacemaker also aborts the current report generation and starts a new epoch. + +**Report Generation** + +For a given epoch, the report generation protocol enters into **rounds** where **observations** are gathered and (given conditions are met such as heartbeat and deviation) a signed oracle **report** is generated. The rounds are controlled by a leader node who controls the frequency of rounds, gathers the observations and generates the report. + +**Transmission** + +The transmission protocol then transmits the generated report to the OCR module. + +## Off-chain OCR integration + +- Provide means to communicate with Injective using sdk-go +- Read data from the module, such as a list of approved oracles +- Submit reports as Msgs (Implement `ContractTransmitter`) +- Implement `OffchainConfigDigester` +- Implement `OnchainKeyring` for producing signatures that will work on the target chain module +- Implement `ContractConfigTracker` for tracking changes of the chain module config (gov approved) + +Notes: + +- Reports are timestamped in Epoch-Round fashion +- `ocr` module verifies the signatures of oracles on the report +- `ocr` module records oracles who contributed to a report, for the payout +- `ocr` module stores the median of the observations +- `ocr` module provides extra reward for the first submitter of a Msg + +### Integration Overview + +Chainlink has several [price data feeds](https://data.chain.link/ethereum/mainnet/stablecoins) including: + +- 80 Crypto/USD pairs (e.g. ETH/USD, BTC/USD) +- 17 Stablecoin pairs (e.g. USDT/USD, USDC/USD) +- 73 ETH pairs (e.g. LINK/ETH) +- 17 Forex pairs (e.g. GBP/USD, CNY/USD) + +A derivative market on Injective specifies the following oracle parameters: + +- An oracleBase (e.g. BTC) +- An oracleQuote (e.g. USDT) +- An oracleType (e.g. Chainlink) + +Thus for a BTC/USDT derivative market on Injective, the oracleBase would be BTC/USD, the oracleQuote would be USDT/USD and the oracleType would be Chainlink. The price for the market would then be obtained by dividing the BTC/USD price with the USDT/USD price, leaving the BTC/USDT price. diff --git a/.gitbook/developers/modules/injective/ocr/02_state.md b/.gitbook/developers/modules/injective/ocr/02_state.md new file mode 100644 index 00000000..5ab39bbd --- /dev/null +++ b/.gitbook/developers/modules/injective/ocr/02_state.md @@ -0,0 +1,218 @@ +--- +sidebar_position: 2 +title: State +--- + +# State + +Genesis state defines the initial state of the module to be used to setup the module. + +```go +// GenesisState defines the OCR module's genesis state. +type GenesisState struct { + // params defines all the parameters of related to OCR. + Params Params + // feed_configs stores all of the supported OCR feeds + FeedConfigs []*FeedConfig + // latest_epoch_and_rounds stores the latest epoch and round for each feedId + LatestEpochAndRounds []*FeedEpochAndRound + // feed_transmissions stores the last transmission for each feed + FeedTransmissions []*FeedTransmission + // latest_aggregator_round_ids stores the latest aggregator round ID for each feedId + LatestAggregatorRoundIds []*FeedLatestAggregatorRoundIDs + // reward_pools stores the reward pools + RewardPools []*RewardPool + // feed_observation_counts stores the feed observation counts + FeedObservationCounts []*FeedCounts + // feed_transmission_counts stores the feed transmission counts + FeedTransmissionCounts []*FeedCounts + // pending_payeeships stores the pending payeeships + PendingPayeeships []*PendingPayeeship +} +``` +## Params + +`Params` is a module-wide configuration that stores system parameters and defines overall functioning of the ocr module. +This module is modifiable by governance using params update proposal natively supported by `gov` module. + +Struct for the `ocr` module params store. +```go +type Params struct { + // Native denom for LINK coin in the bank keeper + LinkDenom string + // The block number interval at which payouts are made + PayoutBlockInterval uint64 + // The admin for the OCR module + ModuleAdmin string +} +``` + +## FeedConfig + +`FeedConfig` is to manage the configurations of feed and it exists one per feed. + +```go +type FeedConfig struct { + // signers ith element is address ith oracle uses to sign a report + Signers []string + // transmitters ith element is address ith oracle uses to transmit a report via the transmit method + Transmitters []string + // f maximum number of faulty/dishonest oracles the protocol can tolerate while still working correctly + F uint32 + // onchain_config contains properties relevant only for the Cosmos module. + OnchainConfig *OnchainConfig + // offchain_config_version version of the serialization format used for "offchain_config" parameter + OffchainConfigVersion uint64 + // offchain_config serialized data used by oracles to configure their offchain operation + OffchainConfig []byte +} +``` + +### FeedConfigInfo + +`FeedConfigInfo` is storing the information that needs to be updated more often for each transmission event. + +```go +type FeedConfigInfo struct { + LatestConfigDigest []byte + F uint32 + N uint32 + // config_count ordinal number of this config setting among all config settings + ConfigCount uint64 + LatestConfigBlockNumber int64 +} +``` + +### Transmission + +`Transmission` is the unit to save transition information on the store. + +```go +// Transmission records the median answer from the transmit transaction at +// time timestamp +type Transmission struct { + Answer math.LegacyDec + ObservationsTimestamp int64 + TransmissionTimestamp int64 +} +``` + +### Report + +`Report` is the unit to save report information on the store. + +```go +type Report struct { + ObservationsTimestamp int64 + Observers []byte + Observations []math.LegacyDec +} +``` + +`ReportToSign` saves the information that needs to be signed by observers. + +```go +type ReportToSign struct { + ConfigDigest []byte + Epoch uint64 + Round uint64 + ExtraHash []byte + // Opaque report + Report []byte +} +``` + +### OnchainConfig + +`OnchainConfig` saves the configuration that needs to be managed on-chain for feed config. + +```go +type OnchainConfig struct { + // chain_id the ID of the Cosmos chain itself. + ChainId string + // feed_id is an unique ID for the target of this config + FeedId string + // lowest answer the median of a report is allowed to be + MinAnswer math.LegacyDec + // highest answer the median of a report is allowed to be + MaxAnswer math.LegacyDec + // Fixed LINK reward for each observer + LinkPerObservation math.Int + // Fixed LINK reward for transmitter + LinkPerTransmission math.Int + // Native denom for LINK coin in the bank keeper + LinkDenom string + // Enables unique reports + UniqueReports bool + // short human-readable description of observable this feed's answers pertain to + Description string + // feed administrator + FeedAdmin string + // feed billing administrator + BillingAdmin string +} +``` + +### ContractConfig + +`ContractConfig` saves the configuration that is related to contract to store OCR. + +```go +type ContractConfig struct { + // config_count ordinal number of this config setting among all config settings + ConfigCount uint64 + // signers ith element is address ith oracle uses to sign a report + Signers []string + // transmitters ith element is address ith oracle uses to transmit a report via the transmit method + Transmitters []string + // f maximum number of faulty/dishonest oracles the protocol can tolerate while still working correctly + F uint32 + // onchain_config serialized config that is relevant only for the module. + OnchainConfig []byte + // offchain_config_version version of the serialization format used for "offchain_config" parameter + OffchainConfigVersion uint64 + // offchain_config serialized data used by oracles to configure their offchain operation + OffchainConfig []byte +} +``` +### FeedProperties + +`FeedProperties` is a unit to store the properties of feed by id. + +```go +type FeedProperties struct { + // feed_id is an unique ID for the target of this config + FeedId string + // f maximum number of faulty/dishonest oracles the protocol can tolerate while still working correctly + F uint32 + // offchain_config_version version of the serialization format used for "offchain_config" parameter + OffchainConfigVersion uint64 + // offchain_config serialized data used by oracles to configure their offchain operation + OffchainConfig []byte + // lowest answer the median of a report is allowed to be + MinAnswer math.LegacyDec + // highest answer the median of a report is allowed to be + MaxAnswer math.LegacyDec + // Fixed LINK reward for each observer + LinkPerObservation math.Int + // Fixed LINK reward for transmitter + LinkPerTransmission math.Int + // Enables unique reports + UniqueReports bool + // short human-readable description of observable this feed's answers pertain to + Description string +} +``` + +### PendingPayeeship + +`PendingPayeeship` is a record that is stored when a person is delegating payeeship to another address. +When proposed payee accept this, this record is removed. + +```go +type PendingPayeeship struct { + FeedId string + Transmitter string + ProposedPayee string +} +``` \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/ocr/03_messages.md b/.gitbook/developers/modules/injective/ocr/03_messages.md new file mode 100644 index 00000000..ee0823ff --- /dev/null +++ b/.gitbook/developers/modules/injective/ocr/03_messages.md @@ -0,0 +1,227 @@ +--- +sidebar_position: 3 +title: Messages +--- + +# Messages + +In this section we describe the processing of the ocr messages and the corresponding updates to the state. + +## Msg/CreateFeed + +`MsgCreateFeed` is a message to create feed config and it is restricted message that is executable by module admin. + +```protobuf +message MsgCreateFeed { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + string sender = 1; + FeedConfig config = 2; +} +``` + +**Steps** + +- Ensure `Sender` is module admin +- Ensure `msg.Config.OnchainConfig.LinkDenom` is module param's `LinkDenom` +- Set `OnchainConfig.ChainId` from `ctx.ChainID` +- Ensure `FeedConfig` with same `FeedId` does not exist +- Set latest `EpochAndRound` to `(0, 0)` +- Set feed config for `feedId` +- Set feed trasmissions count and observations count to 1 + +## Msg/UpdateFeed + +`MsgCreateFeed` is a message to update feed config and it is restricted message that is executable by feed admin or feed billing admin. + +```protobuf +message MsgUpdateFeed { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + string sender = 1; + // feed_id is an unique ID for the target of this config + string feed_id = 2; + // signers ith element is address ith oracle uses to sign a report + repeated string signers = 3; + // transmitters ith element is address ith oracle uses to transmit a report via the transmit method + repeated string transmitters = 4; + // Fixed LINK reward for each observer + string link_per_observation = 5[ + (gogoproto.customtype) = "cosmossdk.io/math.Int", + (gogoproto.nullable) = true + ]; + // Fixed LINK reward for transmitter + string link_per_transmission = 6[ + (gogoproto.customtype) = "cosmossdk.io/math.Int", + (gogoproto.nullable) = true + ]; + // Native denom for LINK coin in the bank keeper + string link_denom = 7; + // feed administrator + string feed_admin = 8; + // feed billing administrator + string billing_admin = 9; +} +``` + +**Steps** + +- Get previous feed config by `feedId` and ensure it exists +- Ensure `Sender` is feed admin or feed billing admin +- Ensure billing admin is not changing Signers, Transmitters and feed admin +- Process rewards payout for previous feed config +- Delete previous feed transmission and observation counts +- Set latest `EpochAndRound` to `(0, 0)` +- Update signers, transmitters, `LinkPerObservation`, `LinkPerTransmission`, `LinkDenom`, `FeedAdmin`, `BillingAdmin` if set. + +## Msg/Transmit + +`MsgTransmit` is a message to transmit a report for specific feed. When broadcasting the message, there should be enough amount of signatures from observers to be accepted. + +```protobuf +message MsgTransmit { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + // Address of the transmitter + string transmitter = 1; + bytes config_digest = 2; + string feed_id = 3; + uint64 epoch = 4; + uint64 round = 5; + bytes extra_hash = 6; + Report report = 7; + repeated bytes signatures = 8; +} +``` + +**Steps** + +- Get epoch and round for `feedId` +- Ensure that the report is not staled one by checking `msg.Epoch` and `msg.Round` +- Get feed config and config info from `feedId` +- Check msg.ConfigDigest equals to feed config info's latest config digest +- Check if transmitter is valid transmitter configured in `feedConfig` +- Save transmitter report +- Emit event for trasmission +- Validate signatures and the number of signatures +- Increment feed observation and transmission counts + +## Msg/FundFeedRewardPool + +`MsgFundFeedRewardPool` is a message to add funds to feed reward pool to be given to transmitters and observers. + +```protobuf +message MsgFundFeedRewardPool { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string sender = 1; + string feed_id = 2; + cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false]; +} +``` + +**Steps** + +- Get previous reward pool amount from `feedId` +- If previous amount is empty, initiate the pool amount with zero integer +- Ensure previous amount denom is not different from deposit denom if exist +- Send coins from account to the module account (`ocr` module) +- Update reward pool amount with `amount` field addition +- Call `AfterFundFeedRewardPool` hook if hooks is set + +## Msg/WithdrawFeedRewardPool + +`MsgFundFeedRewardPool` is a message to withdraw funds from feed reward pool and is restricted to feed admin or billing admin. + +```protobuf +message MsgWithdrawFeedRewardPool { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string sender = 1; + string feed_id = 2; + cosmos.base.v1beta1.Coin amount = 3 [(gogoproto.nullable) = false]; +} +``` + +**Steps** + +- Get feed config from `feedId` +- Ensure `msg.Sender` is `feedAdmin` or `billingAdmin` +- Process reward for the feed +- Withdraw specified amount `msg.Amount` from module account + +## Msg/SetPayees + +`MsgSetPayees` is a message to set payee for transmitters - it is restricted to feed admin. Once it's set, it should be changed only by payee. + +```protobuf +message MsgSetPayees { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string sender = 1; + string feed_id = 2; + // addresses oracles use to transmit the reports + repeated string transmitters = 3; + // addresses of payees corresponding to list of transmitters + repeated string payees = 4; +} +``` + +**Steps** + +- Get feed config from `feedId` and ensure that feed config exists +- Ensure `msg.Sender` is feed admin +- Iterating `msg.Transmitters`, +- 1. Ensure payee is set already for the transmitter +- 2. Set payee for the transmitter + +## Msg/TransferPayeeship + +`MsgTransferPayeeship` is a message to transfer payeeship for a specific transmitter of feed. After execution, pending payeeship object is created. + +```protobuf +message MsgTransferPayeeship { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + // transmitter address of oracle whose payee is changing + string sender = 1; + string transmitter = 2; + string feed_id = 3; + // new payee address + string proposed = 4; +} +``` + +**Steps** + +- Get feed config from `feedId` and ensure that feed config exists +- Ensure msg.Sender is current payee +- Check previous pending payeeship transfer record and ensure previous payeeship transfer does not conflict +- Set payeeship transfer record + +## Msg/AcceptPayeeship + +`MsgTransferPayeeship` is a message to accept payeeship for a specific transmitter of feed. + +```protobuf +message MsgAcceptPayeeship { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + // new payee address + string payee = 1; + // transmitter address of oracle whose payee is changing + string transmitter = 2; + string feed_id = 3; +} +``` + +**Steps** + +- Get feed config from `feedId` and ensure that feed config exists +- Get pending payeeship transfer record for `msg.Transmitter` and `feedId` +- Reset payee for `feedId` and `transmitter` +- Delete pending payeeship transfer for `transmitter` of `feedId` diff --git a/.gitbook/developers/modules/injective/ocr/04_proposals.md b/.gitbook/developers/modules/injective/ocr/04_proposals.md new file mode 100644 index 00000000..787e24ae --- /dev/null +++ b/.gitbook/developers/modules/injective/ocr/04_proposals.md @@ -0,0 +1,50 @@ +--- +sidebar_position: 4 +title: Governance Proposals +--- + +# Governance Proposals + +## SetConfigProposal + +`SetConfigProposal` is a proposal to set feed config by governance. + +```protobuf +message SetConfigProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1; + string description = 2; + FeedConfig config = 3; +} +``` + +**Steps** + +- Validate basics for the proposal +- Ensure module's `LinkDenom` is same as proposal's `LinkDenom` +- set `p.Config.OnchainConfig.ChainId` from `ctx.ChainID` +- Set feed config for `feedId` +- Set feed transmissions and observations count for `Config.Transmitters` + +## SetBatchConfigProposal + +`SetBatchConfigProposal` is a proposal to set multiple feed configs at once by governance. + +```protobuf +message SetBatchConfigProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1; + string description = 2; + // signers ith element is address ith oracle uses to sign a report + repeated string signers = 3; + // transmitters ith element is address ith oracle uses to transmit a report via the transmit method + repeated string transmitters = 4; + // Native denom for LINK coin in the bank keeper + string link_denom = 5; + repeated FeedProperties feed_properties = 6; +} +``` diff --git a/.gitbook/developers/modules/injective/ocr/05_begin_block.md b/.gitbook/developers/modules/injective/ocr/05_begin_block.md new file mode 100644 index 00000000..6c2ed6a8 --- /dev/null +++ b/.gitbook/developers/modules/injective/ocr/05_begin_block.md @@ -0,0 +1,13 @@ +--- +sidebar_position: 5 +title: Begin-Block +--- + +# Begin-Block + +At each BeginBlock, it checks if it's time for payout interval and if it's time, it process payout for all feeds. + +**Steps** + +- Ensure it's the begin block of payout interval +- While iterating all feed configs, process reward payouts diff --git a/.gitbook/developers/modules/injective/ocr/06_hooks.md b/.gitbook/developers/modules/injective/ocr/06_hooks.md new file mode 100644 index 00000000..c50e2acf --- /dev/null +++ b/.gitbook/developers/modules/injective/ocr/06_hooks.md @@ -0,0 +1,17 @@ +--- +sidebar_position: 6 +--- + +# Hooks + +Other modules may register operations to execute when a certain event has occurred within ocr module. The following hooks can registered with ocr: + +- `AfterSetFeedConfig(ctx sdk.Context, feedConfig *FeedConfig)` + - called after feed config is created or updated +- `AfterTransmit(ctx sdk.Context, feedId string, answer math.LegacyDec, timestamp int64)` + - called when info is transmitted +- `AfterFundFeedRewardPool(ctx sdk.Context, feedId string, newPoolAmount sdk.Coin)` + - called when feed reward pool is updated + +Note: +`oracle` module is accepting `AfterTransmit` hook to store cumulative price when transmission is made. \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/ocr/07_events.md b/.gitbook/developers/modules/injective/ocr/07_events.md new file mode 100644 index 00000000..257d2c97 --- /dev/null +++ b/.gitbook/developers/modules/injective/ocr/07_events.md @@ -0,0 +1,102 @@ +--- +sidebar_position: 7 +title: Events +--- + +# Events + +The ocr module emits the following events: + +## Handlers + +### MsgCreateFeed + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | --------------- | +| message | action | MsgCreateFeed | +| message | sender | {sender} | + +### MsgUpdateFeed + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | --------------- | +| message | action | MsgUpdateFeed | +| message | sender | {sender} | + +### MsgTransmit + +| Type | Attribute Key | Attribute Value | +| -------------------- | --------------------- | ----------------------- | +| EventNewTransmission | FeedId | {FeedId} | +| EventNewTransmission | AggregatorRoundId | {AggregatorRoundId} | +| EventNewTransmission | Answer | {Answer} | +| EventNewTransmission | Transmitter | {Transmitter} | +| EventNewTransmission | ObservationsTimestamp | {ObservationsTimestamp} | +| EventNewTransmission | Observations | {Observations} | +| EventNewTransmission | Observers | {Observers} | +| EventNewTransmission | ConfigDigest | {ConfigDigest} | +| EventNewTransmission | EpochAndRound | {EpochAndRound} | +| EventTransmitted | ConfigDigest | {ConfigDigest} | +| EventTransmitted | Epoch | {Epoch} | +| message | action | MsgTransmit | +| message | sender | {sender} | + +### MsgFundFeedRewardPool + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | --------------------- | +| message | action | MsgFundFeedRewardPool | +| message | sender | {sender} | + +### MsgWithdrawFeedRewardPool + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | ------------------------- | +| message | action | MsgWithdrawFeedRewardPool | +| message | sender | {sender} | + +### MsgSetPayees + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | --------------- | +| message | action | MsgSetPayees | +| message | sender | {sender} | + +### MsgTransferPayeeship + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | -------------------- | +| message | action | MsgTransferPayeeship | +| message | sender | {sender} | + +### MsgAcceptPayeeship + +| Type | Attribute Key | Attribute Value | +| ------- | ------------- | ------------------ | +| message | action | MsgAcceptPayeeship | +| message | sender | {sender} | + +## Proposals + +### SetConfigProposal + +| Type | Attribute Key | Attribute Value | +| -------------- | ------------------------- | --------------------------- | +| EventConfigSet | ConfigDigest | {ConfigDigest} | +| EventConfigSet | PreviousConfigBlockNumber | {PreviousConfigBlockNumber} | +| EventConfigSet | Config | {Config} | +| EventConfigSet | ConfigInfo | {ConfigInfo} | + +### SetBatchConfigProposal + +| Type | Attribute Key | Attribute Value | +| ---------------- | ------------------------- | --------------------------- | +| EventConfigSet[] | ConfigDigest | {ConfigDigest} | +| EventConfigSet[] | PreviousConfigBlockNumber | {PreviousConfigBlockNumber} | +| EventConfigSet[] | Config | {Config} | +| EventConfigSet[] | ConfigInfo | {ConfigInfo} | + +## BeginBlocker + +| Type | Attribute Key | Attribute Value | +| ---- | ------------- | --------------- | diff --git a/.gitbook/developers/modules/injective/ocr/08_params.md b/.gitbook/developers/modules/injective/ocr/08_params.md new file mode 100644 index 00000000..f78af34e --- /dev/null +++ b/.gitbook/developers/modules/injective/ocr/08_params.md @@ -0,0 +1,14 @@ +--- +order: 8 +title: Params +--- + +# Parameters + +The ocr module contains the following parameters: + +| Key | Type | Example | +| ------------------- | ------ | --------- | +| LinkDenom | string | link | +| PayoutBlockInterval | uint64 | 100 | +| ModuleAdmin | string | {address} | diff --git a/.gitbook/developers/modules/injective/ocr/README.md b/.gitbook/developers/modules/injective/ocr/README.md new file mode 100644 index 00000000..41e1e177 --- /dev/null +++ b/.gitbook/developers/modules/injective/ocr/README.md @@ -0,0 +1,21 @@ +# Ocr + +## Abstract + +OCR module is to store chainlink's OCR(Off-Chain Report) info into the chain storage. + +Feed configuration is managed by module admin and report move to on-chain by transmitters and observers. +Transmitters and observers are rewarded in LINK token on the chain configured by governance. + +While storing feed information, module provide hooks where oracle module can use for the calculation of cumulative price for futures market. + +## Contents + +1. **[Concepts](01_concepts.md)** +2. **[State](02_state.md)** +3. **[Messages](03_messages.md)** +4. **[Proposals](04_proposals.md)** +5. **[Begin-Block](05_begin_block.md)** +6. **[Hooks](06_hooks.md)** +7. **[Events](07_events.md)** +8. **[Parameters](08_params.md)** diff --git a/.gitbook/developers/modules/injective/oracle/01_state.md b/.gitbook/developers/modules/injective/oracle/01_state.md new file mode 100644 index 00000000..5a5ed19e --- /dev/null +++ b/.gitbook/developers/modules/injective/oracle/01_state.md @@ -0,0 +1,275 @@ +--- +sidebar_position: 1 +title: State +--- + +# State + +## Params +The oracle module parameters. +```protobuf +message Params { + option (gogoproto.equal) = true; + + string pyth_contract = 1; +} +``` + + +## PriceState + +PriceState is common type to manage cumulative price and latest price along with timestamp for all oracle types. + +```protobuf +message PriceState { + string price = 1 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; + + string cumulative_price = 2 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; + + int64 timestamp = 3; +} +``` + +where + +- `Price` represents the normalized decimal price +- `CumulativePrice` represents the cumulative price for a given oracle price feed since the start of the oracle price feed's creation. +- `Timestamp` represents the time at which the blocktime at which the price state was relayed. + +Note that the `CumulativePrice` value follows the convention set by the [Uniswap V2 Oracle](https://uniswap.org/docs/v2/core-concepts/oracles/) and is used to allows modules to calculate Time-Weighted Average Price (TWAP) between 2 arbitrary block time intervals (t1, t2). + +$\mathrm{TWAP = \frac{CumulativePrice_2 - CumulativePrice_1}{Timestamp_2 - Timestamp_1}}$ + +## Band + +Band price data for a given symbol are represented and stored as follows: + +- BandPriceState: `0x01 | []byte(symbol) -> ProtocolBuffer(BandPriceState)` + +```protobuf +message BandPriceState { + string symbol = 1; + string rate = 2 [(gogoproto.customtype) = "cosmossdk.io/math.Int", (gogoproto.nullable) = false]; + uint64 resolve_time = 3; + uint64 request_ID = 4; + PriceState price_state = 5 [(gogoproto.nullable) = false]; +} +``` + +Note that the `Rate` is the raw USD rate for the `Symbol` obtained from the Band chain which has is scaled by 1e9 (e.g. a price of 1.42 is 1420000000) while the PriceState has the normalized decimal price (e.g. 1.42). + +Band relayers are stored by their address as follows. + +- BandRelayer: `0x02 | RelayerAddr -> []byte{}` + +## Band IBC + +This section describes all the state management to maintain the price by connecting to Band chain via IBC. + +- LatestClientID is maintained to manage unique clientID for band IBC packets. It is increased by 1 when sending price request packet into bandchain. + +* LatestClientID: `0x32 -> Formated(LatestClientID)` + +- LatestRequestID is maintained to manage unique `BandIBCOracleRequests`. Incremented by 1 when creating a new `BandIBCOracleRequest`. + +* LatestRequestID: `0x36 -> Formated(LatestRequestID)` + +- Band IBC price data for a given symbol is stored as follows: + +* BandPriceState: `0x31 | []byte(symbol) -> ProtocolBuffer(BandPriceState)` + +```protobuf +message BandPriceState { + string symbol = 1; + string rate = 2 [(gogoproto.customtype) = "cosmossdk.io/math.Int", (gogoproto.nullable) = false]; + uint64 resolve_time = 3; + uint64 request_ID = 4; + PriceState price_state = 5 [(gogoproto.nullable) = false]; +} +``` + +- BandIBCCallDataRecord is stored as follows when sending price request packet into bandchain: + +* CalldataRecord: `0x33 | []byte(ClientId) -> ProtocolBuffer(CalldataRecord)` + +```protobuf +message CalldataRecord { + uint64 client_id = 1; + bytes calldata = 2; +} +``` + +- BandIBCOracleRequest is stored as follows when the governance configure oracle requests to send: + +* BandOracleRequest: `0x34 | []byte(RequestId) -> ProtocolBuffer(BandOracleRequest)` + +```protobuf +message BandOracleRequest { + // Unique Identifier for band ibc oracle request + uint64 request_id = 1; + + // OracleScriptID is the unique identifier of the oracle script to be executed. + int64 oracle_script_id = 2; + + // Symbols is the list of symbols to prepare in the calldata + repeated string symbols = 3; + + // AskCount is the number of validators that are requested to respond to this + // oracle request. Higher value means more security, at a higher gas cost. + uint64 ask_count = 4; + + // MinCount is the minimum number of validators necessary for the request to + // proceed to the execution phase. Higher value means more security, at the + // cost of liveness. + uint64 min_count = 5; + + // FeeLimit is the maximum tokens that will be paid to all data source providers. + repeated cosmos.base.v1beta1.Coin fee_limit = 6 [(gogoproto.nullable) = false, (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins"]; + + // PrepareGas is amount of gas to pay to prepare raw requests + uint64 prepare_gas = 7; + // ExecuteGas is amount of gas to reserve for executing + uint64 execute_gas = 8; +} +``` + +- BandIBCParams is stored as follows and configured by governance: + +* BandIBCParams: `0x35 -> ProtocolBuffer(BandIBCParams)` + +`BandIBCParams` contains the information for IBC connection with band chain. + +```protobuf +message BandIBCParams { + // true if Band IBC should be enabled + bool band_ibc_enabled = 1; + // block request interval to send Band IBC prices + int64 ibc_request_interval = 2; + // band IBC source channel + string ibc_source_channel = 3; + // band IBC version + string ibc_version = 4; + // band IBC portID + string ibc_port_id = 5; +} +``` + +Note: + +1. `BandIbcEnabled` describes the status of band ibc connection +2. `IbcSourceChannel`, `IbcVersion`, `IbcPortId` are common parameters required for IBC connection. +3. `IbcRequestInterval` describes the automatic price fetch request interval that is automatically triggered on injective chain on beginblocker. + +## Coinbase + +Coinbase price data for a given symbol ("key") are represented and stored as follows: + +- CoinbasePriceState: `0x21 | []byte(key) -> CoinbasePriceState` + +```protobuf +message CoinbasePriceState { + // kind should always be "prices" + string kind = 1; + // timestamp of the when the price was signed by coinbase + uint64 timestamp = 2; + // the symbol of the price, e.g. BTC + string key = 3; + // the value of the price scaled by 1e6 + uint64 value = 4; + // the price state + PriceState price_state = 5 [(gogoproto.nullable) = false]; +} +``` + +More details about the Coinbase price oracle can be found in the [Coinbase API docs](https://docs.pro.coinbase.com/#oracle) as well as this explanatory [blog post](https://blog.coinbase.com/introducing-the-coinbase-price-oracle-6d1ee22c7068). + +Note that the `Value` is the raw USD price data obtained from Coinbase which has is scaled by 1e6 (e.g. a price of 1.42 is 1420000) while the PriceState has the normalized decimal price (e.g. 1.42). + +## Pricefeed + +Pricefeed price data for a given base quote pair are represented and stored as follows: + +- PriceFeedInfo: `0x11 + Keccak256Hash(base + quote) -> PriceFeedInfo` + +```protobuf +message PriceFeedInfo { + string base = 1; + string quote = 2; +} +``` + +- PriceFeedPriceState: `0x12 + Keccak256Hash(base + quote) -> PriceFeedPriceState` + +```protobuf +message PriceFeedState { + string base = 1; + string quote = 2; + PriceState price_state = 3; + repeated string relayers = 4; +} +``` + +- PriceFeedRelayer: `0x13 + Keccak256Hash(base + quote) + relayerAddr -> relayerAddr` + +## Provider +Provider price feeds are represented and stored as follows: + +- ProviderInfo: `0x61 + provider + @@@ -> ProviderInfo` +```protobuf +message ProviderInfo { + string provider = 1; + repeated string relayers = 2; +} +``` + +- ProviderIndex: `0x62 + relayerAddress -> provider` + +- ProviderPrices: `0x63 + provider + @@@ + symbol -> ProviderPriceState` +```protobuf +message ProviderPriceState { + string symbol = 1; + PriceState state = 2; +} +``` + +## Pyth + +Pyth prices are represented and stored as follows: +- PythPriceState: `0x71 + priceID -> PythPriceState` +```protobuf +message PythPriceState { + bytes price_id = 1; + string ema_price = 2 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; + string ema_conf = 3 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; + string conf = 4 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; + uint64 publish_time = 5; + PriceState price_state = 6 [(gogoproto.nullable) = false]; +} +``` + +## Stork + +Stork prices are represented and stored as follows: +- StorkPriceState: `0x81 + symbol -> PythPriceState` +```protobuf +message StorkPriceState { + // timestamp of the when the price was signed by stork + uint64 timestamp = 1; + // the symbol of the price, e.g. BTC + string symbol = 2; + // the value of the price scaled by 1e18 + string value = 3 [ + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false + ]; + // the price state + PriceState price_state = 5 [ (gogoproto.nullable) = false ]; +} +``` + +Stork publishers are represented and stored as follows: +- Publisher: `0x82 + stork_publisher -> publisher` + +```protobuf +string stork_publisher +``` \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/oracle/02_keeper.md b/.gitbook/developers/modules/injective/oracle/02_keeper.md new file mode 100644 index 00000000..32509c5f --- /dev/null +++ b/.gitbook/developers/modules/injective/oracle/02_keeper.md @@ -0,0 +1,120 @@ +--- +sidebar_position: 2 +title: Keepers +--- + +# Keepers + +The oracle module currently provides three different exported keeper interfaces which can be passed to other modules +which need to read price feeds. Modules should use the least-permissive interface which provides the functionality they +require. + +## Oracle Module ViewKeeper + +The oracle module ViewKeeper provides the ability to obtain price data as well as cumulative price data for any +supported oracle type and oracle pair. + +```go +type ViewKeeper interface { + GetPrice(ctx sdk.Context, oracletype types.OracleType, base string, quote string) *math.LegacyDec // Returns the price for a given pair for a given oracle type. + GetCumulativePrice(ctx sdk.Context, oracleType types.OracleType, base string, quote string) *math.LegacyDec // Returns the cumulative price for a given pair for a given oracle type. +} +``` + +Note that the `GetPrice` for Coinbase oracles returns the 5 minute TWAP price. + +## Band + +The BandKeeper provides the ability to create/modify/read/delete BandPricefeed and BandRelayer. + +```go +type BandKeeper interface { + GetBandPriceState(ctx sdk.Context, symbol string) *types.BandPriceState + SetBandPriceState(ctx sdk.Context, symbol string, priceState types.BandPriceState) + GetAllBandPriceStates(ctx sdk.Context) []types.BandPriceState + GetBandReferencePrice(ctx sdk.Context, base string, quote string) *math.LegacyDec + IsBandRelayer(ctx sdk.Context, relayer sdk.AccAddress) bool + GetAllBandRelayers(ctx sdk.Context) []string + SetBandRelayer(ctx sdk.Context, relayer sdk.AccAddress) + DeleteBandRelayer(ctx sdk.Context, relayer sdk.AccAddress) +} +``` + +## Band IBC + +The BandIBCKeeper provides the ability to create/modify/read/delete BandIBCOracleRequest, BandIBCPriceState, BandIBCLatestClientID and BandIBCCallDataRecord. + +```go +type BandIBCKeeper interface { + SetBandIBCOracleRequest(ctx sdk.Context, req types.BandOracleRequest) + GetBandIBCOracleRequest(ctx sdk.Context) *types.BandOracleRequest + DeleteBandIBCOracleRequest(ctx sdk.Context, requestID uint64) + GetAllBandIBCOracleRequests(ctx sdk.Context) []*types.BandOracleRequest + + GetBandIBCPriceState(ctx sdk.Context, symbol string) *types.BandPriceState + SetBandIBCPriceState(ctx sdk.Context, symbol string, priceState types.BandPriceState) + GetAllBandIBCPriceStates(ctx sdk.Context) []types.BandPriceState + GetBandIBCReferencePrice(ctx sdk.Context, base string, quote string) *math.LegacyDec + + GetBandIBCLatestClientID(ctx sdk.Context) uint64 + SetBandIBCLatestClientID(ctx sdk.Context, clientID uint64) + SetBandIBCCallDataRecord(ctx sdk.Context, clientID uint64, bandIBCCallDataRecord []byte) + GetBandIBCCallDataRecord(ctx sdk.Context, clientID uint64) *types.CalldataRecord +} +``` + +## Coinbase + +The CoinbaseKeeper provides the ability to create, modify and read CoinbasePricefeed data. + +```go +type CoinbaseKeeper interface { + GetCoinbasePrice(ctx sdk.Context, base string, quote string) *math.LegacyDec + HasCoinbasePriceState(ctx sdk.Context, key string) bool + GetCoinbasePriceState(ctx sdk.Context, key string) *types.CoinbasePriceState + SetCoinbasePriceState(ctx sdk.Context, priceData *types.CoinbasePriceState) error + GetAllCoinbasePriceStates(ctx sdk.Context) []*types.CoinbasePriceState +} +``` + +The `GetCoinbasePrice` returns the 5 minute TWAP price of the CoinbasePriceState based off the `CoinbasePriceState.Timestamp` values provided by Coinbase. + +## PriceFeeder + +The PriceFeederKeeper provides the ability to create/modify/read/delete PriceFeedPrice and PriceFeedRelayer. + +```go +type PriceFeederKeeper interface { + IsPriceFeedRelayer(ctx sdk.Context, oracleBase, oracleQuote string, relayer sdk.AccAddress) bool + GetAllPriceFeedStates(ctx sdk.Context) []*types.PriceFeedState + GetAllPriceFeedRelayers(ctx sdk.Context, baseQuoteHash common.Hash) []string + SetPriceFeedRelayer(ctx sdk.Context, oracleBase, oracleQuote string, relayer sdk.AccAddress) + SetPriceFeedRelayerFromBaseQuoteHash(ctx sdk.Context, baseQuoteHash common.Hash, relayer sdk.AccAddress) + DeletePriceFeedRelayer(ctx sdk.Context, oracleBase, oracleQuote string, relayer sdk.AccAddress) + HasPriceFeedInfo(ctx sdk.Context, priceFeedInfo *types.PriceFeedInfo) bool + GetPriceFeedInfo(ctx sdk.Context, baseQuoteHash common.Hash) *types.PriceFeedInfo + SetPriceFeedInfo(ctx sdk.Context, priceFeedInfo *types.PriceFeedInfo) + GetPriceFeedPriceState(ctx sdk.Context, base string, quote string) *types.PriceState + SetPriceFeedPriceState(ctx sdk.Context, oracleBase, oracleQuote string, priceState *types.PriceState) + GetPriceFeedPrice(ctx sdk.Context, base string, quote string) *math.LegacyDec +} +``` + +## Stork + +The StorkKeeper provides the ability to create/modify/read StorkPricefeed and StorkPublishers data. + +```go +type StorkKeeper interface { + GetStorkPrice(ctx sdk.Context, base string, quote string) *math.LegacyDec + IsStorkPublisher(ctx sdk.Context, address string) bool + SetStorkPublisher(ctx sdk.Context, address string) + DeleteStorkPublisher(ctx sdk.Context, address string) + GetAllStorkPublishers(ctx sdk.Context) []string + + SetStorkPriceState(ctx sdk.Context, priceData *types.StorkPriceState) + GetStorkPriceState(ctx sdk.Context, symbol string) types.StorkPriceState + GetAllStorkPriceStates(ctx sdk.Context) []*types.StorkPriceState +} +``` +The GetStorkPrice returns the price(`value`) of the StorkPriceState. \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/oracle/03_messages.md b/.gitbook/developers/modules/injective/oracle/03_messages.md new file mode 100644 index 00000000..599e47a3 --- /dev/null +++ b/.gitbook/developers/modules/injective/oracle/03_messages.md @@ -0,0 +1,190 @@ +--- +sidebar_position: 3 +title: Messages +--- + +# Messages + +## MsgRelayBandRates + +Authorized Band relayers can relay price feed data for multiple symbols with the `MsgRelayBandRates` message. +The registered handler iterates over all the symbols present in the `MsgRelayBandRates` and creates/updates the +`BandPriceState` for each symbol. + +```protobuf +message MsgRelayBandRates { + string relayer = 1; + repeated string symbols = 2; + repeated uint64 rates = 3; + repeated uint64 resolve_times = 4; + repeated uint64 requestIDs = 5; +} +``` + +This message is expected to fail if the Relayer is not an authorized Band relayer. + +## MsgRelayCoinbaseMessages + +Relayers of Coinbase provider can send price data using `MsgRelayCoinbaseMessages` message. + +Each Coinbase `Messages` is authenticated by the `Signatures` provided by the Coinbase oracle address `0xfCEAdAFab14d46e20144F48824d0C09B1a03F2BC`, thus allowing anyone to submit the `MsgRelayCoinbaseMessages`. + +```protobuf +message MsgRelayCoinbaseMessages { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + string sender = 1; + + repeated bytes messages = 2; + repeated bytes signatures = 3; +} +``` + +This message is expected to fail if signature verification fails or if the Timestamp submitted is not more recent than the last previously submitted Coinbase price. + +## MsgRelayPriceFeedPrice + +Relayers of PriceFeed provider can send the price feed using `MsgRelayPriceFeedPrice` message. + +```protobuf +// MsgRelayPriceFeedPrice defines a SDK message for setting a price through the pricefeed oracle. +message MsgRelayPriceFeedPrice { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + string sender = 1; + + repeated string base = 2; + repeated string quote = 3; + + // price defines the price of the oracle base and quote + repeated string price = 4 [ + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false + ]; +} +``` + +This message is expected to fail if the Relayer (`Sender`) is not an authorized pricefeed relayer for the given Base Quote pair or if the price is greater than 10000000. + +## MsgRequestBandIBCRates + +`MsgRequestBandIBCRates` is a message to instantly broadcast a request to bandchain. + +```protobuf +// MsgRequestBandIBCRates defines a SDK message for requesting data from BandChain using IBC. +message MsgRequestBandIBCRates { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string sender = 1; + uint64 request_id = 2; + +} +``` + +Anyone can broadcast this message and no specific authorization is needed. +The handler checks if `BandIbcEnabled` flag is true and go ahead sending a request. + +## MsgRelayPythPrices + +`MsgRelayPythPrices` is a message for the Pyth contract relay prices to the oracle module. + +```protobuf +// MsgRelayPythPrices defines a SDK message for updating Pyth prices +message MsgRelayPythPrices { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string sender = 1; + repeated PriceAttestation price_attestations = 2; +} + +message PriceAttestation { + string product_id = 1; + bytes price_id = 2; + int64 price = 3; + uint64 conf = 4; + int32 expo = 5; + int64 ema_price = 6; + uint64 ema_conf = 7; + PythStatus status = 8; + uint32 num_publishers = 9; + uint32 max_num_publishers = 10; + int64 attestation_time = 11; + int64 publish_time = 12; +} + +enum PythStatus { + // The price feed is not currently updating for an unknown reason. + Unknown = 0; + // The price feed is updating as expected. + Trading = 1; + // The price feed is not currently updating because trading in the product has been halted. + Halted = 2; + // The price feed is not currently updating because an auction is setting the price. + Auction = 3; +} +``` + +This message is expected to fail if the Relayer (`sender`) does not equal the Pyth contract address as defined in the +oracle module Params. + +## MsgRelayStorkPrices + +`MsgRelayStorkPrices` is a message for the Stork contract relay prices to the oracle module. + +```protobuf +// MsgRelayStorkPrices defines a SDK message for relaying price message from Stork API. +message MsgRelayStorkPrices { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + option (cosmos.msg.v1.signer) = "sender"; + + string sender = 1; + repeated AssetPair asset_pairs = 2; +} + +message AssetPair { + string asset_id = 1; + repeated SignedPriceOfAssetPair signed_prices = 2; +} + +message SignedPriceOfAssetPair { + string publisher_key = 1; + uint64 timestamp = 2; + string price = 3 [ + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false + ]; + bytes signature = 4; +} +``` + +This message is expected to fail if: +- the Relayer (`sender`) is not an authorized oracle publisher or if `assetId` is not unique amongst the provided asset pairs +- ECDSA signature verification fails for the `SignedPriceOfAssetPair` +- the difference between timestamps exceeds the `MaxStorkTimestampIntervalNano` (500 milliseconds). + +## MsgRelayProviderPrices + +Relayers of a particular Provider can send the price feed using `MsgRelayProviderPrices` message. + +```protobuf +// MsgRelayProviderPrice defines a SDK message for setting a price through the provider oracle. +message MsgRelayProviderPrices { + option (amino.name) = "oracle/MsgRelayProviderPrices"; + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + option (cosmos.msg.v1.signer) = "sender"; + + string sender = 1; + string provider = 2; + repeated string symbols = 3; + repeated string prices = 4 [ + (gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", + (gogoproto.nullable) = false + ]; +} +``` + +This message is expected to fail if the Relayer (`Sender`) is not an authorized pricefeed relayer for the given Base Quote pair or if the price is greater than 10000000. diff --git a/.gitbook/developers/modules/injective/oracle/04_proposals.md b/.gitbook/developers/modules/injective/oracle/04_proposals.md new file mode 100644 index 00000000..82488e8c --- /dev/null +++ b/.gitbook/developers/modules/injective/oracle/04_proposals.md @@ -0,0 +1,227 @@ +--- +sidebar_position: 4 +title: Governance Proposals +--- + +# Governance Proposals + +## GrantProviderPrivilegeProposal + +Oracle provider privileges can be granted to your account through a `GrantBandOraclePrivilegeProposal`. After the governance proposal is passed, you will be able to relay price feeds using your provider. + + +```protobuf +// Grant Privileges +message GrantProviderPrivilegeProposal { + option (amino.name) = "oracle/GrantProviderPrivilegeProposal"; + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content"; + + string title = 1; + string description = 2; + string provider = 3; + repeated string relayers = 4; +} +``` + +You can submit your proposal according to the example: + +```bash +injectived tx oracle grant-provider-privilege-proposal YOUR_PROVIDER \ + YOUR_ADDRESS_HERE \ + --title="TITLE OF THE PROPOSAL" \ + --description="Registering PROVIDER as an oracle provider" \ + --chain-id=injective-888 \ + --from=local_key \ + --node=https://testnet.sentry.tm.injective.network:443 \ + --gas-prices=160000000inj \ + --gas=20000000 \ + --deposit="40000000000000000000inj" +``` + + +To successfully pass the proposal for **testnet**, `YOUR_DEPOSIT` should be slightly less than `min_deposit` +value (for example, `40000000000000000000inj`). After that you should contact the Injective dev team. Dev team will +top up your deposit to `min_deposit` and vote for your proposal. + +## RevokeProviderPrivilegeProposal + +Oracle provider privileges can be revoked from your account through a `RevokeProviderPrivilegeProposal`. + +```protobuf +// Revoke Privileges +message RevokeProviderPrivilegeProposal { + option (amino.name) = "oracle/RevokeProviderPrivilegeProposal"; + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content"; + + string title = 1; + string description = 2; + string provider = 3; + repeated string relayers = 5; +} +``` + +## GrantBandOraclePrivilegeProposal + +Band Oracle privileges can be granted to Relayer accounts of Band provider through a `GrantBandOraclePrivilegeProposal`. + +```protobuf +// Grant Privileges +message GrantBandOraclePrivilegeProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1; + string description = 2; + repeated string relayers = 3; +} +``` + +## RevokeBandOraclePrivilegeProposal + +Band Oracle privileges can be revoked from Relayer accounts of Band provider through a `RevokeBandOraclePrivilegeProposal`. + +```protobuf +// Revoke Privileges +message RevokeBandOraclePrivilegeProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1; + string description = 2; + repeated string relayers = 3; +} +``` + +## GrantPriceFeederPrivilegeProposal + +Price feeder privileges for a given base quote pair can be issued to relayers through a `GrantPriceFeederPrivilegeProposal`. + +```protobuf +// Grant Privileges +message GrantPriceFeederPrivilegeProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1; + string description = 2; + string base = 3; + string quote = 4; + repeated string relayers = 5; +} +``` + +## RevokePriceFeederPrivilegeProposal + +Price feeder privileges can be revoked from Relayer accounts through a `RevokePriceFeederPrivilegeProposal`. + +```protobuf +// Revoke Privileges +message RevokePriceFeederPrivilegeProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1; + string description = 2; + string base = 3; + string quote = 4; + repeated string relayers = 5; +} +``` + +## AuthorizeBandOracleRequestProposal + +This proposal is to add a band oracle request into the list. When this is accepted, injective chain fetches one more price info from bandchain. + +```protobuf +message AuthorizeBandOracleRequestProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1; + string description = 2; + BandOracleRequest request = 3 [(gogoproto.nullable) = false]; +} +``` + +## UpdateBandOracleRequestProposal + +This proposal is used for deleting a request or updating the request. +When `DeleteRequestId` is not zero, it deletes the request with the id and finish its execution. +When `DeleteRequestId` is zero, it update the request with id `UpdateOracleRequest.RequestId` to UpdateOracleRequest. + +```protobuf +message UpdateBandOracleRequestProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1; + string description = 2; + uint64 delete_request_id = 3; + BandOracleRequest update_oracle_request = 4; +} +``` + +## EnableBandIBCProposal + +This proposal is to enable IBC connection between Band chain and Injective chain. +When the proposal is approved, it updates the BandIBCParams into newer one configured on the proposal. + +```protobuf +message EnableBandIBCProposal { + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + string title = 1; + string description = 2; + + BandIBCParams band_ibc_params = 3 [(gogoproto.nullable) = false]; +} +``` + +The details of `BandIBCParams`, can be checked at **[State](./01_state.md)** + +## GrantStorkPublisherPrivilegeProposal + +Stork Publisher privileges can be granted from Publishers through a `GrantStorkPublisherPrivilegeProposal`. + +```protobuf +// Grant Privileges +message GrantStorkPublisherPrivilegeProposal { + option (amino.name) = "oracle/GrantStorkPublisherPrivilegeProposal"; + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content"; + + string title = 1; + string description = 2; + + repeated string stork_publishers = 3; +} +``` + +## RevokeStorkPublisherPrivilegeProposal + +Stork Publisher privileges can be revoked from Publishers through a `RevokeStorkPublisherPrivilegeProposal`. + +```protobuf +// Revoke Privileges +message RevokeStorkPublisherPrivilegeProposal { + option (amino.name) = "oracle/RevokeStorkPublisherPrivilegeProposal"; + option (gogoproto.equal) = false; + option (gogoproto.goproto_getters) = false; + + option (cosmos_proto.implements_interface) = "cosmos.gov.v1beta1.Content"; + + string title = 1; + string description = 2; + + repeated string stork_publishers = 3; +} +``` \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/oracle/05_events.md b/.gitbook/developers/modules/injective/oracle/05_events.md new file mode 100644 index 00000000..ea883770 --- /dev/null +++ b/.gitbook/developers/modules/injective/oracle/05_events.md @@ -0,0 +1,96 @@ +--- +sidebar_position: 5 +title: Events +--- +# Events + +The oracle module emits the following events: +## Band +```protobuf +message SetBandPriceEvent { + string relayer = 1; + string symbol = 2; + string price = 3 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; + uint64 resolve_time = 4; + uint64 request_id = 5; +} + +message SetBandIBCPriceEvent { + string relayer = 1; + repeated string symbols = 2; + repeated string prices = 3 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; + uint64 resolve_time = 4; + uint64 request_id = 5; + int64 client_id = 6; +} + +message EventBandIBCAckSuccess { + string ack_result = 1; + int64 client_id = 2; +} + +message EventBandIBCAckError { + string ack_error = 1; + int64 client_id = 2; +} + +message EventBandIBCResponseTimeout { + int64 client_id = 1; +} +``` + +## Chainlink +```protobuf +message SetChainlinkPriceEvent { + string feed_id = 1; + string answer = 2 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; + uint64 timestamp = 3; +} +``` + +## Coinbase + +```protobuf +message SetCoinbasePriceEvent { + string symbol = 1; + string price = 2 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; + uint64 timestamp = 3; +} +``` + +## Provider +```protobuf +message SetProviderPriceEvent { + string provider = 1; + string relayer = 2; + string symbol = 3; + string price = 4 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; +} +``` + +## Pricefeed +```protobuf +message SetPriceFeedPriceEvent { + string relayer = 1; + + string base = 2; + string quote = 3; + + // price defines the price of the oracle base and quote + string price = 4 [(gogoproto.customtype) = "cosmossdk.io/math.LegacyDec", (gogoproto.nullable) = false]; +} +``` + +## Pyth +```protobuf +message EventSetPythPrices { + repeated PythPriceState prices = 1; +} +``` + +## Stork +```protobuf +message EventSetStorkPrices { + repeated StorkPriceState prices = 1; +} +``` \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/oracle/06_future_improvements.md b/.gitbook/developers/modules/injective/oracle/06_future_improvements.md new file mode 100644 index 00000000..60b92334 --- /dev/null +++ b/.gitbook/developers/modules/injective/oracle/06_future_improvements.md @@ -0,0 +1,10 @@ +--- +sidebar_position: 6 +title: Future Improvements +--- + +# Future Improvements + +Extend support for other oracle providers including Chainlink, Razor, DIA, API3, UMA, Pyth as well as Band oracle data through IBC. + +Of the following above, development is ongoing to integrate Band and Pyth oracle data through IBC, as well as Chainlink oracle data through the OCR (off-chain reporting) mechanism. diff --git a/.gitbook/developers/modules/injective/oracle/README.md b/.gitbook/developers/modules/injective/oracle/README.md new file mode 100644 index 00000000..f30bd028 --- /dev/null +++ b/.gitbook/developers/modules/injective/oracle/README.md @@ -0,0 +1,39 @@ +# `Oracle` + +## Abstract + +This specification specifies the oracle module, which is primarily used by the `exchange` modules to obtain external price data. + +## Workflow + +1. New price feed providers must first obtain oracle privileges through a governance proposal which grants privileges to a list of relayers. The exception to this is for the Coinbase price oracle, as anyone can send Coinbase price updates since they are already exclusively signed by the Coinbase oracle private key.
+ **Example Grant Proposals**: `GrantBandOraclePrivilegeProposal`, `GrantPriceFeederPrivilegeProposal` +2. Once the governance proposal is approved, the specified relayers can publish oracle data by sending relay messages specific to their oracle type.
+ **Example Relay Messages**:`MsgRelayBandRates`, `MsgRelayPriceFeedPrice`, `MsgRelayCoinbaseMessages` etc +3. Upon receiving the relay message, the oracle module checks if the relayer account has grant privileges and persists the latest price data in the state. +4. Other Cosmos-SDK modules can then fetch the latest price data for a specific provider by querying the oracle module. + +**Note**: In case of any discrepancy, the price feed privileges can be revoked through governance
+**Example Revoke Proposals**: `RevokeBandOraclePrivilegeProposal`, `RevokePriceFeederPrivilegeProposal` etc + +## Band IBC integration flow + +Cosmos SDK blockchains are able to interact with each other using IBC and Injective support the feature to fetch price feed from bandchain via IBC. + +1. To communicate with BandChain's oracle using IBC, Injective Chain must first initialize a communication channel with the oracle module on the BandChain using relayers. + +2. Once the connection has been established, a pair of channel identifiers is generated -- one for the Injective Chain and one for Band. The channel identifier is used by Injective Chain to route outgoing oracle request packets to Band. Similarly, Band's oracle module uses the channel identifier when sending back the oracle response. + +3. To enable band IBC integration after setting up communication channel, the governance proposal for `EnableBandIBCProposal` should pass. + +4. And then, the list of prices to be fetched via IBC should be determined by `AuthorizeBandOracleRequestProposal` and `UpdateBandOracleRequestProposal`. + +5. Once BandIBC is enabled, chain periodically sends price request IBC packets (`OracleRequestPacketData`) to bandchain and bandchain responds with the price via IBC packet (`OracleResponsePacketData`). Band chain is providing prices when there are threshold number of data providers confirm and it takes time to get the price after sending requests. To request price before the configured interval, any user can broadcast `MsgRequestBandIBCRates` message which is instantly executed. + +## Contents + +1. **[State](./01_state.md)** +2. **[Keeper](./02_keeper.md)** +3. **[Messages](./03_messages.md)** +4. **[Proposals](./04_proposals.md)** +5. **[Events](./05_events.md)** diff --git a/.gitbook/developers/modules/injective/peggy/01_definitions.md b/.gitbook/developers/modules/injective/peggy/01_definitions.md new file mode 100644 index 00000000..037c1da0 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/01_definitions.md @@ -0,0 +1,36 @@ +--- +sidebar_position: 1 +title: Definitions +--- + +# Intro + +This doc aims to provide an overview of `Peggy` (Injective's Ethereum bridge) from a technical perspective and dive deep into its operational logic. +Peggy is the name of the custom Cosmos SDK module built on Injective as well as the Ethereum contract (Peggy.sol) which make up both sides of the bridge. +Connected via a middle-man process called `Peggo` users can securely move token assets between networks. + +To suggest improvements, please open a GitHub issue. + +### Key definitions + +Words matter and we seek clarity in the terminology so we can have clarity in our thinking and communication. +To help better understand, some key definitions are: + +- `Operator` - this is a person (or people) who control and operate `Validator` and `Orchestrator` processes +- `Validator` - this is an Injective Chain validating node (eg. `injectived` process) +- `Validator Set` - the (active) set of Injective Chain `Validators` (Valset) along with their respective voting power as determined by their stake weight. Each validator is associated with an Ethereum address to be represented on the Ethereum network +- `Orchestrator (Peggo)` - the off-chain process (`peggo`) that plays the middleman role between Injective and Ethereum. Orchestrators are responsible for keeping the bridge online and require active endpoints to fully synced Injective (Ethereum) nodes +- `Peggy module` - the counterparty Cosmos module for `Peggy contract`. Besides providing services to bridge token assets, it automatically reflects on the active `Validator Set` as it changes over time. The update is later applied on Ethereum via `Peggo` +- `Peggy Contract` - The Ethereum contract that holds all the ERC-20 tokens. It also maintains a compressed checkpointed representation of the Injective Chain `Validator Set` using `Delegate Keys` and normalized powers +- `Delegate Keys` - when an `Operator` sets up their `Orchestrator` for the first time they register (on Injective) their `Validator`'s address with an Ethereum address. The corresponding key is used to sign messages and represent that validator on Ethereum. + Optionally, one delegate Injective Chain account key can be provided to sign Injective messages (eg `Claims`) on behalf of the `Validator` +- `Peggy Tx pool (withdrawals)` - when a user wishes to move their asset from Injective to Ethereum their individual tx gets pooled with others with the same asset +- `Peggy Batch pool` - pooled withdrawals are batched together (by an `Orchestrator`) to be signed off and eventually relayed to Ethereum. These batches are kept within this pool +- `Claim` - a signed proof (by an `Orchestrator`) that an event occurred in the `Peggy contract` +- `Attestation` - an aggregate of claims for a particular event nonce emitted from `Peggy contract`. After a majority of `Orchestrators` attests to a claim, the event is acknowledged and executed on Injective +- `Majority` - the majority of Injective network, 2/3 + 1 validators +- `Deposit` - an asset transfer initiated from Ethereum to Injective +- `Withdrawal` - an asset transfer initiated from Injective to Ethereum (present in `Peggy Tx pool`) +- `Batch` - a batch of withdrawals with the same token type (present in `Peggy Batch pool`) + + diff --git a/.gitbook/developers/modules/injective/peggy/02_workflow.md b/.gitbook/developers/modules/injective/peggy/02_workflow.md new file mode 100644 index 00000000..2a7b4742 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/02_workflow.md @@ -0,0 +1,164 @@ +--- +sidebar_position: 2 +title: Workflow +--- + +# Workflow + +## Conceptual Overview + +To recap, each `Operator` is responsible for maintaining 2 secure processes: + +1. A fully synced Injective Chain `Validator` node (`injectived` process) +2. The `Orchestrator` service (`peggo orchestrator` process) which interacts with both networks. Implicitly, an RPC endpoint to a fully synced Ethereum node is required as well (see peggo .env example) + +Combined, these 2 entities accomplish 3 things: +- Move token assets from Ethereum to Injective +- Move token assets from Injective to Ethereum +- Keep the `Peggy.sol` contract in sync with the active `Validator Set` on Injective + +It is possible to run `peggo` without ever being a `Validator`. Peggo automatically runs in "relayer mode" when configured to run with an address **not associated** with a `Validator`. +In this mode, only 2 things can happen: +* new token batches can be created on Injective +* confirmed valsets/batches can be relayed to Ethereum + +## Types of Assets + +### Native Ethereum assets + +Any asset originating from Ethereum which implements the ERC-20 standard can be transferred from Ethereum to Injective by calling the `sendToInjective` function on the [Peggy.sol](https://github.com/InjectiveLabs/peggo/blob/master/solidity/contracts/Peggy.sol) contract which transfers tokens from the sender's balance to the Peggy contract. + +The `Operators` all run their `peggo` processes which submit `MsgDepositClaim` messages describing the deposit they have observed. Once more than 66% of all voting power has submitted a claim for this specific deposit representative tokens are minted and issued to the Injective Chain address that the sender requested. + +These representative tokens have a denomination prefix of `peggy` concatenated with the ERC-20 token hex address, e.g. `peggy0xdac17f958d2ee523a2206206994597c13d831ec7`. + +### Native Cosmos SDK assets + +An asset native to a Cosmos SDK chain (e.g. `ATOM`) first must be represented on Ethereum before it's possible to bridge it. To do so, the [Peggy contract](https://github.com/InjectiveLabs/peggo/blob/master/solidity/contracts/Peggy.sol) allows anyone to create a new ERC-20 token representing a Cosmos asset by calling the `deployERC20` function. + +This endpoint is not permissioned, so it is up to the validators and the users of the Peggy bridge to declare any given ERC-20 token as the representation of a given asset. + +When a user on Ethereum calls `deployERC20` they pass arguments describing the desired asset. [Peggy.sol](https://github.com/InjectiveLabs/peggo/blob/master/solidity/contracts/Peggy.sol) uses an ERC-20 factory to deploy the actual ERC-20 contract and assigns ownership of the entire balance of the new token to the Peggy contract itself before emitting an `ERC20DeployedEvent`. + +The peggo orchestrators observe this event and decide if a Cosmos asset has been accurately represented (correct decimals, correct name, no pre-existing representation). If this is the case, the ERC-20 contract address is adopted and stored as the definitive representation of that Cosmos asset on Ethereum. + +## `Orchestrator` (Peggo) subprocesses + +The `peggo orchestrator` process consists of 4 subprocesses running concurrently at exact intervals (loops). These are: +* `Signer` which signs new `Validator Set` updates and `Token Batches` with the `Operator`'s Ethereum keys and submits using [messages](./04_messages.md#Ethereum-Signer-messages). +* `Oracle` which observes Ethereum events and sends them as [claims](./04_messages.md#Oracle-messages) to Injective. +* `Relayer` which submits confirmed `Validator Set` updates and `Token Batches` to the `Peggy Contract` on Ethereum +* `Batch Creator` which observes (new) withdrawals on Injective and decides which of these to batch according to their type and the configured `PEGGO_MIN_BATCH_FEE_USD` value + +### Batch Creator + +The purpose of the `Batch Creator` is only in creating token batches on the Injective side. The relevant `Peggy module` RPC is not permissioned so anyone can create a batch. + +When a user wants to withdraw assets from Injective to Ethereum they send a special message to Injective (`MsgSendToEth`) which adds their withdrawal to `Peggy Tx Pool`. +`Batch Creator` continually queries the pool for withdrawals (by token type) and issues a `MsgRequestBatch` to Injective when a potential batch satisfies the configured `PEGGO_MIN_BATCH_FEE_USD` value (see .env example). + +On the receiving end, all pooled withdrawals matching the token type in the request are moved from the `Outgoing Tx Pool` as a single batch and placed in the `Outgoing Batch Pool`. + +### Signer + +The responsibility of Signer is to provide confirmations that an `Operator (Orchestrator)` is partaking in bridge activity. Failure to provide these confirmations results in slashing penalties for the orchestrator's `Validator`. +In other words, this process **must be running at all times** for a `Validator` node. + +Any payload moving in the Injective->Ethereum pipeline (`Validator Set` updates/`Token Batches`) requires `Validator` signatures to be successfully relayed to Ethereum. Certain calls on `Peggy Contract` accept an array of signatures to be checked against the `Validator Set` in the contract itself. +`Orchestrators` make these signatures with their `Delegate Ethereum address`: this is an Ethereum address decided by the `Operator` upon initial setup ([SetOrchestratorAddress](./04_messages.md#setorchestratoraddresses)). This address then represents that validator on the Ethereum blockchain and will be added as a signing member of the multisig with a weighted voting power as close as possible to the Injective Chain voting power. + +Whenever `Signer` finds that there is a unconfirmed valset update (token batch) present within the `Peggy Module` it issues a `MsgConfirmValset` (`MsgConfirmBatch`) as proof that the operating `Validator` is active in bridge activity. + +### Oracle + +Monitors the Ethereum network for new events involving the `Peggy Contract`. + +Every event emitted by the contract has a unique event nonce. This nonce value is crucial in coordinating `Orchestrators` to properly observe contract activity and make sure Injective acknowledges them via `Claims`. +Multiple claims of the same nonce make up an `Attestation` and when the majority (2/3) of orchestrators have observed an event its particular logic gets executed on Injective. + +If 2/3 of the validators can not agree on a single `Attestation`, the oracle is halted. This means no new events will be relayed from Ethereum until some of the validators change their votes. There is no slashing condition for this, with reasoning outlined in the [slashing spec](./05_slashing.md) + +There are 4 types of events emitted from Peggy.sol: +1. `TransactionBatchExecutedEvent` - event indicating that a token batch (withdrawals) has been successfully relayed to Ethereum +2. `ValsetUpdatedEvent` - event indicating that a `Validator Set` update has been successfully relayed to Ethereum +3. `SendToInjectiveEvent` - event indicating that a new deposit to Injective has been initiated +4. `ERC20DeployedEvent` - event indicating a new Cosmos token has been registered on Ethereum + +Injective's `Oracle` implementation ignores the last 12 blocks on Ethereum to ensure block finality. In reality, this means latest events are observed 2-3 minutes after they occurred. + +### Relayer + +`Relayer` bundles valset updates (or token batches) along with their confirmations into an Ethereum transaction and sends it to the `Peggy contract`. + +Keep in mind that these messages cost a variable amount of money based on wildly changing Ethereum gas prices, so it's not unreasonable for a single batch to cost over a million gas. +A major design decision for our relayer rewards was to always issue them on the Ethereum chain. This has downsides, namely some strange behavior in the case of validator set update rewards. + +But the upsides are undeniable, because the Ethereum messages pay `msg.sender` any existing bot in the Ethereum ecosystem will pick them up and try to submit them. This makes the relaying market much more competitive and less prone to cabal like behavior. + +## End-to-end Lifecycle + +This document describes the end to end lifecycle of the Peggy bridge. + +### Peggy Smart Contract Deployment + +In order to deploy the Peggy contract, the validator set of the native chain (Injective Chain) must be known. Upon deploying the Peggy contract suite (Peggy Implementation, Proxy contract, and ProxyAdmin contracts), the Peggy contract (the Proxy contract) must be initialized with the validator set. +Upon initialization a `ValsetUpdatedEvent` is emitted from the contract. + +The proxy contract is used to upgrade Peggy Implementation contract which is needed for bug fixing and potential improvements during initial phase. It is a simple wrapper or "proxy" which users interact with directly and is in charge of forwarding transactions to the Peggy implementation contract, which contains the logic. The key concept to understand is that the implementation contract can be replaced but the proxy (the access point) is never changed. + +The ProxyAdmin is a central admin for the Peggy proxy, which simplifies management. It controls upgradability and ownership transfers. The ProxyAdmin contract itself has a built-in expiration time which, once expired, prevents the Peggy implementation contract from being upgraded in the future. + +Then the following peggy genesis params should be updated: +1. `bridge_ethereum_address` with Peggy proxy contract address +2. `bridge_contract_start_height` with the height at which the Peggy proxy contract was deployed + +This completes the bootstrap of the Peggy bridge and the chain can be started. Afterward, `Operators` should start their `peggo` processes and eventually observe that the initial `ValsetUpdatedEvent` is attested on Injective. + +### **Updating Injective Chain validator set on Ethereum** + +![img.png](./images/valsetupdate.png) + +A validator set is a series of Ethereum addresses with attached normalized powers used to represent the Injective validator set (Valset) in the Peggy contract on Ethereum. The Peggy contract stays in sync with the Injective Chain validator set through the following mechanism: +1. **Creating a new Valset on Injective:** A new Valset is automatically created on the Injective Chain when either: + * the cumulative difference of the current validator set powers compared to the last recorded Valset exceeds 5% + * a validator begins unbonding from the set +2. **Confirming a Valset on Injective:** Each `Operator` is responsible for confirming Valset updates that are created on Injective. The `Signer` process sends these confirmations via `MsgConfirmValset` by having the validator's delegated Ethereum key sign over a compressed representation of the Valset data. The `Peggy module` verifies the validity of the signature and persists it to its state. +3. **Updating the Valset on the Peggy contract:** After a 2/3+ 1 majority of validators have submitted their confirmations for a given Valset, `Relayer` submits the new Valset data to the Peggy contract by calling `updateValset`. +The Peggy contract then validates the data, updates the valset checkpoint, transfers valset rewards to sender and emits a `ValsetUpdatedEvent`. +4. **Acknowledging the `ValsetUpdatedEvent` on Injective:** `Oracle` witnesses the `ValsetUpdatedEvent` on Ethereum, and sends a `MsgValsetUpdatedClaim` which informs the `Peggy module` that the Valset has been updated on Ethereum. +5. **Pruning Valsets on Injective:** Once a 2/3 majority of validators send their claim for a given `ValsetUpdateEvent`, all the previous valsets are pruned from the `Peggy module` state. +6. **Validator Slashing:** Validators are subject to slashing after a configured window of time (`SignedValsetsWindow`) for not providing confirmations. Read more [valset slashing](./05_slashing.md) + +---- + +### **Transferring ERC-20 tokens from Ethereum to Injective** + +![img.png](./images/SendToCosmos.png) + +ERC-20 tokens are transferred from Ethereum to Injective through the following mechanism: + 1. **Depositing ERC-20 tokens on the Peggy Contract:** A user initiates a transfer of ERC-20 tokens from Ethereum to Injective by calling the `sendToInjective` function on the Peggy contract which deposits tokens on the Peggy contract and emits a `SendToInjectiveEvent`. + The deposited tokens will remain locked until withdrawn at some undetermined point in the future. This event contains the amount and type of tokens, as well as a destination address on the Injective Chain to receive the funds. + + 2. **Confirming the deposit:** Each `Oracle` witnesses the `SendToInjectiveEvent` and sends a `MsgDepositClaim` which contains the deposit information to the Peggy module. + + 3. **Minting tokens on the Injective:** Once a majority of validators confirm the deposit claim, the deposit is processed. + - If the asset is Ethereum originated, the tokens are minted and transferred to the intended recipient's address on the Injective Chain. + - If the asset is Cosmos-SDK originated, the coins are unlocked and transferred to the intended recipient's address on the Injective Chain. + +----- +### **Withdrawing tokens from Injective to Ethereum** + +![img.png](./images/SendToEth.png) + +1. **Request Withdrawal from Injective:** A user can initiate the transfer of assets from the Injective Chain to Ethereum by sending a `MsgSendToEth` transaction to the peggy module. + * If the asset is Ethereum native, the represented tokens are burnt. + * If the asset is Cosmos SDK native, coins are locked in the module. The withdrawal is then added to `Outgoing Tx Pool`. +2. **Batch Creation:** A `Batch Creator` observes the pool of pending withdrawals. The batch creator (or any external third party) then requests a batch of to be created for given token by sending `MsgRequestBatch` to the Injective Chain. The `Peggy module` collects withdrawals matching the token type into a batch and puts it in `Outgoing Batch Pool`. +3. **Batch Confirmation:** Upon detecting the existence of an Outgoing Batch, the `Signer` signs over the batch with its Ethereum key and submits a `MsgConfirmBatch` tx to the Peggy module. +4. **Submit Batch to Peggy Contract:** Once a majority of validators confirm the batch, the `Relayer` calls `submitBatch` on the Peggy contract with the batch and its confirmations. The Peggy contract validates the signatures, updates the batch checkpoint, processes the batch ERC-20 withdrawals, transfers the batch fee to the tx sender and emits a `TransactionBatchExecutedEvent`. +5. **Send Withdrawal Claim to Injective:** `Oracles` witness the `TransactionBatchExecutedEvent` and send a `MsgWithdrawClaim` containing the withdrawal information to the Peggy module. +6. **Prune Batches** Once a majority of validators submit their `MsgWithdrawClaim` , the batch is deleted along and all previous batches are cancelled on the Peggy module. Withdrawals in cancelled batches get moved back into `Outgoing Tx Pool`. +7. **Batch Slashing:** Validators are responsible for confirming batches and are subject to slashing if they fail to do so. Read more on [batch slashing](./05_slashing.md). + +Note while that batching reduces individual withdrawal costs dramatically, this comes at the cost of latency and implementation complexity. If a user wishes to withdraw quickly they will have to pay a much higher fee. However this fee will be about the same as the fee every withdrawal from the bridge would require in a non-batching system. + diff --git a/.gitbook/developers/modules/injective/peggy/03_state.md b/.gitbook/developers/modules/injective/peggy/03_state.md new file mode 100644 index 00000000..e589efe6 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/03_state.md @@ -0,0 +1,265 @@ +--- +sidebar_position: 3 +title: State +--- + +# State + +This doc lists all the data Peggy module reads/writes to its state as KV pairs + +### Module Params + +Params is a module-wide configuration structure that stores parameters and defines overall functioning of the peggy module. Detailed specification for each parameter can be found in the [Parameters section](08_params.md). + +| key | Value | Type | Encoding | +|---------------|---------------|----------------|------------------| +| `[]byte{0x4}` | Module params | `types.Params` | Protobuf encoded | + + +### Validator Info + +#### Ethereum Address by Validator + +Stores `Delegate Ethereum address` indexed by the `Validator`'s account address + +| key | Value | Type | Encoding | +|---------------------------------------|------------------|------------------|------------------| +| `[]byte{0x1} + []byte(validatorAddr)` | Ethereum address | `common.Address` | Protobuf encoded | + +#### Validator by Ethereum Address + +Stores `Validator` account address indexed by the `Delegate Ethereum address` + +| key | Value | Type | Encoding | +|-------------------------------------|-------------------|------------------|------------------| +| `[]byte{0xfb} + []byte(ethAddress)` | Validator address | `sdk.ValAddress` | Protobuf encoded | + + +#### OrchestratorValidator + +When a validator would like to delegate their voting power to another key. The value is stored using the orchestrator address as the key + +| Key | Value | Type | Encoding | +|-------------------------------------|----------------------------------------------|----------|------------------| +| `[]byte{0xe8} + []byte(AccAddress)` | Orchestrator address assigned by a validator | `[]byte` | Protobuf encoded | + + +### Valset + +This is the validator set of the bridge. Created automatically by `Peggy module` during EndBlocker. + +Stored in two possible ways, first with a height and second without (unsafe). Unsafe is used for testing and export and import of state. + +```go +type Valset struct { + Nonce uint64 + Members []*BridgeValidator + Height uint64 + RewardAmount math.Int + RewardToken string +} + +``` + +| key | Value | Type | Encoding | +|--------------------------------------------|---------------|----------------|------------------| +| `[]byte{0x2} + nonce (big endian encoded)` | Validator set | `types.Valset` | Protobuf encoded | + +### SlashedValsetNonce + +The latest validator set slash nonce. This is used to track which validator set needs to be slashed and which already has been. + +| Key | Value | Type | Encoding | +|----------------|-------|--------|------------------------| +| `[]byte{0xf5}` | Nonce | uint64 | encoded via big endian | + +### ValsetNonce + +Nonce of the latest validator set. Updated on each new validator set. + +| key | Value | Type | Encoding | +|----------------|-------|----------|------------------------| +| `[]byte{0xf6}` | Nonce | `uint64` | encoded via big endian | + + +### Valset Confirmation + +`Singer` confirmation for a particular validator set. See [oracle messages](./04_messages.md#ValsetConfirm) + +| Key | Value | Type | Encoding | +|---------------------------------------------|------------------------|--------------------------|------------------| +| `[]byte{0x3} + (nonce + []byte(AccAddress)` | Validator Confirmation | `types.MsgValsetConfirm` | Protobuf encoded | + +### Batch Confirmation + +`Singer` confirmation for a particular token batch. See [oracle messages](./04_messages.md#ConfirmBatch) + +| Key | Value | Type | Encoding | +|---------------------------------------------------------------------|------------------------------|-------------------------|------------------| +| `[]byte{0xe1} + []byte(tokenContract) + nonce + []byte(AccAddress)` | Validator Batch Confirmation | `types.MsgConfirmBatch` | Protobuf encoded | + + +### OutgoingTransferTx + +User withdrawals are pooled together in `Peggy Tx Pool` ready to be batched later by a `Batch Creator`. + +Each withdrawal is indexed by a unique nonce set by the `Peggy module` when the withdrawal was received. + +```go +type OutgoingTransferTx struct { + Id uint64 + Sender string + DestAddress string + Erc20Token *ERC20Token + Erc20Fee *ERC20Token +} +``` + +| Key | Value | Type | Encoding | +|----------------------------------------|------------------------------|----------|--------------------| +| `[]byte{0x7} + []byte("lastTxPoolId")` | nonce of outgoing withdrawal | `uint64` | Big endian encoded | + + +### LastTXPoolID + +Monotonically increasing value for each withdrawal received by Injective + +| Key | Value | Type | Encoding | +|----------------------------------------|-------------------------|----------|--------------------| +| `[]byte{0x6} + []byte("lastTxPoolId")` | Last used withdrawal ID | `uint64` | Big endian encoded | + + +### OutgoingTxBatch + +`OutgoingTxBatch` represents a collection of withdrawals of the same token type. Created on every successful `MsgRequestBatch`. + +Stored in two possible ways, first with a height and second without (unsafe). Unsafe is used for testing and export and import of state. +Currently [Peggy.sol](https://github.com/InjectiveLabs/peggo/blob/master/solidity/contracts/Peggy.sol) is hardcoded to only accept batches with a single token type and only pay rewards in that same token type. + +```go +type OutgoingTxBatch struct { + BatchNonce uint64 + BatchTimeout uint64 + Transactions []*OutgoingTransferTx + TokenContract string + Block uint64 +} +``` + +| key | Value | Type | Encoding | +|--------------------------------------------------------------------|----------------------------------|-------------------------|------------------| +| `[]byte{0xa} + []byte(tokenContract) + nonce (big endian encoded)` | A batch of outgoing transactions | `types.OutgoingTxBatch` | Protobuf encoded | +| `[]byte{0xb} + block (big endian encoded)` | A batch of outgoing transactions | `types.OutgoingTxBatch` | Protobuf encoded | + + +### LastOutgoingBatchID + +Monotonically increasing value for each batch created on Injective by some `Batch Creator` + +| Key | Value | Type | Encoding | +|---------------------------------------|--------------------|----------|--------------------| +| `[]byte{0x7} + []byte("lastBatchId")` | Last used batch ID | `uint64` | Big endian encoded | + +### SlashedBlockHeight + +Represents the latest slashed block height. There is always only a singe value stored. + +| Key | Value | Type | Encoding | +|----------------|-----------------------------------------|----------|--------------------| +| `[]byte{0xf7}` | Latest height a batch slashing occurred | `uint64` | Big endian encoded | + +### LastUnbondingBlockHeight + +Represents the latest bloch height at which a `Validator` started unbonding from the `Validator Set`. Used to determine slashing conditions. + +| Key | Value | Type | Encoding | +|----------------|------------------------------------------------------|----------|--------------------| +| `[]byte{0xf8}` | Latest height at which a Validator started unbonding | `uint64` | Big endian encoded | + +### TokenContract & Denom + +A denom that is originally from a counter chain will be from a contract. The token contract and denom are stored in two ways. First, the denom is used as the key and the value is the token contract. Second, the contract is used as the key, the value is the denom the token contract represents. + +| Key | Value | Type | Encoding | +|----------------------------------------|------------------------|----------|-----------------------| +| `[]byte{0xf3} + []byte(denom)` | Token contract address | `[]byte` | stored in byte format | +| `[]byte{0xf4} + []byte(tokenContract)` | Token denom | `[]byte` | stored in byte format | + +### LastObservedValset + +This entry represents the last observed Valset that was successfully relayed to Ethereum. Updates after an attestation of `ValsetUpdatedEvent` has been processed on Injective. + +| Key | Value | Type | Encoding | +|----------------|----------------------------------|----------------|------------------| +| `[]byte{0xfa}` | Last observed Valset on Ethereum | `types.Valset` | Protobuf encoded | + + +### LastEventNonce + +The nonce of the last observed event on Ethereum. This is set when `TryAttestation()` is called. There is always only a single value held in this store. + +| Key | Value | Type | Encoding | +|----------------|---------------------------|----------|--------------------| +| `[]byte{0xf2}` | Last observed event nonce | `uint64` | Big endian encoded | + +### LastObservedEthereumHeight + +This block height of the last observed event on Ethereum. There will always only be a single value stored in this store. + +| Key | Value | Type | Encoding | +|----------------|-------------------------------|----------|------------------| +| `[]byte{0xf9}` | Last observed Ethereum Height | `uint64` | Protobuf encoded | + + +### LastEventByValidator + +This is the last observed event on Ethereum from a particular `Validator`. Updated every time the asssociated `Orchestrator` sends an event claim. + +```go +type LastClaimEvent struct { + EthereumEventNonce uint64 + EthereumEventHeight uint64 +} +``` + +| Key | Value | Type | Encoding | +|--------------------------------------------|---------------------------------------|------------------------|------------------| +| `[]byte{0xf1} + []byte(validator address)` | Last observed event by some Validator | `types.LastClaimEvent` | Protobuf encoded | + + +### Attestation + +Attestation is an aggregate of claims that eventually becomes observed by all orchestrators as more votes (claims) are coming in. Once observed the claim's particular logic gets executed. + +Each attestation is bound to a unique event nonce (generated by `Peggy contract`) and they must be processed in order. This is a correctness issue, if relaying out of order transaction replay attacks become possible. + +```go +type Attestation struct { + Observed bool + Votes []string + Height uint64 + Claim *types.Any +} +``` +| Key | Value | Type | Encoding | +|----------------------------------------------------------------------|---------------------------------------|---------------------|------------------| +| `[]byte{0x5} + event nonce (big endian encoded) + []byte(claimHash)` | Attestation of occurred events/claims | `types.Attestation` | Protobuf encoded | + +### PastEthSignatureCheckpoint + +A computed hash indicating that a validator set/token batch in fact existed on Injective. This checkpoint also exists in `Peggy contract`. +Updated on each new valset update and token batch creation. + + +| Key | Value | Type | Encoding | +|----------------|-------------------------------------------|-------------------|----------------------| +| `[]byte{0x1b}` | Last created checkpoint hash on Injective | `gethcommon.Hash` | store in byte format | + +### EthereumBlacklist + +A list of known malicious Ethereum addresses that are prevented from using the bridge. + +| Key | Value | Type | Encoding | +|-------------------------------------------|--------------------|-------------------|------------------------| +| `[]byte{0x1c} + []byte(ethereum address)` | Empty []byte slice | `gethcommon.Hash` | stored in byte format] | + diff --git a/.gitbook/developers/modules/injective/peggy/04_messages.md b/.gitbook/developers/modules/injective/peggy/04_messages.md new file mode 100644 index 00000000..d2f14516 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/04_messages.md @@ -0,0 +1,199 @@ +--- +sidebar_position: 4 +title: Messages +--- + +# Messages + +This is a reference document for Peggy message types. For code reference and exact arguments see the [proto definitions](https://github.com/InjectiveLabs/injective-core/blob/master/proto/injective/peggy/v1/msgs.proto). + +## User messages + +These are messages sent on the Injective Chain peggy module by the end user. See [workflow](./02_workflow.md) for a more detailed summary of the entire deposit and withdraw process. + +### SendToEth + +Sent to Injective whenever a user wishes to make a withdrawal back to Ethereum. Submitted amount is removed from the user's balance immediately. +The withdrawal is added to the outgoing tx pool as a `types.OutgoingTransferTx` where it will remain until it is included in a batch. + +```go +type MsgSendToEth struct { + Sender string // sender's Injective address + EthDest string // receiver's Ethereum address + Amount types.Coin // amount of tokens to bridge + BridgeFee types.Coin // additional fee for bridge relayers. Must be of same token type as Amount +} + +``` + +### CancelSendToEth + +This message allows the user to cancel a specific withdrawal that is not yet batched. User balance is refunded (`Amount` + `BridgeFee`). + +```go +type MsgCancelSendToEth struct { + TransactionId uint64 // unique tx nonce of the withdrawal + Sender string // original sender of the withdrawal +} + +``` + +### SubmitBadSignatureEvidence + +This call allows anyone to submit evidence that a validator has signed a valset or batch that never existed. Subject contains the batch or valset. + +```go +type MsgSubmitBadSignatureEvidence struct { + Subject *types1.Any + Signature string + Sender string +} +``` + +## Batch Creator Messages + +These messages are sent by the `Batch Creator` subprocess of `peggo` + +### RequestBatch + +This message is sent whenever some `Batch Creator` finds pooled withdrawals that when batched would satisfy their minimum batch fee (`PEGGO_MIN_BATCH_FEE_USD`). +After receiving this message the `Peggy module` collects all withdrawals of the requested token denom, creates a unique token batch (`types.OutgoingTxBatch`) and places it in the `Outgoing Batch pool`. +Withdrawals that are batched cannot be cancelled with `MsgCancelSendToEth`. + + +```go +type MsgRequestBatch struct { + Orchestrator string // orchestrator address interested in creating the batch. Not permissioned. + Denom string // the specific token whose withdrawals will be batched together +} +``` + + +## Oracle Messages + +These messages are sent by the `Oracle` subprocess of `peggo` + +### DepositClaim + +Sent to Injective when a `SendToInjectiveEvent` is emitted from the `Peggy contract`. +This occurs whenever a user is making an individual deposit from Ethereum to Injective. + +```go +type MsgDepositClaim struct { + EventNonce uint64 // unique nonce of the event + BlockHeight uint64 // Ethereum block height at which the event was emitted + TokenContract string // contract address of the ERC20 token + Amount sdkmath.Int // amount of deposited tokens + EthereumSender string // sender's Ethereum address + CosmosReceiver string // receiver's Injective address + Orchestrator string // address of the Orchestrator which observed the event +} +``` + +### WithdrawClaim + +Sent to Injective when a `TransactionBatchExecutedEvent` is emitted from the `Peggy contract`. +This occurs when a `Relayer` has successfully called `submitBatch` on the contract to complete a batch of withdrawals. + +```go +type MsgWithdrawClaim struct { + EventNonce uint64 // unique nonce of the event + BlockHeight uint64 // Ethereum block height at which the event was emitted + BatchNonce uint64 // nonce of the batch executed on Ethereum + TokenContract string // contract address of the ERC20 token + Orchestrator string // address of the Orchestrator which observed the event +} +``` + +### ValsetUpdatedClaim + +Sent to Injective when a `ValsetUpdatedEvent` is emitted from the `Peggy contract`. +This occurs when a `Relayer` has successfully called `updateValset` on the contract to update the `Validator Set` on Ethereum. + +```go + +type MsgValsetUpdatedClaim struct { + EventNonce uint64 // unique nonce of the event + ValsetNonce uint64 // nonce of the valset + BlockHeight uint64 // Ethereum block height at which the event was emitted + Members []*BridgeValidator // members of the Validator Set + RewardAmount sdkmath.Int // Reward for relaying the valset update + RewardToken string // reward token contract address + Orchestrator string // address of the Orchestrator which observed the event +} +``` + +### ERC20DeployedClaim + +Sent to Injective when a `ERC20DeployedEvent` is emitted from the `Peggy contract`. +This occurs whenever the `deployERC20` method is called on the contract to issue a new token asset eligible for bridging. + +```go +type MsgERC20DeployedClaim struct { + EventNonce uint64 // unique nonce of the event + BlockHeight uint64 // Ethereum block height at which the event was emitted + CosmosDenom string // denom of the token + TokenContract string // contract address of the token + Name string // name of the token + Symbol string // symbol of the token + Decimals uint64 // number of decimals the token has + Orchestrator string // address of the Orchestrator which observed the event +} +``` + + +## Signer Messages + +These messages are sent by the `Signer` subprocess of `peggo` + +### ConfirmBatch + +When `Signer` finds a batch that the `Orchestrator` (`Validator`) has not signed off, it constructs a signature with its `Delegated Ethereum Key` and sends the confirmation to Injective. +It's crucial that a `Validator` eventually provides their confirmation for a created batch as they will be slashed otherwise. + +```go +type MsgConfirmBatch struct { + Nonce uint64 // nonce of the batch + TokenContract string // contract address of batch token + EthSigner string // Validator's delegated Ethereum address (previously registered) + Orchestrator string // address of the Orchestrator confirming the batch + Signature string // Validator's signature of the batch +} +``` + +### ValsetConfirm + +When `Signer` finds a valset update that the `Orchestrator` (`Validator`) has not signed off, it constructs a signature with its `Delegated Ethereum Key` and sends the confirmation to Injective. +It's crucial that a `Validator` eventually provides their confirmation for a created valset update as they will be slashed otherwise. + +```go +type MsgValsetConfirm struct { + Nonce uint64 // nonce of the valset + Orchestrator string // address of the Orchestrator confirming the valset + EthAddress string // Validator's delegated Ethereum address (previously registered) + Signature string // Validator's signature of the valset +} +``` + +## Relayer Messages + +The `Relayer` does not send any message to Injective, rather it constructs Ethereum transactions with Injective data to update the `Peggy contract` via `submitBatch` and `updateValset` methods. + +## Validator Messages + +These are messages sent directly using the validator's message key. + +### SetOrchestratorAddresses + +Sent to Injective by an `Operator` managing a `Validator` node. Before being able to start their `Orchestrator` (`peggo`) process, they must register a chosen Ethereum address to represent their `Validator` on Ethereum. +Optionally, an additional Injective address can be provided (`Orchestrator` field) to represent that `Validator` in the bridging process (`peggo`). Defaults to `Validator`'s own address if omitted. + +```go +type MsgSetOrchestratorAddresses struct { + Sender string // address of the Injective validator + Orchestrator string // optional Injective address to represent the Validator in the bridging process (Defaults to Sender if left empty) + EthAddress string // the Sender's (Validator) delegated Ethereum address +} +``` +This message sets the Orchestrator's delegate keys. + diff --git a/.gitbook/developers/modules/injective/peggy/05_slashing.md b/.gitbook/developers/modules/injective/peggy/05_slashing.md new file mode 100644 index 00000000..41d2fa40 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/05_slashing.md @@ -0,0 +1,91 @@ +--- +sidebar_position: 5 +title: Slashing +--- + +# Slashing +### Security Concerns + +The **Validator Set** is the actual set of keys with stake behind them, which are slashed for double-signs or other +misbehavior. We typically consider the security of a chain to be the security of a _Validator Set_. This varies on +each chain, but is our gold standard. Even IBC offers no more security than the minimum of both involved Validator Sets. + +The **Eth bridge relayer** is a binary run alongside the main `injectived` daemon by the validator set. It exists purely as a matter of code organization and is in charge of signing Ethereum transactions, as well as observing events on Ethereum and bringing them into the Injective Chain state. It signs transactions bound for Ethereum with an Ethereum key, and signs over events coming from Ethereum with an Injective Chain account key. We can add slashing conditions to any mis-signed message by any _Eth Signer_ run by the _Validator Set_ and be able to provide the same security as the _Validator Set_, just a different module detecting evidence of malice and deciding how much to slash. If we can prove a transaction signed by any _Eth Signer_ of the _Validator Set_ was illegal or malicious, then we can slash on the Injective Chain side and potentially provide 100% of the security of the _Validator Set_. Note that this also has access to the 3 week unbonding period to allow evidence to slash even if they immediately unbond. + +Below are various slashing conditions we use in Peggy. + +## PEGGYSLASH-01: Signing fake validator set or tx batch evidence + +This slashing condition is intended to stop validators from signing over a validator set and nonce that has never existed on the Injective Chain. It works via an evidence mechanism, where anyone can submit a message containing the signature of a validator over a fake validator set. This is intended to produce the effect that if a cartel of validators is formed with the intention of submitting a fake validator set, one defector can cause them all to be slashed. +```go +// This call allows anyone to submit evidence that a +// validator has signed a valset, batch, or logic call that never +// existed. Subject contains the batch, valset, or logic call. +type MsgSubmitBadSignatureEvidence struct { + Subject *types1.Any + Signature string + Sender string +} +``` +**Implementation considerations:** + +The trickiest part of this slashing condition is determining that a validator set has never existed on Injective. To save space, we will need to clean up old validator sets. We could keep a mapping of validator set hash to true in the KV store, and use that to check if a validator set has ever existed. This is more efficient than storing the whole validator set, but its growth is still unbounded. It might be possible to use other cryptographic methods to cut down on the size of this mapping. It might be OK to prune very old entries from this mapping, but any pruning reduces the deterrence of this slashing condition. + +The implemented version of this slashing condition stores a map of hashes for all past events, this is smaller than storing entire batches or validator sets and doesn't have to be accessed as frequently. A possible but not currently implemented efficiency optimization would be to remove hashes from this list after a given period. But this would require storing more metadata about each hash. + +Currently automatic evidence submission is not implemented in the relayer. By the time a signature is visible on Ethereum it's already too late for slashing to prevent bridge highjacking or theft of funds. Furthermore since 66% of the validator set is required to perform this action anyways that same controlling majority could simply refuse the evidence. The most common case envisioned for this slashing condition is to break up a cabal of validators trying to take over the bridge by making it more difficult for them to trust one another and actually coordinate such a theft. + +The theft would involve exchanging of slashable Ethereum signatures and open up the possibility of a manual submission of this message by any defector in the group. + +Currently this is implemented as an ever growing array of hashes in state. + +## PEGGYSLASH-02: Failure to sign tx batch + +This slashing condition is triggered when a validator does not sign a transaction batch within `SignedBatchesWindow` upon it's creation by the Peggy module. This prevents two bad scenarios- + +1. A validator simply does not bother to keep the correct binaries running on their system, +2. A cartel of >1/3 validators unbond and then refuse to sign updates, preventing any batches from getting enough signatures to be submitted to the Peggy Ethereum contract. + +## PEGGYSLASH-03: Failure to sign validator set update + +This slashing condition is triggered when a validator does not sign a validator set update which is produced by the Peggy module. This prevents two bad scenarios- + +1. A validator simply does not bother to keep the correct binaries running on their system, +2. A cartel of >1/3 validators unbond and then refuse to sign updates, preventing any validator set updates from getting enough signatures to be submitted to the Peggy Ethereum contract. If they prevent validator set updates for longer than the Injective Chain unbonding period, they can no longer be punished for submitting fake validator set updates and tx batches (PEGGYSLASH-01 and PEGGYSLASH-03). + +To deal with scenario 2, PEGGYSLASH-03 will also need to slash validators who are no longer validating, but are still in the unbonding period for up to `UnbondSlashingValsetsWindow` blocks. This means that when a validator leaves the validator set, they will need to keep running their equipment for at least `UnbondSlashingValsetsWindow` blocks. This is unusual for the Injective Chain, and may not be accepted by the validators. + +The current value of `UnbondSlashingValsetsWindow` is 25,000 blocks, or about 12-14 hours. We have determined this to be a safe value based on the following logic. So long as every validator leaving the validator set signs at least one validator set update that they are not contained in then it is guaranteed to be possible for a relayer to produce a chain of validator set updates to transform the current state on the chain into the present state. + +It should be noted that both PEGGYSLASH-02 and PEGGYSLASH-03 could be eliminated with no loss of security if it where possible to perform the Ethereum signatures inside the consensus code. This is a pretty limited feature addition to Tendermint that would make Peggy far less prone to slashing. + +## PEGGYSLASH-04: Submitting incorrect Eth oracle claim (Disabled for now) + +The Ethereum oracle code (currently mostly contained in attestation.go), is a key part of Peggy. It allows the Peggy module to have knowledge of events that have occurred on Ethereum, such as deposits and executed batches. PEGGYSLASH-03 is intended to punish validators who submit a claim for an event that never happened on Ethereum. + +**Implementation considerations** + +The only way we know whether an event has happened on Ethereum is through the Ethereum event oracle itself. So to implement this slashing condition, we slash validators who have submitted claims for a different event at the same nonce as an event that was observed by >2/3s of validators. + +Although well-intentioned, this slashing condition is likely not advisable for most applications of Peggy. This is because it ties the functioning of the Injective Chain which it is installed on to the correct functioning of the Ethereum chain. If there is a serious fork of the Ethereum chain, different validators behaving honestly may see different events at the same event nonce and be slashed through no fault of their own. Widespread unfair slashing would be very disruptive to the social structure of the Injective Chain. + +Maybe PEGGYSLASH-04 is not necessary at all: + +The real utility of this slashing condition is to make it so that, if >2/3 of the validators form a cartel to all submit a fake event at a certain nonce, some number of them can defect from the cartel and submit the real event at that nonce. If there are enough defecting cartel members that the real event becomes observed, then the remaining cartel members will be slashed by this condition. However, this would require >1/2 of the cartel members to defect in most conditions. + +If not enough of the cartel defects, then neither event will be observed, and the Ethereum oracle will just halt. This is a much more likely scenario than one in which PEGGYSLASH-04 is actually triggered. + +Also, PEGGYSLASH-04 will be triggered against the honest validators in the case of a successful cartel. This could act to make it easier for a forming cartel to threaten validators who do not want to join. + +## PEGGYSLASH-05: Failure to submit Eth oracle claims (Disabled for now) + +This is similar to PEGGYSLASH-04, but it is triggered against validators who do not submit an oracle claim that has been observed. In contrast to PEGGYSLASH-04, PEGGYSLASH-05 is intended to punish validators who stop participating in the oracle completely. + +**Implementation considerations** + +Unfortunately, PEGGYSLASH-05 has the same downsides as PEGGYSLASH-04 in that it ties the correct operation of the Injective Chain to the Ethereum chain. Also, it likely does not incentivize much in the way of correct behavior. To avoid triggering PEGGYSLASH-05, a validator simply needs to copy claims which are close to becoming observed. This copying of claims could be prevented by a commit-reveal scheme, but it would still be easy for a "lazy validator" to simply use a public Ethereum full node or block explorer, with similar effects on security. Therefore, the real usefulness of PEGGYSLASH-05 is likely minimal + +PEGGYSLASH-05 also introduces significant risks. Mostly around forks on the Ethereum chain. For example recently OpenEthereum failed to properly handle the Berlin hardfork, the resulting node 'failure' was totally undetectable to automated tools. It didn't crash so there was no restart to perform, blocks where still being produced although extremely slowly. If this had occurred while Peggy was running with PEGGYSLASH-05 active it would have caused those validators to be removed from the set. Possibly resulting in a very chaotic moment for the chain as dozens of validators where removed for little to no fault of their own. + +Without PEGGYSLASH-04 and PEGGYSLASH-05, the Ethereum event oracle only continues to function if >2/3 of the validators voluntarily submit correct claims. Although the arguments against PEGGYSLASH-04 and PEGGYSLASH-05 are convincing, we must decide whether we are comfortable with this fact. Alternatively we must be comfortable with the Injective Chain potentially halting entirely due to Ethereum generated factors. + diff --git a/.gitbook/developers/modules/injective/peggy/06_end_block.md b/.gitbook/developers/modules/injective/peggy/06_end_block.md new file mode 100644 index 00000000..40bcae02 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/06_end_block.md @@ -0,0 +1,51 @@ +--- +sidebar_position: 5 +title: End-Block +--- + +# EndBlocker + +Upon the end of each block the following operations are performed to the state of the module + +## 1. Slashing + +### Validator slashing + +A validator is slashed for not signing over a valset update which passed the `SignedValsetsWindow`. +In other words, if a validator fails to provide the confirmation for a valset update within a preconfigured amount of time, they will be slashed for `SlashFractionValset` portion of their stake and get jailed immediately. + +### Batch Slashing + +A validator is slashed for not signing over a batch which passed the `SignedBatchesWindow`. +In other words, if a validator fails to provide the confirmation for a batch within a preconfigured amount of time, they will be slashed for `SlashFractionBatch` portion of their stake and get jailed immediately. + +## 2. Cancelling timed out batches + +Any batch still present in the `Outgoing Batch pool` whose `BatchTimeout` (a designated Ethereum height by which the batch should have executed) is exceeded gets removed from the pool and the withdrawals are reinserted back into the `Outgoing Tx pool`. + +## 3. Creating new Valset updates + +A new `Validator Set` update will be created automatically when: +* there is a power diff greater than 5% between the latest and current validator set +* a validator begins unbonding + +The new validator set is eventually relayed to `Peggy contract` on Ethereum. + +## 4. Pruning old validator sets + +Previously observed valsets that passed the `SignedValsetsWindow` are removed from the state + +## 5. Attestation processing + +Processes all attestations (an aggregate of claims for a particular event) currently being voted on. Each attestation is processed one by one to ensure each `Peggy contract` event is processed. +After each processed attestation the module's `lastObservedEventNonce` and `lastObservedEthereumBlockHeight` are updated. + +Depending on the type of claim in the attestation, the following is executed: +* `MsgDepositClaim`: deposited tokens are minted/unlocked for the receiver address +* `MsgWithdrawClaim`: corresponding batch is removed from the outgoing pool and any previous batch is cancelled +* `MsgValsetUpdatedClaim`: the module's `LastObservedValset` is updated +* `MsgERC20DeployedClaim`: new token metadata is validated and registered within the module's state (`denom <-> token_contract`) + +## 6. Cleaning up processed attestations + +Previously processed attestations (height earlier that `lastObservedEthereumBlockHeight`) are removed from the module state diff --git a/.gitbook/developers/modules/injective/peggy/07_events.md b/.gitbook/developers/modules/injective/peggy/07_events.md new file mode 100644 index 00000000..68ea6656 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/07_events.md @@ -0,0 +1,143 @@ +--- +sidebar_position: 7 +title: Events +--- + +# Events + +The peggy module emits the following events: + +## EndBlocker + +### EventAttestationObserved +| Type | Attribute Key | Attribute Value | +|--------|------------------|---------------------------| +| int32 | attestation_type | {attestation_type} | +| string | bridge_contract | {bridge_contract_address} | +| uint64 | bridge_chain_id | {bridge_chain_id} | +| []byte | attestation_id | {attestation_id} | +| uint64 | nonce | {event_nonce} | + +### EventValidatorSlash +| Type | Attribute Key | Attribute Value | +|--------|-------------------|-----------------------| +| string | reason | {reason_for_slashing} | +| int64 | power | {validator_power} | +| string | consensus_address | {consensus_addr} | +| string | operator_address | {operator_addr} | +| string | moniker | {validator_moniker} | + + +## Handler + +### EventSetOrchestratorAddresses + +| Type | Attribute Key | Attribute Value | +|--------|----------------------|---------------------| +| string | validator_address | {validator_addr} | +| string | orchestrator_address | {orchestrator_addr} | +| string | operator_eth_address | {eth_addr} | + +### EventSendToEth + +| Type | Attribute Key | Attribute Value | +|----------|----------------|-----------------| +| message | outgoing_tx_id | {tx_id} | +| string | sender | {sender_addr} | +| string | receiver | {dest_addr} | +| sdk.Coin | amount | {token_amount} | +| sdk.Coin | bridge_fee | {token_amount} | + + +### EventBridgeWithdrawCanceled +| Type | Attribute Key | Attribute Value | +|----------------------|-----------------|-------------------| +| withdrawal_cancelled | bridge_contract | {bridge_contract} | +| withdrawal_cancelled | bridge_chain_id | {bridge_chain_id} | + + +### EventOutgoingBatch + +| Type | Attribute Key | Attribute Value | +|----------|----------------------|-----------------| +| string | denom | {token_denom} | +| string | orchestrator_address | {orch_addr} | +| uint64 | batch_nonce | {batch_nonce} | +| uint64 | batch_timeout | {block_height} | +| []uint64 | batch_tx_ids | {ids} | + +### EventOutgoingBatchCanceled +| Type | Attribute Key | Attribute Value | +|--------|-----------------|-------------------| +| string | bridge_contract | {bridge_contract} | +| uint64 | bridge_chain_id | {bridge_chain_id} | +| uint64 | batch_id | {id} | +| uint64 | nonce | {nonce} | + +### EventValsetConfirm + +| Type | Attribute Key | Attribute Value | +|--------|----------------------|-----------------| +| uint64 | valset_nonce | {nonce} | +| string | orchestrator_address | {prch_addr} | + + +### EventConfirmBatch + +| Type | Attribute Key | Attribute Value | +|--------|----------------------|-----------------| +| uint64 | batch_nonce | {nonce} | +| string | orchestrator_address | {orch_addr} | + +### EventDepositClaim + +| Type | Attribute Key | Attribute Value | +|---------|----------------------|-------------------| +| uint64 | event_nonce | {event_nonce} | +| uint64 | event_height | {event_height} | +| []byte | attestation_id | {attestation_key} | +| string | ethereum_sender | {sender_addr} | +| string | cosmos_receiver | {receiver_addr} | +| string | token_contract | {contract_addr} | +| sdk.Int | amount | {token_amount} | +| string | orchestrator_address | {orch_addr} | +| string | data | {custom_data} | + + +### EventWithdrawClaim + +| Type | Attribute Key | Attribute Value | +|--------|----------------------|-------------------| +| uint64 | event_nonce | {event_nonce{ | +| uint64 | event_height | {event_height} | +| []byte | attestation_id | {attestation_key} | +| uint64 | batch_nonce | {batch_nonce} | +| string | token_contract | {contract_addr} | +| string | orchestrator_address | {orch_addr} | + +### EventERC20DeployedClaim +| Type | Attribute Key | Attribute Value | +|--------|----------------------|------------------------| +| uint64 | event_nonce | {event_nonce} | +| uint64 | event_height | {event_height} | +| []byte | attestation_id | {attestation_key} | +| string | cosmos_denom | {token_denom} | +| string | token_contract | {token_conntract_addr} | +| string | name | {token_name} | +| string | symbol | {token_symbol} | +| uint64 | decimals | {token_decimals} | +| string | orchestrator_address | {orch_addr} | + +### EventValsetUpdateClaim +| Type | Attribute Key | Attribute Value | +|--------------------|----------------------|-----------------------| +| uint64 | event_nonce | {event_nonce} | +| uint64 | event_height | {event_height} | +| []byte | attestation_id | {attestation_key} | +| uint64 | valset_nonce | {valset_nonce} | +| []*BridgeValidator | valset_members | {array_of_validators} | +| sdk.Int | reward_amount | {amount} | +| string | reward_token | {contract_addr} | +| string | orchestrator_address | {orch_addr} | + + diff --git a/.gitbook/developers/modules/injective/peggy/08_params.md b/.gitbook/developers/modules/injective/peggy/08_params.md new file mode 100644 index 00000000..d76128cc --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/08_params.md @@ -0,0 +1,112 @@ +--- +sidebar_position: 8 +title: Parameters +--- + +# Params + +This document describes and advises configuration of the Peggy module's parameters. The default parameters can be found in the genesis.go of the peggy module. + +```go +type Params struct { + PeggyId string + ContractSourceHash string + BridgeEthereumAddress string + BridgeChainId uint64 + SignedValsetsWindow uint64 + SignedBatchesWindow uint64 + SignedClaimsWindow uint64 + TargetBatchTimeout uint64 + AverageBlockTime uint64 + AverageEthereumBlockTime uint64 + SlashFractionValset math.LegacyDec + SlashFractionBatch math.LegacyDec + SlashFractionClaim math.LegacyDec + SlashFractionConflictingClaim math.LegacyDec + UnbondSlashingValsetsWindow uint64 + SlashFractionBadEthSignature math.LegacyDec + CosmosCoinDenom string + CosmosCoinErc20Contract string + ClaimSlashingEnabled bool + BridgeContractStartHeight uint64 + ValsetReward types.Coin +} +``` + +## `peggy_id` + +A random 32 byte value to prevent signature reuse, for example if the +Injective Chain validators decided to use the same Ethereum keys for another chain +also running Peggy we would not want it to be possible to play a deposit +from chain A back on chain B's Peggy. This value IS USED ON ETHEREUM so +it must be set in your genesis.json before launch and not changed after +deploying Peggy. Changing this value after deploying Peggy will result +in the bridge being non-functional. To recover just set it back to the original +value the contract was deployed with. + +## `contract_source_hash` + +The code hash of a known good version of the Peggy contract +solidity code. This can be used to verify the correct version +of the contract has been deployed. This is a reference value for +governance action only it is never read by any Peggy code + +## `bridge_ethereum_address` + +is address of the bridge contract on the Ethereum side, this is a +reference value for governance only and is not actually used by any +Peggy module code. + +The Ethereum bridge relayer use this value to interact with Peggy contract for querying events and submitting valset/batches to Peggy contract. + +## `bridge_chain_id` + +The bridge chain ID is the unique identifier of the Ethereum chain. This is a reference value only and is not actually used by any Peggy code + +These reference values may be used by future Peggy client implementations to allow for consistency checks. + +## Signing windows + +* `signed_valsets_window` +* `signed_batches_window` +* `signed_claims_window` + +These values represent the time in blocks that a validator has to submit +a signature for a batch or valset, or to submit a claim for a particular +attestation nonce. + +In the case of attestations this clock starts when the +attestation is created, but only allows for slashing once the event has passed. +Note that that claims slashing is not currently enabled see [slashing spec](./05_slashing.md) + +## `target_batch_timeout` + +This is the 'target' value for when batches time out, this is a target because +Ethereum is a probabilistic chain and you can't say for sure what the block +frequency is ahead of time. + +## Ethereum timing + +* `average_block_time` +* `average_ethereum_block_time` + +These values are the average Injective Chain block time and Ethereum block time respectively +and they are used to compute what the target batch timeout is. It is important that +governance updates these in case of any major, prolonged change in the time it takes +to produce a block + +## Slash fractions + +* `slash_fraction_valset` +* `slash_fraction_batch` +* `slash_fraction_claim` +* `slash_fraction_conflicting_claim` + +The slashing fractions for the various peggy related slashing conditions. The first three +refer to not submitting a particular message, the third for failing to submit a claim and the last for submitting a different claim than other validators. + +Note that claim slashing is currently disabled as outlined in the [slashing spec](./05_slashing.md) + +## `valset_reward` + +Valset reward is the reward amount paid to a relayer when they relay a valset to the Peggy contract on Ethereum. \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/peggy/09_relay_semantics.md b/.gitbook/developers/modules/injective/peggy/09_relay_semantics.md new file mode 100644 index 00000000..8dbcad36 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/09_relay_semantics.md @@ -0,0 +1,53 @@ +--- +sidebar_position: 9 +title: Relay Semantics +--- + +# Relay Semantics + +This document is designed to assist developers in implementing alternate Peggy relayers. The two major components of the Orchestrator which interact with Ethereum. The Peggy bridge has been designed for increased efficiency, not for ease of use. This means there are many implicit requirements of these external binaries which this document does it's best to make explicit. + +The Peggy `orchestrator` combines three distinct roles that need to be performed by external binaries in the Peggy bridge. This document highlights the requirements of the `relayer` which is one of those roles included in the `orchestrator`. + +## Semantics for Validator set update relaying + +### Sorting and Ordering of the Validator set and signatures + +When updating the validator set in the Peggy contract you must provide a copy of the old validator set. This _MUST_ only be taken from the last ValsetUpdated event on the Ethereum chain. + +Providing the old validator set is part of a storage optimization, instead of storing the entire validator set in Ethereum storage it is instead provided by each caller and stored in the much cheaper Ethereum event queue. No sorting of any kind is performed in the Peggy contract, meaning the list of validators and their new signatures must be submitted in exactly the same order as the last call. + +For the purpose of normal operation this requirement can be shortened to 'sort the validators by descending power, and by Eth address bytes where power is equal'. Since the peggy module produces the validator sets they should always come in order. It is not possible for the relayer to change this order since it is part of the signature. But a change in this sorting method on the Peggy module side would halt valset updates and essentially decouple the bridge unless your implementation is smart enough to take a look at the last submitted order rather than blindly following sorting. + +### Deciding what Validator set to relay + +The Injective Chain simply produces a stream of validator sets, it does not make any judgement on how they are relayed. It's up to the relayer implementation to determine how to optimize the gas costs of this relaying operation. + +For example lets say we had validator sets `A, B, C, and D` each is created when there is a 5% power difference between the last Peggy validator set snapshot in the store and the currently active validator set. + +5% is an arbitrary constant. The specific value chosen here is a tradeoff made by the chain between how up to date the Ethereum validator set is and the cost to keep it updated. The higher this value is the lower the portion of the voting validator set is needed to highjack the bridge in the worst case. If we made a new validator set update every block 66% would need to collude, the 5% change threshold means 61% of the total voting power colluding in a given validator set may be able to steal the funds in the bridge. + +``` +A -> B -> C -> D + 5% 10% 15% +``` + +The relayer should iterate over the event history for the Peggy Ethereum contract, it will determine that validator set A is currently in the Peggy bridge. It can choose to either relay validator sets B, C and then D or simply submit validator set D. Provided all validators have signed D it has more than 66% voting power and can pass on it's own. Without paying potentially several hundred dollars more in Ethereum to relay the intermediate sets. + +Performing this check locally somehow, before submitting transactions, is essential to a cost effective relayer implementation. You can either use a local Ethereum signing implementation and sum the powers and signatures yourself, or you can simply use the `eth_call()` Ethereum RPC to simulate the call on your Ethereum node. + +Note that `eth_call()` often has funny gotchas. All calls fail on Geth based implementations if you don't have any Ethereum to pay for gas, while on Parity based implementations your gas inputs are mostly ignored and an accurate gas usage is returned. + +## Semantics for transaction batch relaying + +In order to submit a transaction batch you also need to submit the last set of validators and their staking powers. This is to facilitate the same storage optimization mentioned there. + +### Deciding what batch to relay + +Making a decision about which batch to relay is very different from deciding which validator set to relay. Batch relaying is primarily motivated by fees, not by a desire to maintain the integrity of the bridge. So the decision mostly comes down to fee computation, this is further complicated by the concept of 'batch requests'. Which is an unpermissioned transaction that requests the Peggy module generate a new batch for a specific token type. + +Batch requests are designed to allow the user to withdraw their tokens from the send to Ethereum tx pool at any time up until a relayer shows interest in actually relaying them. While transactions are in the pool there's no risk of a double spend if the user is allowed to withdraw them by sending a MsgCancelSendToEth. Once the transaction enters a batch due to a 'request batch' that is no longer the case and the users funds must remain locked until the Oracle informs the Peggy module that the batch containing the users tokens has become somehow invalid to submit or has been executed on Ethereum. + +A relayer uses the query endpoint `BatchFees` to iterate over the send to Eth tx pool for each token type, the relayer can then observe the price for the ERC-20 tokens being relayed on a dex and compute the gas cost of executing the batch (via `eth_call()`) as well as the gas cost of liquidating the earnings on a dex if desired. Once a relayer determines that a batch is good and profitable it can send a `MsgRequestBatch` and the batch will be created for the relayer to relay. + +There are also existing batches, which the relayer should also judge for profitability and make an attempt at relaying using much the same method. diff --git a/.gitbook/developers/modules/injective/peggy/10_future_improvements.md b/.gitbook/developers/modules/injective/peggy/10_future_improvements.md new file mode 100644 index 00000000..76771318 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/10_future_improvements.md @@ -0,0 +1,22 @@ +--- +sidebar_position: 10 +title: Future Improvements +--- + +# Future Improvements + +### Native Ethereum Signing + +Validators run a required `Eth Signer` in the peggo orchestrator because we can not yet insert this sort of simple signature logic into Cosmos SDK based chains without significant modification to Tendermint. This may be possible in the future with [modifications to Tendermint](https://github.com/tendermint/tendermint/issues/6066). + +It should be noted that both [PEGGYSLASH-02](./05_slashing.md) and [PEGGYSLASH-03](./05_slashing.md) could be eliminated with no loss of security if it where possible to perform the Ethereum signatures inside the consensus code. This is a pretty limited feature addition to Tendermint that would make Peggy far less prone to slashing. + +### Improved Validator Incentives + +Currently validators in Peggy have only one carrot - the extra activity brought to the chain by a functioning bridge. + +There are on the other hand a lot of negative incentives (sticks) that the validators must watch out for. These are outlined in the [slashing spec](./05_slashing.md). + +One negative incentive that is not covered under slashing is the cost of submitting oracle submissions and signatures. Currently these operations are not incentivized, but still cost the validators fees to submit. This isn't a severe issue considering the relatively cheap transaction fees on the Injective Chain currently, but of course is an important factor to consider as transaction fees rise. + +Some positive incentives for correctly participating in the operation of the bridge should be under consideration. In addition to eliminating the fees for mandatory submissions. \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/peggy/README.md b/.gitbook/developers/modules/injective/peggy/README.md new file mode 100644 index 00000000..87c78767 --- /dev/null +++ b/.gitbook/developers/modules/injective/peggy/README.md @@ -0,0 +1,39 @@ +# `Peggy` + +## Abstract + +The peggy module enables the Injective Chain to support a trustless, on-chain bidirectional ERC-20 token bridge to Ethereum. In this system, +holders of ERC-20 tokens on Ethereum can convert their ERC-20 tokens to Cosmos-native coins on +the Injective Chain and vice-versa. + +This decentralized bridge is secured and operated by the validators of the Injective Chain. + +## Contents + +1. **[Definitions](./01_definitions.md)** +2. **[Workflow](./02_workflow.md)** +3. **[State](./03_state.md)** +4. **[Messages](./04_messages.md)** +5. **[Slashing](./05_slashing.md)** +6. **[End-Block](./06_end_block.md)** +7. **[Events](./07_events.md)** +8. **[Parameters](./08_params.md)** + +### Components + +1. **[Peggy](https://etherscan.io/address/0xF955C57f9EA9Dc8781965FEaE0b6A2acE2BAD6f3) smart contract on Ethereum** +2. **Peggy module on the Injective Chain** +3. **[Peggo](https://github.com/InjectiveLabs/peggo) (off-chain relayer aka orchestrator)** + - **Oracle** (Observes events of Peggy contract and send claims to the Peggy module) + - **EthSigner** (Signs Valset and Batch confirmations to the Peggy module) + - **Batch Requester** (Sends batch token withdrawal requests to the Peggy module) + - **Valset Relayer** (Submits Validator set updates to the Peggy contract) + - **Batch Relayer** (Submits batches of token withdrawals to the Peggy contract) + +In addition to running an `injectived` node to sign blocks, Injective Chain validators must also run the `peggo` orchestrator to relay data from the Peggy smart contract on Ethereum and the Peggy module on the Injective Chain. + +### Peggo Functionalities + +1. **Maintaining an up-to-date checkpoint of the Injective Chain validator set on Ethereum** +2. **Transferring ERC-20 tokens from Ethereum to the Injective Chain** +3. **Transferring pegged tokens from the Injective Chain to Ethereum** diff --git a/.gitbook/developers/modules/injective/peggy/images/SendToCosmos.png b/.gitbook/developers/modules/injective/peggy/images/SendToCosmos.png new file mode 100644 index 0000000000000000000000000000000000000000..c66908f6a93672f6155a46d39385a63f5cb7456b GIT binary patch literal 302926 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 MuW}48d*SB)17A=|u>b%7 literal 0 HcmV?d00001 diff --git a/.gitbook/developers/modules/injective/peggy/images/SendToEth.png b/.gitbook/developers/modules/injective/peggy/images/SendToEth.png new file mode 100644 index 0000000000000000000000000000000000000000..914787ed67a5f75bc4547fe53be893653222b865 GIT binary patch literal 486210 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%0DTcQ@xjUptP!is)rCd7^RlSy*XSoo5bt>Cwx64+Z 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 z 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
  • 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¬ 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

    >~h)Q3aio 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 Ja7Nqhe*rzW;P(Ik literal 0 HcmV?d00001 diff --git a/.gitbook/developers/modules/injective/peggy/images/valsetupdate.png b/.gitbook/developers/modules/injective/peggy/images/valsetupdate.png new file mode 100644 index 0000000000000000000000000000000000000000..5592111fcfeb13019681da54b937498e3fba87bf GIT binary patch literal 517707 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

      p;?LroJ!oa_@Fi*MA+4!t_5^-(FE`mlnvj+qMk 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

      E&*4AcEUQ52h-63Rui`A`sM|1RmNCLu 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 GBmWDXzs2eR literal 0 HcmV?d00001 diff --git a/.gitbook/developers/modules/injective/permissions/01_concepts.md b/.gitbook/developers/modules/injective/permissions/01_concepts.md new file mode 100644 index 00000000..9b166cbf --- /dev/null +++ b/.gitbook/developers/modules/injective/permissions/01_concepts.md @@ -0,0 +1,57 @@ +--- +sidebar_position: 1 +title: Concepts +--- + + +## Key Concepts + +### Denoms +Tokens on Injective are referred to as denoms which are tracked and managed by the bank module on Injective. The permissions +module creates and manages assets by representing them as denoms and attaching specific permissions to them, which are then +managed by different roles. + +Note that the permissions module itself does not create new denoms, but rather attaches permissions to existing denoms +created by the tokenfactory module. The denom admin specified in the authority metadata of the denom created by the +tokenfactory module is the only address that can set and update permissions to the denom. + +### Namespace + +A token can be associated with a specific namespace which defines the set of roles and permissions associated with the +token, including e.g. the set of addresses (roles) allowed to mint, burn, and receive the token. The namespace also can +specify a Cosmwasm smart contract which can define custom logic to be invoked when a token is transferred, if more complex +control over transfers is desired. + +### Roles + +Roles group permissions together under a single human readable label. An address can be assigned multiple roles within a +namespace, and each role can have multiple actions allowed by them. Currently, there are three different actions supported: + +- Mint: Allows for minting/issuance of new tokens of this denom +- Burn: Allows for burning tokens of this denom +- Receive: Allows for receiving tokens of this denom + +### Actions + +`Minting`: Since mints can only be done from the denom admin address in Cosmos SDK, we assume that all mints are +performed by the denom admin and then transferred to the minter address. Therefore, any send from the denom admin +address can be considered a mint performed by the minter address (even though it is technically done by the denom admin). + +`Burning`: Similarly, burns can only be performed from the denom admin address, so transfers to the denom admin address +are considered burns. + +`Receiving`: Everything else is just a Receive. + +### Permissions + +Permissions define what actions an address can perform within a namespace. Default permissions for addresses not assigned +any role can be applied through `EVERYONE` role when creating or updating a namespace. Permissions can be used to control +actions like minting tokens, recieving tokens, or burning tokens. + +### Vouchers + +Whenever a transfer from a predefined set of module addresses (exchange, auction, insurance) to a user address fails due +to restrictions, the destination address of the transefer is rewritten to the permissions module address, where the tokens +are held. The original receiver of the funds is be assigned a voucher for the amount of tokens held inside the module. +The user will be able to claim the voucher only if they got assigned the respective permissions (RECEIVE action should +be allowed), which they didn't have previously and was the cause of the initial transfer failure. diff --git a/.gitbook/developers/modules/injective/permissions/02_state.md b/.gitbook/developers/modules/injective/permissions/02_state.md new file mode 100644 index 00000000..f026f149 --- /dev/null +++ b/.gitbook/developers/modules/injective/permissions/02_state.md @@ -0,0 +1,93 @@ +--- +sidebar_position: 2 +title: State +--- + +# State + +Genesis state defines the initial state of the module to be used to setup the module. + +```go +// GenesisState defines the permissions module's genesis state. +type GenesisState struct { + // params defines the parameters of the module. + Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"` + Namespaces []Namespace `protobuf:"bytes,2,rep,name=namespaces,proto3" json:"namespaces"` +} +``` + +## Params + +The permissions module doesn't use any params. +```go +// Params defines the parameters for the permissions module. +type Params struct { + WasmHookQueryMaxGas uint64 `protobuf:"varint,1,opt,name=wasm_hook_query_max_gas,json=wasmHookQueryMaxGas,proto3" json:"wasm_hook_query_max_gas,omitempty"` +} +``` + +## Namespaces + +Addresses can create permissioned namespaces with new denoms. Namespaces define roles and actions that users in the namespace are allowed or disallowed to perform or be. + +```go +// Namespace defines a permissions namespace +type Namespace struct { + Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty"` + WasmHook string `protobuf:"bytes,2,opt,name=wasm_hook,json=wasmHook,proto3" json:"wasm_hook,omitempty"` + MintsPaused bool `protobuf:"varint,3,opt,name=mints_paused,json=mintsPaused,proto3" json:"mints_paused,omitempty"` + SendsPaused bool `protobuf:"varint,4,opt,name=sends_paused,json=sendsPaused,proto3" json:"sends_paused,omitempty"` + BurnsPaused bool `protobuf:"varint,5,opt,name=burns_paused,json=burnsPaused,proto3" json:"burns_paused,omitempty"` + RolePermissions map[string]uint32 `protobuf:"bytes,6,rep,name=role_permissions,json=rolePermissions,proto3" json:"role_permissions,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"` + AddressRoles map[string]*Roles `protobuf:"bytes,7,rep,name=address_roles,json=addressRoles,proto3" json:"address_roles,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` +} +``` + +Within a namespace, `MintsPaused`, `SendsPaused` and `BurnsPaused` determine whether new tokens can minted, sent or burnt. They can be updated only by the Denom admin. + +## Roles + +`Roles` are strings in a namespace where each role has specific permissions. + +```go +type Roles struct { + Roles []string `protobuf:"bytes,1,rep,name=roles,proto3" json:"roles,omitempty"` +} +``` + +## Actions + +Actions are powers of two used to denote different types of actions, `Action_UNSPECIFIED` = 0, `Action_MINT` = 1, `Action_RECEIVE` = 2 and `Action_BURN` = 4. + +```go +// each Action enum value should be a power of two +type Action int32 +``` + +## Role + +`Role` stores the name of the role and actions allowed to the role. + +```go +// Role is only used for storage +type Role struct { + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + Permissions uint32 `protobuf:"varint,2,opt,name=permissions,proto3" json:"permissions,omitempty"` +} +``` + +## RoleIDs + +`RoleIDs` stores IDs for the roles. + +```go +// used in storage +type RoleIDs struct { + RoleIds []uint32 `protobuf:"varint,1,rep,packed,name=role_ids,json=roleIds,proto3" json:"role_ids,omitempty"` +} +``` + +## Voucher + +A `Voucher` holds tokens from all failed transactions until the original receiver has `RECEIVE` permissions. +* Vouchers: `0x06 | Address | denom -> ProtocolBuffer(Coin)` diff --git a/.gitbook/developers/modules/injective/permissions/03_state_transitions.md b/.gitbook/developers/modules/injective/permissions/03_state_transitions.md new file mode 100644 index 00000000..fe0a11bf --- /dev/null +++ b/.gitbook/developers/modules/injective/permissions/03_state_transitions.md @@ -0,0 +1,188 @@ +--- +sidebar_position: 3 +title: State Transitions +--- + +# State Transitions + +This document describes the state transition operations pertaining to: + +- Create namespace +- Delete namespace +- Update namespace +- Update namespace roles +- Revoke namespace roles +- Claim Voucher +- Update params + +## Create Namespace + +Namespaces can be created for implementing different roles and actions. + +```protobuf +message MsgCreateNamespace { + option (cosmos.msg.v1.signer) = "sender"; + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + + Namespace namespace = 2 [ (gogoproto.nullable) = false ]; +} + +// Namespace defines a permissions namespace +message Namespace { + string denom = 1; // tokenfactory denom to which this namespace applies to + string wasm_hook = + 2; // address of smart contract to apply code-based restrictions + + bool mints_paused = 3; + bool sends_paused = 4; + bool burns_paused = 5; + + repeated Role role_permissions = 6; // permissions for each role + + repeated AddressRoles address_roles = 7; +} + +message AddressRoles { + string address = 1; + repeated string roles = 2; +} + +message Role { + string role = 1; + uint32 permissions = 2; +} +``` + +**Steps** + +- Create a new denom +- Create a `MsgCreateNamespace` message with `Denom`, `RolePermissions` and `AddressRoles`. +- Validate the `MsgCreateNamespace` object. +- Send the create namespace message. + +## Delete Namespace + +Deleting a namespace removes it and its associated roles and permissions. +```protobuf +message MsgDeleteNamespace { + option (cosmos.msg.v1.signer) = "sender"; + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + + string namespace_denom = 2; +} +``` + +**Steps** + +- Create a `MsgDeleteNamespace` message with the namespace denom `NamespaceDenom` to be deleted. +- Validate the `MsgDeleteNamespace` object. +- Send the delete namespace message. + +## Update Namespace + +Updating a namespace allows modifying its associated roles and permissions. +```protobuf +message MsgUpdateNamespace { + option (cosmos.msg.v1.signer) = "sender"; + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + + string namespace_denom = + 2; // namespace denom to which this updates are applied + + message MsgSetWasmHook { string new_value = 1; } + MsgSetWasmHook wasm_hook = + 3; // address of smart contract to apply code-based restrictions + + message MsgSetMintsPaused { bool new_value = 1; } + MsgSetMintsPaused mints_paused = 4; + + message MsgSetSendsPaused { bool new_value = 1; } + MsgSetSendsPaused sends_paused = 5; + + message MsgSetBurnsPaused { bool new_value = 1; } + MsgSetBurnsPaused burns_paused = 6; +} +``` +**Steps** + +- Create a `MsgUpdateNamespace` message with `NamespaceDenom`, and the new values for `MintsPaused`, `BurnsPaused` and `SendsPaused`. +- Validate the `MsgUpdateNamespace` object. +- Send the update namespace message. + +## Update Namespace Roles + +Updating namespace roles allows modifying the roles and their permissions within a namespace. +```protobuf +message MsgUpdateNamespaceRoles { + option (cosmos.msg.v1.signer) = "sender"; + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + + string namespace_denom = + 2; // namespace denom to which this updates are applied + + repeated Role role_permissions = + 3; // new role definitions or updated permissions for existing roles + repeated AddressRoles address_roles = + 4; // new addresses to add or new roles for existing addresses to + // overwrite current roles +} +``` +**Steps** + +- Create a `MsgUpdateNamespaceRoles` message with the `NamespaceDenom`, the new `RolePermissions` and `AddressRoles`. +- Validate the `MsgUpdateNamespaceRoles` object. +- Send the update namespace roles message. + +## Revoke Namespace Roles + +Revoking namespace roles removes certain roles from an address within a namespace. +```protobuf +message MsgRevokeNamespaceRoles { + option (cosmos.msg.v1.signer) = "sender"; + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + + string namespace_denom = + 2; // namespace denom to which this updates are applied + repeated AddressRoles address_roles_to_revoke = + 3; // {"address" => array of roles to revoke from this address} +} +``` +**Steps** + +- Create a `MsgRevokeNamespaceRoles` message with the `NamespaceDenom` and `AddressRolesToRevoke`. +- Validate the `MsgRevokeNamespaceRoles` object. +- Send the revoke namespace roles message. + +## Claim Voucher + +```protobuf +message MsgClaimVoucher { + option (amino.name) = "permissions/MsgClaimVoucher"; + option (cosmos.msg.v1.signer) = "sender"; + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + + string denom = 2; +} +``` + +## Update Params + +```protobuf +message MsgUpdateParams { + option (cosmos.msg.v1.signer) = "authority"; + + // authority is the address of the governance account. + string authority = 1 [ (cosmos_proto.scalar) = "cosmos.AddressString" ]; + + // params defines the permissions parameters to update. + // + // NOTE: All parameters must be supplied. + Params params = 2 [ (gogoproto.nullable) = false ]; +} + +message Params { + option (gogoproto.equal) = true; + + uint64 wasm_hook_query_max_gas = 1; +} +``` \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/permissions/README.md b/.gitbook/developers/modules/injective/permissions/README.md new file mode 100644 index 00000000..c92ce1de --- /dev/null +++ b/.gitbook/developers/modules/injective/permissions/README.md @@ -0,0 +1,13 @@ +# `Permissions` + +## Abstract + +Bringing real world permissioned assets (e.g. tokenized treasury yield products) on-chain require certain levels of control over asset actions/properties such as transfers, holders (whitelists), and more. + +The `permissions` module allows managing certain prefixed actions and roles for real world assets and permissioned denoms created within a namespace on the chain-level. It provides a flexible and extensible way to define and enforce permissions and roles and serves as the entry point through which real world assets can be natively issued and managed on Injective. + +## Contents + +1. **[Concepts](./01_concepts.md)** +2. **[State](./02_state.md)** +3. **[State Transitions](./03_state_transitions.md)** diff --git a/.gitbook/developers/modules/injective/tokenfactory/01_concepts.md b/.gitbook/developers/modules/injective/tokenfactory/01_concepts.md new file mode 100644 index 00000000..730c65cb --- /dev/null +++ b/.gitbook/developers/modules/injective/tokenfactory/01_concepts.md @@ -0,0 +1,23 @@ +--- +sidebar_position: 1 +title: Concepts +--- + +# Concepts + +The `tokenfactory` module allows any account to create a new token with +the name `factory/{creator address}/{subdenom}`. Because tokens are +namespaced by creator address, this allows token minting to be +permissionless, due to not needing to resolve name collisions. A single +account can create multiple denoms, by providing a unique subdenom for each +created denom. Once a denom is created, the original creator is given +"admin" privileges over the asset. This allows them to: + +- Mint their denom to any account +- Burn their denom from any account +- Create a transfer of their denom between any two accounts +- Change the admin. In the future, more admin capabilities may be added. Admins + can choose to share admin privileges with other accounts using the authz + module. The `ChangeAdmin` functionality, allows changing the master admin + account, or even setting it to `""`, meaning no account has admin privileges + of the asset. diff --git a/.gitbook/developers/modules/injective/tokenfactory/02_state.md b/.gitbook/developers/modules/injective/tokenfactory/02_state.md new file mode 100644 index 00000000..dfaefb62 --- /dev/null +++ b/.gitbook/developers/modules/injective/tokenfactory/02_state.md @@ -0,0 +1,74 @@ +--- +sidebar_position: 2 +title: State +--- + +# State + +The tokenfactory module keeps state of the following primary objects: + +## Denom Authority Metadata + +- 0x02 + | + denom + | + 0x01 ⇒ `DenomAuthorityMetadata` + +## Denom Creators + +- 0x03 + | + creator + | denom ⇒ denom + + +```protobuf +// DenomAuthorityMetadata specifies metadata for addresses that have specific +// capabilities over a token factory denom. Right now there is only one Admin +// permission, but is planned to be extended to the future. +message DenomAuthorityMetadata { + option (gogoproto.equal) = true; + + // Can be empty for no admin, or a valid injective address + string admin = 1 [ (gogoproto.moretags) = "yaml:\"admin\"" ]; +} +``` + +Genesis state defines the initial state of the module to be used to setup the module. + +```protobuf +// GenesisState defines the tokenfactory module's genesis state. +message GenesisState { + // params defines the parameters of the module. + Params params = 1 [ (gogoproto.nullable) = false ]; + + repeated GenesisDenom factory_denoms = 2 [ + (gogoproto.moretags) = "yaml:\"factory_denoms\"", + (gogoproto.nullable) = false + ]; +} + +// GenesisDenom defines a tokenfactory denom that is defined within genesis +// state. The structure contains DenomAuthorityMetadata which defines the +// denom's admin. +message GenesisDenom { + option (gogoproto.equal) = true; + + string denom = 1 [ (gogoproto.moretags) = "yaml:\"denom\"" ]; + DenomAuthorityMetadata authority_metadata = 2 [ + (gogoproto.moretags) = "yaml:\"authority_metadata\"", + (gogoproto.nullable) = false + ]; +} +``` +## Params + +`Params` is a module-wide configuration that stores system parameters and defines overall functioning of the tokenfactory module. +This module is modifiable by governance using params update proposal natively supported by `gov` module. + +Struct for the `ocr` module params store. +```protobuf +// Params defines the parameters for the tokenfactory module. +message Params { + repeated cosmos.base.v1beta1.Coin denom_creation_fee = 1 [ + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", + (gogoproto.moretags) = "yaml:\"denom_creation_fee\"", + (gogoproto.nullable) = false + ]; +} + +``` diff --git a/.gitbook/developers/modules/injective/tokenfactory/03_messages.md b/.gitbook/developers/modules/injective/tokenfactory/03_messages.md new file mode 100644 index 00000000..9869b19a --- /dev/null +++ b/.gitbook/developers/modules/injective/tokenfactory/03_messages.md @@ -0,0 +1,145 @@ +--- +sidebar_position: 3 +--- + +# Messages + +In this section we describe the processing of the tokenfactory messages and the corresponding updates to the state. + +## Messages + +### CreateDenom + +Creates a denom of `factory/{creator address}/{subdenom}` given the denom creator +address and the subdenom. Subdenoms can contain `[a-zA-Z0-9./]`. + +```go +message MsgCreateDenom { + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + string subdenom = 2 [ (gogoproto.moretags) = "yaml:\"subdenom\"" ]; +} +``` + +**State Modifications:** + +- Fund community pool with the denom creation fee from the creator address, set + in `Params`. +- Set `DenomMetaData` via bank keeper. +- Set `AuthorityMetadata` for the given denom to store the admin for the created + denom `factory/{creator address}/{subdenom}`. Admin is automatically set as the + Msg sender. +- Add denom to the `CreatorPrefixStore`, where a state of denoms created per + creator is kept. + +### Mint + +Minting of a specific denom is only allowed for the current admin. +Note, the current admin is defaulted to the creator of the denom. + +```go +message MsgMint { + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + cosmos.base.v1beta1.Coin amount = 2 [ + (gogoproto.moretags) = "yaml:\"amount\"", + (gogoproto.nullable) = false + ]; +} +``` + +**State Modifications:** + +- Safety check the following + - Check that the denom minting is created via `tokenfactory` module + - Check that the sender of the message is the admin of the denom +- Mint designated amount of tokens for the denom via `bank` module + +### Burn + +Burning of a specific denom is only allowed for the current admin. +Note, the current admin is defaulted to the creator of the denom. + +```go +message MsgBurn { + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + cosmos.base.v1beta1.Coin amount = 2 [ + (gogoproto.moretags) = "yaml:\"amount\"", + (gogoproto.nullable) = false + ]; +} +``` + +**State Modifications:** + +- Safety check the following + - Check that the denom minting is created via `tokenfactory` module + - Check that the sender of the message is the admin of the denom +- Burn designated amount of tokens for the denom via `bank` module + +### ChangeAdmin + +Change the admin of a denom. Note, this is only allowed to be called by the current admin of the denom. + +```go +message MsgChangeAdmin { + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + string denom = 2 [ (gogoproto.moretags) = "yaml:\"denom\"" ]; + string newAdmin = 3 [ (gogoproto.moretags) = "yaml:\"new_admin\"" ]; +} +``` + +### SetDenomMetadata + +Setting of metadata for a specific denom is only allowed for the admin of the denom. +It allows the overwriting of the denom metadata in the bank module. + +```go +message MsgChangeAdmin { + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + cosmos.bank.v1beta1.Metadata metadata = 2 [ (gogoproto.moretags) = "yaml:\"metadata\"", (gogoproto.nullable) = false ]; +} +``` + +**State Modifications:** + +- Check that sender of the message is the admin of denom +- Modify `AuthorityMetadata` state entry to change the admin of the denom + + +## Expectations from the chain + +The chain's bech32 prefix for addresses can be at most 16 characters long. + +This comes from denoms having a 128 byte maximum length, enforced from the SDK, +and us setting longest_subdenom to be 44 bytes. + +A token factory token's denom is: `factory/{creator address}/{subdenom}` + +Splitting up into sub-components, this has: + +- `len(factory) = 7` +- `2 * len("/") = 2` +- `len(longest_subdenom)` +- `len(creator_address) = len(bech32(longest_addr_length, chain_addr_prefix))`. + +Longest addr length at the moment is `32 bytes`. Due to SDK error correction +settings, this means `len(bech32(32, chain_addr_prefix)) = len(chain_addr_prefix) + 1 + 58`. +Adding this all, we have a total length constraint of `128 = 7 + 2 + len(longest_subdenom) + len(longest_chain_addr_prefix) + 1 + 58`. +Therefore `len(longest_subdenom) + len(longest_chain_addr_prefix) = 128 - (7 + 2 + 1 + 58) = 60`. + +The choice between how we standardized the split these 60 bytes between maxes +from longest_subdenom and longest_chain_addr_prefix is somewhat arbitrary. +Considerations going into this: + +- Per [BIP-0173](https://github.com/bitcoin/bips/blob/master/bip-0173.mediawiki#bech32) + the technically longest HRP for a 32 byte address ('data field') is 31 bytes. + (Comes from encode(data) = 59 bytes, and max length = 90 bytes) +- subdenom should be at least 32 bytes so hashes can go into it +- longer subdenoms are very helpful for creating human readable denoms +- chain addresses should prefer being smaller. The longest HRP in cosmos to date is 11 bytes. (`persistence`) + +For explicitness, its currently set to `len(longest_subdenom) = 44` and `len(longest_chain_addr_prefix) = 16`. + +Please note, if the SDK increases the maximum length of a denom from 128 bytes, +these caps should increase. + +So please don't make code rely on these max lengths for parsing. diff --git a/.gitbook/developers/modules/injective/tokenfactory/04_events.md b/.gitbook/developers/modules/injective/tokenfactory/04_events.md new file mode 100644 index 00000000..ac7a3185 --- /dev/null +++ b/.gitbook/developers/modules/injective/tokenfactory/04_events.md @@ -0,0 +1,54 @@ +--- +sidebar_position: 4 +title: Events +--- + +# Events + +The tokenfactory module emits the following events: + +An EventCreateTFDenom is emitted upon MsgCreateDenom execution, which creates a new token factory denom. + +```protobuf +message EventCreateTFDenom { + string account = 1; + string denom = 2; +} +``` + +An EventMintTFDenom is emitted upon MsgMint execution, which mints a new token factory denom for a recipient. + +```protobuf +message EventMintTFDenom { + string recipient_address = 1; + cosmos.base.v1beta1.Coin amount = 2 [(gogoproto.nullable) = false]; +} +``` + +An EventBurnDenom is emitted upon MsgBurn execution, which burns a specified amount for any denom for a user. + +```protobuf +message EventBurnDenom { + string burner_address = 1; + cosmos.base.v1beta1.Coin amount = 2 [(gogoproto.nullable) = false]; +} +``` + +An EventChangeTFAdmin is emitted upon MsgChangeAdmin execution, which changes the admin address for a new token factory denom. + +```protobuf +message EventChangeTFAdmin { + string denom = 1; + string new_admin_address = 2; +} + +``` + +An EventSetTFDenomMetadata is emitted upon MsgSetDenomMetadata execution, which sets the token factory denom metadata for a given token factory denom. + +```protobuf +message EventSetTFDenomMetadata { + string denom = 1; + cosmos.bank.v1beta1.Metadata metadata = 2[(gogoproto.nullable) = false]; +} +``` \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/tokenfactory/05_params.md b/.gitbook/developers/modules/injective/tokenfactory/05_params.md new file mode 100644 index 00000000..a2bd83cd --- /dev/null +++ b/.gitbook/developers/modules/injective/tokenfactory/05_params.md @@ -0,0 +1,19 @@ +--- +sidebar_position: 5 +title: Params +--- + +# Parameters + +The tokenfactory module contains the following parameters: + +```protobuf +// Params defines the parameters for the tokenfactory module. +message Params { + repeated cosmos.base.v1beta1.Coin denom_creation_fee = 1 [ + (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins", + (gogoproto.moretags) = "yaml:\"denom_creation_fee\"", + (gogoproto.nullable) = false + ]; +} +``` diff --git a/.gitbook/developers/modules/injective/tokenfactory/README.md b/.gitbook/developers/modules/injective/tokenfactory/README.md new file mode 100644 index 00000000..d1b0a39b --- /dev/null +++ b/.gitbook/developers/modules/injective/tokenfactory/README.md @@ -0,0 +1,14 @@ +# Tokenfactory + +## Abstract + +The tokenfactory module allows for the permissionless creation of new bank denom tokens. + + +## Contents + +1. **[Concepts](01_concepts.md)** +2. **[State](02_state.md)** +3. **[Messages](03_messages.md)** +4. **[Events](04_events.md)** +5. **[Parameters](05_params.md)** diff --git a/.gitbook/developers/modules/injective/wasmx/01_concepts.md b/.gitbook/developers/modules/injective/wasmx/01_concepts.md new file mode 100644 index 00000000..50da6d18 --- /dev/null +++ b/.gitbook/developers/modules/injective/wasmx/01_concepts.md @@ -0,0 +1,53 @@ +--- +sidebar_position: 1 +title: Concepts +--- + +## Concepts + +### Begin blocker execution + +Smart contracts can only respond to incoming messages and do not have the ability to execute actions on their own schedule. The Wasmx module allows contracts to be registered and called in the begin blockers section of each block. +To be eligible for this, each registered contract must respond to the sudo message called `begin_blocker` which can only be called by the chain itself and not directly by any user or other contract. This ensures that the "begin_blocker" message can be trusted. + +### Registration + +Upon registering a contract, the user must declare a gas price, which is the amount they are willing to pay for contract execution, as well as a gas limit, which is the maximum amount of gas that can be consumed during the execution of the contract. + +Currently, contract registration can only be done through a governance proposal. This proposal, if approved, will add the contract at a specific address to the list of contracts that are run during each "begin blockers" period. + +For security reasons, the proposer must specify a code_id for the contract, which will be verified upon registration and each time the contract is executed. This is to prevent an attacker from registering a benign contract but later upgrading it to a malicious one. The proposer can request to be exempt from this check when registering the contract to avoid delays when a new version of the contract is released, but this may affect the voting results depending on the trustworthiness of the proposer. + +The proposer can also request for the contract to be "pinned," meaning it is loaded and kept in memory, which can greatly improve the performance of the contract. + +### Deregistration + +A contract can be deregistered through a governance proposal, which can be initiated by anyone, including the contract owner if they no longer require the contract or by any other individual if the contract is found to be malicious. + +If contract fails to execute due to insufficient gas it will be automatically deregistered. + +When contract is deregistered, wasmx will call special `deregister{}` callback (if present) as a sudo message in the contract. + +### Deactivation + +A contract can be deactivated automatically if it runs out of gas, or manually by the contract owner. When a contract is deactivated, wasmx will call a special `deactivate{}` callback (if present) as a sudo message in the contract. The contract can be reactivated by the contract owner. + +### Fee Grant + +The Wasmx module allows other addresses (contracts, EOAs) to pay for the Begin blocker execution of other contracts through the [`x/feegrant`](https://docs.cosmos.network/main/modules/feegrant) module. + +When a contract is being registered for the first time, users specify the `FundingMode` which indicates how the contract's execution will be funded. Three modes are supported: + +- `SelfFunded` - contract will pay for its own execution (default) +- `GrantOnly` - contract will execute if its associated allowance covers for it (provided by the `GranterAddress` in the `ContractRegistrationRequest`) +- `Dual` - contract will prioritize spending its allowance's funds. In case the allowance cannot cover for execution, it will use its own funds instead + +Given there are 3 kinds of allowances provided by the `x/feegrant` module (Basic, Periodic and AllowedMsg), the wasmx module supports only Basic and Periodic. Granting an `AllowedMsgAllowance` to a contract is discouraged as any contract attempting to use this kind of allowance will error by default. + +### Pausing, params update + +The owner of a contract has the ability to deactivate or activate the contract at any time without requiring a governance vote. They can also update the parameters for contract execution, such as the gas price or gas limit, at any time. + +### Batch methods + +For convenience, the Wasmx module provides batch versions of some of the previously mentioned proposals, such as batch registration and deregistration, as well as a batch version of the StoreCodeProposal. These batch versions allow multiple proposals to be processed at the same time, rather than individually. diff --git a/.gitbook/developers/modules/injective/wasmx/02_data.md b/.gitbook/developers/modules/injective/wasmx/02_data.md new file mode 100644 index 00000000..822bb8fb --- /dev/null +++ b/.gitbook/developers/modules/injective/wasmx/02_data.md @@ -0,0 +1,38 @@ +--- +sidebar_position: 2 +title: Data +--- + +## Data + +### RegisteredContract + +Data stored about each contract + +```go +type RegisteredContract struct { + // limit of gas per BB execution + GasLimit uint64 json:"gas_limit,omitempty" + // gas price that contract is willing to pay for execution in BeginBlocker + GasPrice uint64 json:"gas_price,omitempty" + // is contract currently active + IsExecutable bool json:"is_executable,omitempty" + // code_id that is allowed to be executed (to prevent malicious updates) - if nil/0 any code_id can be executed + CodeId uint64 json:"code_id,omitempty"ł + // optional - admin addr that is allowed to update contract data + AdminAddress string json:"admin_address,omitempty" + // address of an account providing grant for execution + GranterAddress string + // enum indicating how contract's execution is funded + FundMode FundingMode +} + +type FundingMode int32 + +const ( + FundingMode_Unspecified FundingMode = 0 + FundingMode_SelfFunded FundingMode = 1 + FundingMode_GrantOnly FundingMode = 2 + FundingMode_Dual FundingMode = 3 +) +``` \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/wasmx/03_proposals.md b/.gitbook/developers/modules/injective/wasmx/03_proposals.md new file mode 100644 index 00000000..c815ddd5 --- /dev/null +++ b/.gitbook/developers/modules/injective/wasmx/03_proposals.md @@ -0,0 +1,130 @@ +--- +sidebar_position: 3 +title: Governance Proposals +--- + +## Governance Proposals + +### ContractRegistrationRequest + +`ContractRegistrationRequest` is a base message for registering new contracts (shouldn't be used directly but as a part of proposal) + +```go +type ContractRegistrationRequest struct { + ContractAddress string + GasLimit uint64 + GasPrice uint64 + PinContract bool + AllowUpdating bool + CodeId uint64 + ContractAdmin string + GranterAddress string + FundMode FundingMode +} +``` + +**Fields description** + +- `ContractAddress` - unique Identifier for contract instance to be registered. +- `GasLimit` - Maximum gas to be used for the smart contract execution. +- `GasPrice` - Gas price to be used for the smart contract execution. +- `PinContract` - should contract be pinned. +- `AllowUpdating`- defines wether contract owner can migrate it without need to register again (if false only current code_id will be allowed to be executed) +- `CodeId` - code_id of the contract being registered - will be verified on execution to allow last minute change (after votes were cast) +- `AdminAddress` - optional address of admin account (that will be allowed to pause or update contract params) +- `GranterAddress` - address of an account which granted funds for execution. Must be set if `FundMode` is other than `SelfFunded` (see below for an explanation) + +`FundingMode` indicates how the contract will fund its own execution. + +```go +enum FundingMode { + Unspecified = 0; + SelfFunded = 1; + GrantOnly = 2; + Dual = 3; +} +``` + +- `SelfFunded` - contract will use its own funds to execute. +- `GrantOnly` - contract wil only use funds provided by the grant. +- `Dual` - contract will first deplete grant's funds before using its own. + +### ContractRegistrationRequestProposal + +`ContractRegistrationRequestProposal` defines an SDK message to register a single contract in wasmx contract registry. + +```go +type ContractRegistrationRequestProposal struct { + Title string + Description string + ContractRegistrationRequest ContractRegistrationRequest +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `ContractRegistrationRequest` contains contract registration request (as described above) + + + + +### BatchContractRegistrationRequestProposal + +`BatchContractRegistrationRequestProposal` defines an SDK message to register a batch of contracts in wasmx contract registry. + +```go +type BatchContractRegistrationRequestProposal struct { + Title string + Description string + ContractRegistrationRequests []ContractRegistrationRequest +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `ContractRegistrationRequests` contains a list of contracts registration requests (as described above) + + +### BatchStoreCodeProposal + +`BatchStoreCodeProposal` defines an SDK message to store a batch of contracts in wasm. + +```go +type BatchStoreCodeProposal struct { + Title string + Description string + Proposals []types.StoreCodeProposal +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `Proposals` contains a list of store code proposals (as defined by Cosmos wasm module) + + +### BatchContractDeregistrationProposal + +`BatchContractDeregistrationProposal` defines an SDK message to deregister a batch of contracts in wasm. + +```go +type BatchContractDeregistrationProposal struct { + Title string + Description string + Contracts []string +} +``` + +**Fields description** + +- `Title` describes the title of the proposal. +- `Description` describes the description of the proposal. +- `Contracts` contains a list of addresses of contracts to be deregistered + + + diff --git a/.gitbook/developers/modules/injective/wasmx/04_messages.md b/.gitbook/developers/modules/injective/wasmx/04_messages.md new file mode 100644 index 00000000..a1b1699c --- /dev/null +++ b/.gitbook/developers/modules/injective/wasmx/04_messages.md @@ -0,0 +1,90 @@ +--- +sidebar_position: 4 +title: Messages +--- + +## Messages + +### MsgUpdateContract + +Updates registered contract execution params (gas price, limit). Can also define a new admin account. +Can be called only by admin (if defined) or contract itself. + +```go + +type MsgUpdateContract struct { + Sender string `json:"sender,omitempty"` + // Unique Identifier for contract instance to be registered. + ContractAddress string `json:"contract_address,omitempty"` + // Maximum gas to be used for the smart contract execution. + GasLimit uint64 `json:"gas_limit,omitempty"` + // gas price to be used for the smart contract execution. + GasPrice uint64 `json:"gas_price,omitempty"` + // optional - admin account that will be allowed to perform any changes + AdminAddress string `json:"admin_address,omitempty"` +} +``` + +### MsgDeactivateContract + +Deactivates a registered contract (it will no longer be executed in begin blocker) + +```go + +type MsgDeactivateContract struct { + Sender string `json:"sender,omitempty"` + // Unique Identifier for contract instance to be activated. + ContractAddress string `json:"contract_address,omitempty"` +} +``` + +### MsgActivateContract + +Reactivates a registered contract (it will be executed in begin blocker from now on again) + +```go + +type MsgActivateContract struct { + Sender string `json:"sender,omitempty"` + // Unique Identifier for contract instance to be activated. + ContractAddress string `json:"contract_address,omitempty"` +} +``` + +### MsgExecuteContract + +Invokes a function defined within the smart contract. Function and parameters are encoded in `ExecuteMsg`, which is a JSON message encoded in Base64. + +```go +type MsgExecuteContract struct { + Sender sdk.AccAddress `json:"sender" yaml:"sender"` + Contract sdk.AccAddress `json:"contract" yaml:"contract"` + ExecuteMsg core.Base64Bytes `json:"execute_msg" yaml:"execute_msg"` + Coins sdk.Coins `json:"coins" yaml:"coins"` +} +``` + +### MsgMigrateContract + +Can be issued by the owner of a migratable smart contract to reset its code ID to another one. `MigrateMsg` is a JSON message encoded in Base64. + +```go +type MsgMigrateContract struct { + Owner sdk.AccAddress `json:"owner" yaml:"owner"` + Contract sdk.AccAddress `json:"contract" yaml:"contract"` + NewCodeID uint64 `json:"new_code_id" yaml:"new_code_id"` + MigrateMsg core.Base64Bytes `json:"migrate_msg" yaml:"migrate_msg"` +} +``` + +### MsgUpdateContractOwner + +Can be issued by the smart contract's owner to transfer ownership. + +```go +type MsgUpdateContractOwner struct { + Owner sdk.AccAddress `json:"owner" yaml:"owner"` + NewOwner sdk.AccAddress `json:"new_owner" yaml:"new_owner"` + Contract sdk.AccAddress `json:"contract" yaml:"contract"` +} +``` \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/wasmx/05_params.md b/.gitbook/developers/modules/injective/wasmx/05_params.md new file mode 100644 index 00000000..2663c1f3 --- /dev/null +++ b/.gitbook/developers/modules/injective/wasmx/05_params.md @@ -0,0 +1,21 @@ +--- +sidebar_position: 5 +title: Params +--- + +## Params + +The subspace for the wasmx module is `wasmx`. + +```go +type Params struct { + // Set the status to active to indicate that contracts can be executed in begin blocker. + IsExecutionEnabled bool ` json:"is_execution_enabled,omitempty"` + // Maximum aggregate total gas to be used for the contract executions in the BeginBlocker. + MaxBeginBlockTotalGas uint64 `json:"max_begin_block_total_gas,omitempty"` + // the maximum gas limit each individual contract can consume in the BeginBlocker. + MaxContractGasLimit uint64 `json:"max_contract_gas_limit,omitempty"` + // min_gas_price defines the minimum gas price the contracts must pay to be executed in the BeginBlocker. + MinGasPrice uint64 `json:"min_gas_price,omitempty"` +} +``` \ No newline at end of file diff --git a/.gitbook/developers/modules/injective/wasmx/README.md b/.gitbook/developers/modules/injective/wasmx/README.md new file mode 100644 index 00000000..71cdd4f7 --- /dev/null +++ b/.gitbook/developers/modules/injective/wasmx/README.md @@ -0,0 +1,17 @@ +# `Wasmx` + +## Abstract + +The `wasmx` module handles integration of [CosmWasm](https://cosmwasm.com) smart contracts with Injective Chain. +Its main function is to provide a method for contracts to be executed in the begin blocker section of each block. +A contract may be automatically deactivated if it runs out of gas but can be reactivated by the contract owner. + +It also includes helper methods for managing contracts, such as a batch code storage proposal. These functions allow for seamless integration of CosmWasm contracts with the Injective Chain and provide useful tools for managing and maintaining those contracts. + +## Contents + +1. **[Concepts](./01_concepts.md)** +2. **[Data](./02_data.md)** +3. **[State](./03_proposals.md)** +4. **[Messages](./04_messages.md)** +5. **[Params](./05_params.md)** diff --git a/.gitignore b/.gitignore index 5e06e6fe..f928452b 100644 --- a/.gitignore +++ b/.gitignore @@ -10,6 +10,7 @@ .cache-loader # Misc +.env .DS_Store .env.local .env.development.local