foundation

package
v0.45.4 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jul 5, 2023 License: Apache-2.0 Imports: 35 Imported by: 0

README

x/foundation

Abstract

This module provides the functionalities related to the foundation. The foundation can turn off these functionalities irreversibly, through the corresponding proposal. Therefore, the users can ensure that no one can bring back these foundation-specific functionalities.

Contents

Concepts

Authority

x/foundation's authority is a module account associated with the foundation and a decision policy. It is an "administrator" which has the ability to add, remove and update members in the foundation. x/foundation has several messages which cannot be triggered but by the authority. It includes membership management messages, and other messages which controls the assets of the foundation.

Note: The authority is a module account, which means no one has the private key of the authority. Hence, foundation members MUST propose, vote and execute the corresponding proposal.

Decision Policy

A decision policy is 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 the members are allowed to execute a proposal.

The current foundation 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:

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/x/foundation/foundation.go#L90-L103 +++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/x/foundation/foundation.go#L90-L103

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.

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 a foundation where the membership can be updated, as the percentage threshold stays the same, and doesn't depend on how the number of members get updated.

Outsourcing decision policy

A outsourcing decision policy is a policy set after x/foundation decides to outsource its proposal relevant features to other modules (e.g. x/group). It means one can expect that any states relevant to the feature must be removed in the update to this policy.

Proposal

Any foundation member(s) can submit a proposal for the foundation 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 decision policy.

Withdrawing Proposals

Proposals can be withdrawn any time before the voting period end, either by the module's authority 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 decision 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 decision 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 can be triggered by the following two factors:

  • 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 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 member must submit a Msg/Exec transaction to attempt to execute the proposal based on the current votes and decision policy. Any member 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.
  • or after updating the membership or decision policy.

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.

Censorship

The foundation module defines interfaces of authorizations on messages to enforce censorship on its execution. The other modules may deny the execution of the message based on the information in the foundation.

A censorship has its target message type URL and authority which can trigger the messages which manipulate the relevant censorship information:

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.

Note: The foundation module's Authorization is different from that of x/authz, while the latter allows an account to perform actions on behalf of another account.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/x/foundation/authz.go#L10-L27

Built-in Authorizations

ReceiveFromTreasuryAuthorization

ReceiveFromTreasuryAuthorization implements the Authorization interface for the Msg/WithdrawFromTreasury.

Note: The subject which executes lbm.foundation.v1.MsgWithdrawFromTreasury is the foundation.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/foundation/v1/authz.proto#L9-L13

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/x/foundation/authz.pb.go#L27-L30

CreateValidatorAuthorization

CreateValidatorAuthorization implements the Authorization interface for the Msg/CreateValidator. An account must have this authorization prior to sending the message.

Note: You MUST provide the CreateValidatorAuthorizations into the genesis if Msg/CreateValidator is being censored (CensoredMsgTypeUrls contains the url of Msg/CreateValidator), or the chain cannot be started.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/stakingplus/v1/authz.proto#L9-L15

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/x/stakingplus/authz.pb.go#L27-L31

Foundation Treasury

x/foundation intercepts the rewards prior to its distribution (by x/distribution). The rate would be FoundationTax.

The foundation can withdraw coins from the treasury. The recipient must have the corresponding authorization (ReceiveFromTreasuryAuthorization) prior to sending the message Msg/WithdrawFromTreasury.

Note: After setting the tax rate to zero, you cannot set it to a non-zero value again (irreversible), which means you must set it to a non-zero value in the genesis to make it work.

State

Params

  • Params: 0x00 -> PropocolBuffer(Params).
FoundationTax

The value of FoundationTax is the foundation tax rate.

FoundationInfo

FoundationInfo contains the information relevant to the foundation.

  • FoundationInfo: 0x01 -> ProtocolBuffer(FoundationInfo).
Version

The Version is used to track changes to the foundation membership. Whenever the membership is changed, this value is incremented, which will cause proposals based on older versions to fail.

TotalWeight

The TotalWeight is the number of the foundation members.

DecisionPolicy

The DecisionPolicy is the decision policy of the foundation.

Member

The Member is the foundation member.

  • Member: 0x10 | []byte(member.Address) -> ProtocolBuffer(Member).

PreviousProposalID

The value of the PreviousProposalID is the last used proposal ID. The chain uses this value to issue the ID of the next new proposal.

  • PreviousProposalID: 0x11 -> BigEndian(ProposalId).

Proposal

  • Proposal: 0x12 | BigEndian(ProposalId) -> ProtocolBuffer(Proposal).

ProposalByVotingPeriodEnd

ProposalByVotingPeriodEnd allows to retrieve proposals sorted by chronological voting_period_end. This index is used when tallying the proposal votes at the end of the voting period, and for pruning proposals at VotingPeriodEnd + MaxExecutionPeriod.

  • ProposalByVotingPeriodEnd: 0x13 | sdk.FormatTimeBytes(proposal.VotingPeriodEnd) | BigEndian(ProposalId) -> []byte().

Vote

  • Vote: 0x40 | BigEndian(ProposalId) | []byte(voter.Address) -> ProtocolBuffer(Vote).

Censorship

Censorships are identified by its target message type URL.

  • Censorship: 0x20 | []byte(censorship.MsgTypeURL) -> ProtocolBuffer(Censorship)

Grant

Grants are identified by combining grantee address and Authorization type (its target message type URL). Hence we only allow one grant for the (grantee, Authorization) tuple.

  • Grant: 0x21 | len(grant.Grantee) (1 byte) | []byte(grant.Grantee) | []byte(grant.Authorization.MsgTypeURL()) -> ProtocolBuffer(Authorization)

Msg Service

Msg/UpdateParams

The MsgUpdateParams can be used to update the parameters of foundation.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/f682f758268c19dd93958abbbaf697f51e6991b3/proto/lbm/foundation/v1/tx.proto#L62-L71

It's expected to fail if:

  • the authority is not the module's authority.
  • the parameters introduces any new foundation-specific features.

Msg/UpdateDecisionPolicy

The MsgUpdateDecisionPolicy can be used to update the decision policy.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/f682f758268c19dd93958abbbaf697f51e6991b3/proto/lbm/foundation/v1/tx.proto#L111-L118

It's expected to fail if:

  • the authority is not the module's authority.
  • the new decision policy's Validate() method doesn't pass.

Msg/UpdateMembers

Foundation members can be updated with the MsgUpdateMembers.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/f682f758268c19dd93958abbbaf697f51e6991b3/proto/lbm/foundation/v1/tx.proto#L98-L106

In the list of MemberUpdates, an existing member can be removed by setting its remove flag to true.

It's expected to fail if:

  • the authority is not the module's authority.
  • if the decision policy's Validate() method fails against the updated membership.

Msg/LeaveFoundation

The MsgLeaveFoundation allows a foundation member to leave the foundation.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/foundation/v1/tx.proto#L205-L209

It's expected to fail if:

  • the address is not of a foundation member.
  • if the decision policy's Validate() method fails against the updated membership.

Msg/SubmitProposal

A new proposal can be created with the MsgSubmitProposal, which has 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.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/foundation/v1/tx.proto#L135-L151

It's expected to fail if:

  • metadata length is greater than MaxMetadataLen config.
  • if any of the proposers is not a foundation member.

Msg/WithdrawProposal

A proposal can be withdrawn using MsgWithdrawProposal which has an address (can be either a proposer or the module's authority) and a proposal_id (which has to be withdrawn).

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/foundation/v1/tx.proto#L159-L166

It's expected to fail if:

  • the address is neither the module's authority nor a 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.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/foundation/v1/tx.proto#L171-L188

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.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/foundation/v1/tx.proto#L193-L200

The messages that are part of this proposal won't be executed if:

  • the proposal has not been accepted by the decision policy.
  • the proposal has already been successfully executed.

Msg/UpdateCensorship

A censorship information is updated by using the MsgUpdateCensorship message. One cannot introduce a censorship over a new message type URL by this message.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/d9428ec5d825dfd9964f510e32bd03a01adade8c/proto/lbm/foundation/v1/tx.proto#L215-L222

The authority of the following modules are candidates of censorship authority:

  • CENSORSHIP_AUTHORITY_GOVERNANCE: x/gov
  • CENSORSHIP_AUTHORITY_FOUNDATION: x/foundation

One may specify CENSORSHIP_AUTHORITY_UNSPECIFIED to remove the censorship.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/d9428ec5d825dfd9964f510e32bd03a01adade8c/proto/lbm/foundation/v1/tx.proto#L25-L34

The message handling should fail if:

  • the authority is not the current censorship's authority.
  • corresponding enum value of the current censorship's authority is lesser than that of the provided censorship's authority.

Note: Do NOT confuse with that of x/authz.

Msg/Grant

An authorization grant is created by using the MsgGrant message. If there is already a grant for the (grantee, Authorization) tuple, then the new grant overwrites the previous one. To update or extend an existing grant, a new grant with the same (grantee, Authorization) tuple should be created.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/f682f758268c19dd93958abbbaf697f51e6991b3/proto/lbm/foundation/v1/tx.proto#L215-L224

The message handling should fail if:

  • the authority is not the current censorship's authority.
  • provided 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).

Note: Do NOT confuse with that of x/authz.

Msg/Revoke

A grant can be removed with the MsgRevoke message.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/f682f758268c19dd93958abbbaf697f51e6991b3/proto/lbm/foundation/v1/tx.proto#L229-L235

The message handling should fail if:

  • the authority is not the current censorship's authority.
  • provided MsgTypeUrl is empty.

Msg/FundTreasury

Anyone can fund treasury with MsgFundTreasury.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/foundation/v1/tx.proto#L76-L81

Msg/WithdrawFromTreasury

The foundation can withdraw coins from the treasury with MsgWithdrawFromTreasury.

+++ https://github.com/PikeEcosystem/cosmos-sdk/blob/f682f758268c19dd93958abbbaf697f51e6991b3/proto/lbm/foundation/v1/tx.proto#L86-L93

The message handling should fail if:

  • the authority is not the module's authority.
  • the address which receives the coins has no authorization of ReceiveFromTreasuryAuthorization.

Events

EventUpdateFoundationParams

EventUpdateFoundationParams is an event emitted when the foundation parameters have been updated.

Attribute Key Attribute Value
params {params}

EventUpdateDecisionPolicy

EventUpdateDecisionPolicy is an event emitted when the decision policy have been updated.

Attribute Key Attribute Value
decision_policy {decisionPolicy}

EventUpdateMembers

EventUpdateMembers is an event emitted when the foundation members have been updated.

Attribute Key Attribute Value
member_updates {members}

EventLeaveFoundation

EventLeaveFoundation is an event emitted when a foundation member leaves the foundation.

Attribute Key Attribute Value
address {memberAddress}

EventSubmitProposal

EventSubmitProposal is an event emitted when a proposal is submitted.

Attribute Key Attribute Value
proposal {proposal}

EventWithdrawProposal

EventWithdrawProposal is an event emitted when a proposal is withdrawn.

Attribute Key Attribute Value
proposal_id {proposalId}

EventVote

EventVote is an event emitted when a voter votes on a proposal.

Attribute Key Attribute Value
vote {vote}

EventExec

EventExec is an event emitted when a proposal is executed.

Attribute Key Attribute Value
proposal_id {proposalId}
result {result}

EventUpdateCensorship

EventCensorship is an event emitted when a censorship is updated.

Attribute Key Attribute Value
censorship {censorship}

EventGrant

EventGrant is an event emitted when an authorization is granted to a grantee.

Attribute Key Attribute Value
grantee {granteeAddress}
authorization {authorization}

EventRevoke

EventRevoke is an event emitted when an authorization is revoked from a grantee.

Attribute Key Attribute Value
grantee {granteeAddress}
msg_type_url {msgTypeURL}

EventFundTreasury

EventFundTreasury is an event emitted when one funds the treasury.

Attribute Key Attribute Value
from {fromAddress}
amount {amount}

EventWithdrawFromTreasury

EventWithdrawFromTreasury is an event emitted when coins are withdrawn from the treasury.

Attribute Key Attribute Value
to {toAddress}
amount {amount}

Client

CLI

A user can query and interact with the foundation module using the CLI.

Query

The query commands allow users to query foundation state.

simd query foundation --help
params

The params command allows users to query for the parameters of foundation.

simd query foundation params [flags]

Example:

simd query foundation params

Example Output:

params:
  foundation_tax: "0.200000000000000000"
foundation-info

The foundation-info command allows users to query for the foundation info.

simd query foundation foundation-info [flags]

Example:

simd query foundation foundation-info

Example Output:

info:
  decision_policy:
    '@type': /lbm.foundation.v1.ThresholdDecisionPolicy
    threshold: "3.000000000000000000"
    windows:
      min_execution_period: 0s
      voting_period: 86400s
  total_weight: "3.000000000000000000"
  version: "1"
member

The member command allows users to query for a foundation member by address.

simd query foundation member [address] [flags]

Example:

simd query foundation member link1...

Example Output:

member:
  added_at: "0001-01-01T00:00:00Z"
  address: link1...
  metadata: genesis member
members

The members command allows users to query for the foundation members with pagination flags.

simd query foundation members [flags]

Example:

simd query foundation members

Example Output:

members:
- added_at: "0001-01-01T00:00:00Z"
  address: link1...
  metadata: genesis member
- added_at: "0001-01-01T00:00:00Z"
  address: link1...
  metadata: genesis member
- added_at: "0001-01-01T00:00:00Z"
  address: link1...
  metadata: genesis member
pagination:
  next_key: null
  total: "3"
proposal

The proposal command allows users to query for proposal by id.

simd query foundation proposal [id] [flags]

Example:

simd query foundation proposal 1

Example Output:

proposal:
  executor_result: PROPOSAL_EXECUTOR_RESULT_NOT_RUN
  final_tally_result:
    abstain_count: "0.000000000000000000"
    no_count: "0.000000000000000000"
    no_with_veto_count: "0.000000000000000000"
    yes_count: "0.000000000000000000"
  foundation_version: "1"
  id: "1"
  messages:
  - '@type': /lbm.foundation.v1.MsgWithdrawFromTreasury
    authority: link1...
    amount:
    - amount: "1000000000"
      denom: stake
    to: link1...
  metadata: show-me-the-money
  proposers:
  - link1...
  status: PROPOSAL_STATUS_SUBMITTED
  submit_time: "2022-09-19T01:26:38.544943184Z"
  voting_period_end: "2022-09-20T01:26:38.544943184Z"
proposals

The proposals command allows users to query for proposals with pagination flags.

simd query foundation proposals [flags]

Example:

simd query foundation proposals

Example Output:

pagination:
  next_key: null
  total: "1"
proposals:
- executor_result: PROPOSAL_EXECUTOR_RESULT_NOT_RUN
  final_tally_result:
    abstain_count: "0.000000000000000000"
    no_count: "0.000000000000000000"
    no_with_veto_count: "0.000000000000000000"
    yes_count: "0.000000000000000000"
  foundation_version: "1"
  id: "1"
  messages:
  - '@type': /lbm.foundation.v1.MsgWithdrawFromTreasury
    authority: link1...
    amount:
    - amount: "1000000000"
      denom: stake
    to: link1...
  metadata: show-me-the-money
  proposers:
  - link1...
  status: PROPOSAL_STATUS_SUBMITTED
  submit_time: "2022-09-19T01:26:38.544943184Z"
  voting_period_end: "2022-09-20T01:26:38.544943184Z"
vote

The vote command allows users to query for vote by proposal id and voter account address.

simd query foundation vote [proposal-id] [voter] [flags]

Example:

simd query foundation vote 1 link1...

Example Output:

vote:
  metadata: nope
  option: VOTE_OPTION_NO
  proposal_id: "1"
  submit_time: "2022-09-19T01:35:30.920689570Z"
  voter: link1...
votes

The votes command allows users to query for votes by proposal id with pagination flags.

simd query foundation votes [proposal-id] [flags]

Example:

simd query foundation votes 1

Example Output:

pagination:
  next_key: null
  total: "1"
votes:
- metadata: nope
  option: VOTE_OPTION_NO
  proposal_id: "1"
  submit_time: "2022-09-19T01:35:30.920689570Z"
  voter: link1...
tally

The tally command allows users to query for the tally in progress by its proposal id.

simd query foundation tally [proposal-id] [flags]

Example:

simd query foundation tally 1

Example Output:

tally:
  abstain_count: "0.000000000000000000"
  no_count: "1.000000000000000000"
  no_with_veto_count: "0.000000000000000000"
  yes_count: "0.000000000000000000"
censorships

The censorships command allows users to query for all the censorships.

simd query foundation censorships [flags]

Example:

simd query foundation censorships

Example Output:

censorships:
- authority: CENSORSHIP_AUTHORITY_GOVERNANCE
  msg_type_url: /cosmos.staking.v1beta1.MsgCreateValidator
- authority: CENSORSHIP_AUTHORITY_FOUNDATION
  msg_type_url: /lbm.foundation.v1.MsgWithdrawFromTreasury
pagination:
  next_key: null
  total: "2"
grants

The grants command allows users to query grants for a grantee. If the message type URL is set, it selects grants only for that message type.

simd query foundation grants [grantee] [msg-type-url]? [flags]

Example:

simd query foundation grants link1... /lbm.foundation.v1.MsgWithdrawFromTreasury

Example Output:

authorizations:
- '@type': /lbm.foundation.v1.ReceiveFromTreasuryAuthorization
pagination: null
treasury

The treasury command allows users to query for the foundation treasury.

simd query foundation treasury [flags]

Example:

simd query foundation treasury

Example Output:

amount:
- amount: "1000000000000.000000000000000000"
  denom: stake
Transactions

The tx commands allow users to interact with the foundation module.

simd tx foundation --help

Note: Some commands must be signed by the module's authority, which means you cannot broadcast the message directly. The use of those commands is to make it easier to generate the messages by end users.

update-params

The update-params command allows users to update the foundation's parameters.

simd tx foundation update-params [authority] [params-json] [flags]

Example:

simd tx foundation update-params link1... \
    '{
       "foundation_tax": "0.1"
     }'

Note: The signer MUST be the module's authority.

update-members

The update-members command allows users to update the foundation's members.

simd tx foundation update-members [authority] [members-json] [flags]

Example:

simd tx foundation update-members link1... \
    '[
       {
         "address": "link1...",
         "metadata": "some new metadata"
       },
       {
         "address": "link1...",
         "remove": true,
       }
     ]'

Note: The signer MUST be the module's authority.

update-decision-policy

The update-decision-policy command allows users to update the foundation's decision policy.

simd tx foundation update-decision-policy [authority] [decision-policy-json] [flags]

Example:

simd tx foundation update-decision-policy link1... \
    '{
       "@type": "/lbm.foundation.v1.ThresholdDecisionPolicy",
       "threshold": "4",
       "windows": {
         "voting_period": "1h",
         "min_execution_period": "0s"
       }
     }'

Note: The signer MUST be the module's authority.

submit-proposal

The submit-proposal command allows users to submit a new proposal.

simd tx foundation submit-proposal [metadata] [proposers-json] [messages-json] [flags]

Example:

simd tx foundation submit-proposal show-me-the-money \
    '[
       "link1...",
       "link1..."
     ]' \
    '[
       {
         "@type": "/lbm.foundation.v1.MsgWithdrawFromTreasury",
         "authority": "link1...",
         "to": "link1...",
         "amount": [
           {
             "denom": "stake",
             "amount": "10000000000"
           }
         ]
       }
     ]'
withdraw-proposal

The withdraw-proposal command allows users to withdraw a proposal.

simd tx foundation withdraw-proposal [proposal-id] [authority-or-proposer] [flags]

Example:

simd tx foundation withdraw-proposal 1 link1...
vote

The vote command allows users to vote on a proposal.

simd tx foundation vote [proposal-id] [voter] [option] [metadata] [flags]

Example:

simd tx foundation vote 1 link1... VOTE_OPTION_NO nope
exec

The exec command allows users to execute a proposal.

simd tx foundation exec [proposal-id] [flags]

Example:

simd tx foundation exec 1
leave-foundation

The leave-foundation command allows foundation member to leave the foundation.

simd tx foundation leave-foundation [address] [flags]

Example:

simd tx foundation leave-foundation link1...
update-censorship

The update-censorship command allows users to update a censorship information.

simd tx foundation update-censorship [authority] [msg-type-url] [new-authority] [flags]

Example:

simd tx foundation update-censorship link1.. /lbm.foundation.v1.MsgWithdrawFromTreasury CENSORSHIP_AUTHORITY_UNSPECIFIED

Note: The signer MUST be the current authority of the censorship.

grant

The grant command allows users to grant an authorization to a grantee.

simd tx foundation grant [authority] [grantee] [authorization-json] [flags]

Example:

simd tx foundation grant link1.. link1... \
    '{
       "@type": "/lbm.foundation.v1.ReceiveFromTreasuryAuthorization",
     }'

Note: The signer MUST be the authority of the censorship.

revoke

The revoke command allows users to revoke an authorization from a grantee.

simd tx foundation revoke [authority] [grantee] [msg-type-url] [flags]

Example:

simd tx foundation revoke link1.. link1... /lbm.foundation.v1.MsgWithdrawFromTreasury

Note: The signer MUST be the authority of the censorship.

fund-treasury

The fund-treasury command allows users to fund the foundation treasury.

simd tx foundation fund-treasury [from] [amount] [flags]

Example:

simd tx foundation fund-treasury link1.. 1000stake
withdraw-from-treasury

The withdraw-from-treasury command allows users to withdraw coins from the foundation treasury.

simd tx foundation withdraw-from-treasury [authority] [to] [amount] [flags]

Example:

simd tx foundation withdraw-from-treasury link1.. link1... 1000stake

Note: The signer MUST be the module's authority.

gRPC

A user can query the foundation module using gRPC endpoints.

grpcurl -plaintext \
    localhost:9090 list lbm.foundation.v1.Query
Params

The Params endpoint allows users to query for the parameters of foundation.

lbm.foundation.v1.Query/Params

Example:

grpcurl -plaintext \
    localhost:9090 lbm.foundation.v1.Query/Params

Example Output:

{
  "params": {
    "foundationTax": "200000000000000000"
  }
}
FoundationInfo

The FoundationInfo endpoint allows users to query for the foundation info.

lbm.foundation.v1.Query/FoundationInfo

Example:

grpcurl -plaintext \
    localhost:9090 lbm.foundation.v1.Query/FoundationInfo

Example Output:

{
  "info": {
    "version": "1",
    "totalWeight": "3000000000000000000",
    "decisionPolicy": {"@type":"/lbm.foundation.v1.ThresholdDecisionPolicy","threshold":"3000000000000000000","windows":{"votingPeriod":"86400s","minExecutionPeriod":"0s"}}
  }
}
Member

The Member endpoint allows users to query for a foundation member by address.

lbm.foundation.v1.Query/Member

Example:

grpcurl -plaintext \
    -d '{"address": "link1..."}'
    localhost:9090 lbm.foundation.v1.Query/Member

Example Output:

{
  "member": {
    "address": "link1...",
    "metadata": "genesis member",
    "addedAt": "0001-01-01T00:00:00Z"
  }
}
Members

The Members endpoint allows users to query for the foundation members with pagination flags.

lbm.foundation.v1.Query/Members

Example:

grpcurl -plaintext \
    localhost:9090 lbm.foundation.v1.Query/Members

Example Output:

{
  "members": [
    {
      "address": "link1...",
      "metadata": "genesis member",
      "addedAt": "0001-01-01T00:00:00Z"
    },
    {
      "address": "link1...",
      "metadata": "genesis member",
      "addedAt": "0001-01-01T00:00:00Z"
    },
    {
      "address": "link1...",
      "metadata": "genesis member",
      "addedAt": "0001-01-01T00:00:00Z"
    }
  ],
  "pagination": {
    "total": "3"
  }
}
Proposal

The Proposal endpoint allows users to query for proposal by id.

lbm.foundation.v1.Query/Proposal

Example:

grpcurl -plaintext \
    -d '{"proposal_id": "1"}' \
    localhost:9090 lbm.foundation.v1.Query/Proposal

Example Output:

{
  "proposal": {
    "id": "1",
    "metadata": "show-me-the-money",
    "proposers": [
      "link1..."
    ],
    "submitTime": "2022-09-19T01:26:38.544943184Z",
    "foundationVersion": "1",
    "status": "PROPOSAL_STATUS_SUBMITTED",
    "finalTallyResult": {
      "yesCount": "0",
      "abstainCount": "0",
      "noCount": "0",
      "noWithVetoCount": "0"
    },
    "votingPeriodEnd": "2022-09-20T01:26:38.544943184Z",
    "executorResult": "PROPOSAL_EXECUTOR_RESULT_NOT_RUN",
    "messages": [
      {"@type":"/lbm.foundation.v1.MsgWithdrawFromTreasury","authority":"link1...","amount":[{"denom":"stake","amount":"1000000000"}],"to":"link1..."}
    ]
  }
}
Proposals

The Proposals endpoint allows users to query for proposals with pagination flags.

lbm.foundation.v1.Query/Proposals

Example:

grpcurl -plaintext \
    localhost:9090 lbm.foundation.v1.Query/Proposals

Example Output:

{
  "proposals": [
    {
      "id": "1",
      "metadata": "show-me-the-money",
      "proposers": [
        "link1..."
      ],
      "submitTime": "2022-09-19T01:26:38.544943184Z",
      "foundationVersion": "1",
      "status": "PROPOSAL_STATUS_SUBMITTED",
      "finalTallyResult": {
        "yesCount": "0",
        "abstainCount": "0",
        "noCount": "0",
        "noWithVetoCount": "0"
      },
      "votingPeriodEnd": "2022-09-20T01:26:38.544943184Z",
      "executorResult": "PROPOSAL_EXECUTOR_RESULT_NOT_RUN",
      "messages": [
        {"@type":"/lbm.foundation.v1.MsgWithdrawFromTreasury","authority":"link1...","amount":[{"denom":"stake","amount":"1000000000"}],"to":"link1..."}
      ]
    }
  ],
  "pagination": {
    "total": "1"
  }
}
Vote

The Vote endpoint allows users to query for vote by proposal id and voter account address.

lbm.foundation.v1.Query/Vote

Example:

grpcurl -plaintext \
    -d '{"proposal_id": "1", "voter": "link1..."}' \
    localhost:9090 lbm.foundation.v1.Query/Vote

Example Output:

{
  "vote": {
    "proposalId": "1",
    "voter": "link1...",
    "option": "VOTE_OPTION_NO",
    "metadata": "nope",
    "submitTime": "2022-09-19T01:35:30.920689570Z"
  }
}
Votes

The Votes endpoint allows users to query for votes by proposal id with pagination flags.

lbm.foundation.v1.Query/Votes

Example:

grpcurl -plaintext \
    -d '{"proposal_id": "1"}' \
    localhost:9090 lbm.foundation.v1.Query/Votes

Example Output:

{
  "votes": [
    {
      "proposalId": "1",
      "voter": "link1...",
      "option": "VOTE_OPTION_NO",
      "metadata": "nope",
      "submitTime": "2022-09-19T01:35:30.920689570Z"
    }
  ],
  "pagination": {
    "total": "1"
  }
}
TallyResult

The TallyResult endpoint allows users to query for the tally in progress by its proposal id.

lbm.foundation.v1.Query/Vote

Example:

grpcurl -plaintext \
    -d '{"proposal_id": "1"}' \
    localhost:9090 lbm.foundation.v1.Query/TallyResult

Example Output:

{
  "tally": {
    "yesCount": "0",
    "abstainCount": "0",
    "noCount": "1000000000000000000",
    "noWithVetoCount": "0"
  }
}
Censorships

The Censorships endpoint allows users to query for all the censorships.

lbm.foundation.v1.Query/Censorships

Example:

grpcurl -plaintext \
    localhost:9090 lbm.foundation.v1.Query/Censorships

Example Output:

{
  "censorships": [
    {
      "msgTypeUrl": "/cosmos.staking.v1beta1.MsgCreateValidator",
      "authority": "CENSORSHIP_AUTHORITY_GOVERNANCE"
    },
    {
      "msgTypeUrl": "/lbm.foundation.v1.MsgWithdrawFromTreasury",
      "authority": "CENSORSHIP_AUTHORITY_FOUNDATION"
    }
  ],
  "pagination": {
    "total": "2"
  }
}
Grants

The Grants endpoint allows users to query grants for a grantee. If the message type URL is set, it selects grants only for that message type.

lbm.foundation.v1.Query/Grants

Example:

grpcurl -plaintext \
    -d '{"grantee": "link1...", "msg_type_url": "/lbm.foundation.v1.MsgWithdrawFromTreasury"}' \
    localhost:9090 lbm.foundation.v1.Query/Grants

Example Output:

{
  "authorizations": [
    {"@type":"/lbm.foundation.v1.ReceiveFromTreasuryAuthorization"}
  ]
}
Treasury

The Treasury endpoint allows users to query for the foundation treasury.

lbm.foundation.v1.Query/Treasury

Example:

grpcurl -plaintext \
    localhost:9090 lbm.foundation.v1.Query/Treasury

Example Output:

{
  "amount": [
    {
      "denom": "stake",
      "amount": "1000000000000000000000000000000"
    }
  ]
}

Documentation

Overview

Package foundation is a reverse proxy.

It translates gRPC into RESTful JSON APIs.

Index

Constants

View Source 
const (
	// ModuleName is the module name constant used in many places
	ModuleName = "foundation"

	// StoreKey defines the primary module store key
	StoreKey = ModuleName

	// RouterKey defines the module's message routing key
	RouterKey = ModuleName

	TreasuryName = "treasury"
)
View Source 
const (
	ProposalTypeFoundationExec string = "FoundationExec"
)

Variables

View Source 
var (
	ErrInvalidLengthAuthz        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAuthz          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupAuthz = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthEvent        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowEvent          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupEvent = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthFoundation        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowFoundation          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupFoundation = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthGenesis        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGenesis          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthQuery        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQuery          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var (
	ErrInvalidLengthTx        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTx          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
)
View Source 
var CensorshipAuthority_name = map[int32]string{
	0: "CENSORSHIP_AUTHORITY_UNSPECIFIED",
	1: "CENSORSHIP_AUTHORITY_GOVERNANCE",
	2: "CENSORSHIP_AUTHORITY_FOUNDATION",
}
View Source 
var CensorshipAuthority_value = map[string]int32{
	"CENSORSHIP_AUTHORITY_UNSPECIFIED": 0,
	"CENSORSHIP_AUTHORITY_GOVERNANCE":  1,
	"CENSORSHIP_AUTHORITY_FOUNDATION":  2,
}
View Source 
var Exec_name = map[int32]string{
	0: "EXEC_UNSPECIFIED",
	1: "EXEC_TRY",
}
View Source 
var Exec_value = map[string]int32{
	"EXEC_UNSPECIFIED": 0,
	"EXEC_TRY":         1,
}
View Source 
var ProposalExecutorResult_name = map[int32]string{
	0: "PROPOSAL_EXECUTOR_RESULT_UNSPECIFIED",
	1: "PROPOSAL_EXECUTOR_RESULT_NOT_RUN",
	2: "PROPOSAL_EXECUTOR_RESULT_SUCCESS",
	3: "PROPOSAL_EXECUTOR_RESULT_FAILURE",
}
View Source 
var ProposalExecutorResult_value = map[string]int32{
	"PROPOSAL_EXECUTOR_RESULT_UNSPECIFIED": 0,
	"PROPOSAL_EXECUTOR_RESULT_NOT_RUN":     1,
	"PROPOSAL_EXECUTOR_RESULT_SUCCESS":     2,
	"PROPOSAL_EXECUTOR_RESULT_FAILURE":     3,
}
View Source 
var ProposalStatus_name = map[int32]string{
	0: "PROPOSAL_STATUS_UNSPECIFIED",
	1: "PROPOSAL_STATUS_SUBMITTED",
	2: "PROPOSAL_STATUS_ACCEPTED",
	3: "PROPOSAL_STATUS_REJECTED",
	4: "PROPOSAL_STATUS_ABORTED",
	5: "PROPOSAL_STATUS_WITHDRAWN",
}
View Source 
var ProposalStatus_value = map[string]int32{
	"PROPOSAL_STATUS_UNSPECIFIED": 0,
	"PROPOSAL_STATUS_SUBMITTED":   1,
	"PROPOSAL_STATUS_ACCEPTED":    2,
	"PROPOSAL_STATUS_REJECTED":    3,
	"PROPOSAL_STATUS_ABORTED":     4,
	"PROPOSAL_STATUS_WITHDRAWN":   5,
}
View Source 
var VoteOption_name = map[int32]string{
	0: "VOTE_OPTION_UNSPECIFIED",
	1: "VOTE_OPTION_YES",
	2: "VOTE_OPTION_ABSTAIN",
	3: "VOTE_OPTION_NO",
	4: "VOTE_OPTION_NO_WITH_VETO",
}
View Source 
var VoteOption_value = map[string]int32{
	"VOTE_OPTION_UNSPECIFIED":  0,
	"VOTE_OPTION_YES":          1,
	"VOTE_OPTION_ABSTAIN":      2,
	"VOTE_OPTION_NO":           3,
	"VOTE_OPTION_NO_WITH_VETO": 4,
}

Functions

func DefaultAuthority 

func DefaultAuthority() sdk.AccAddress

func GetMessagesFromFoundationExecProposal 

func GetMessagesFromFoundationExecProposal(p FoundationExecProposal) []sdk.Msg

func GetMsgs 

func GetMsgs(anys []*codectypes.Any, name string) ([]sdk.Msg, error)

GetMsgs takes a slice of Any's and turn them into sdk.Msg's.

func NewFoundationExecProposal 

func NewFoundationExecProposal(title, description string, msgs []sdk.Msg) govtypes.Content

func RegisterInterfaces 

func RegisterInterfaces(registry types.InterfaceRegistry)

func RegisterLegacyAminoCodec 

func RegisterLegacyAminoCodec(cdc *codec.LegacyAmino)

RegisterLegacyAminoCodec registers concrete types on the LegacyAmino codec

func RegisterMsgServer 

func RegisterMsgServer(s grpc1.Server, srv MsgServer)

func RegisterQueryHandler 

func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error

RegisterQueryHandler registers the http handlers for service Query to "mux". The handlers forward requests to the grpc endpoint over "conn".

func RegisterQueryHandlerClient 

func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error

RegisterQueryHandlerClient registers the http handlers for service Query to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient". Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient" doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in "QueryClient" to call the correct interceptors.

func RegisterQueryHandlerFromEndpoint 

func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error)

RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but automatically dials to "endpoint" and closes the connection when "ctx" gets done.

func RegisterQueryHandlerServer 

func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error

RegisterQueryHandlerServer registers the http handlers for service Query to "mux". UnaryRPC :call QueryServer directly. StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906. Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.

func RegisterQueryServer 

func RegisterQueryServer(s grpc1.Server, srv QueryServer)

func SetAuthorization 

func SetAuthorization(a Authorization) (*codectypes.Any, error)

func SetMsgs 

func SetMsgs(msgs []sdk.Msg) ([]*codectypes.Any, error)

SetMsgs takes a slice of sdk.Msg's and turn them into Any's.

func UnpackInterfaces 

func UnpackInterfaces(unpacker codectypes.AnyUnpacker, anys []*codectypes.Any) error

UnpackInterfaces unpacks Any's to sdk.Msg's.

func ValidateGenesis 

func ValidateGenesis(data GenesisState) error

ValidateGenesis validates the provided genesis state to ensure the expected invariants holds.

Types

type AcceptResponse 

type AcceptResponse struct {
	// If Accept=true, the controller can accept and authorization and handle the update.
	Accept bool
	// If Delete=true, the controller must delete the authorization object and release
	// storage resources.
	Delete bool
	// Controller, who is calling Authorization.Accept must check if `Updated != nil`. If yes,
	// it must use the updated version and handle the update on the storage level.
	Updated Authorization
}

AcceptResponse instruments the controller of an authz message if the request is accepted and if it should be updated or deleted.

type AuthKeeper 

type AuthKeeper interface {
	GetModuleAccount(ctx sdk.Context, name string) authtypes.ModuleAccountI
}

AuthKeeper defines the auth module interface contract needed by the foundation module.

type Authorization 

type Authorization interface {
	proto.Message

	// MsgTypeURL returns the fully-qualified Msg service method URL (as described in ADR 031),
	// which will process and accept or reject a request.
	MsgTypeURL() string

	// Accept determines whether this grant permits the provided sdk.Msg to be performed,
	// and if so provides an updated authorization instance.
	Accept(ctx sdk.Context, msg sdk.Msg) (AcceptResponse, error)

	// ValidateBasic does a simple validation check that
	// doesn't require access to any other information.
	ValidateBasic() error
}

Authorization represents the interface of various Authorization types implemented by other modules. Caution: It's not for x/authz exec.

func GetAuthorization 

func GetAuthorization(any *codectypes.Any, name string) (Authorization, error)

type BankKeeper 

type BankKeeper interface {
	GetAllBalances(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins

	SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
	SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
}

BankKeeper defines the bank module interface contract needed by the foundation module.

type Censorship 

type Censorship struct {
	MsgTypeUrl string              `protobuf:"bytes,1,opt,name=msg_type_url,json=msgTypeUrl,proto3" json:"msg_type_url,omitempty"`
	Authority  CensorshipAuthority `protobuf:"varint,2,opt,name=authority,proto3,enum=lbm.foundation.v1.CensorshipAuthority" json:"authority,omitempty"`
}

func (*Censorship) Descriptor 

func (*Censorship) Descriptor() ([]byte, []int)

func (*Censorship) Equal 

func (this *Censorship) Equal(that interface{}) bool

func (*Censorship) GetAuthority 

func (m *Censorship) GetAuthority() CensorshipAuthority

func (*Censorship) GetMsgTypeUrl 

func (m *Censorship) GetMsgTypeUrl() string

func (*Censorship) Marshal 

func (m *Censorship) Marshal() (dAtA []byte, err error)

func (*Censorship) MarshalTo 

func (m *Censorship) MarshalTo(dAtA []byte) (int, error)

func (*Censorship) MarshalToSizedBuffer 

func (m *Censorship) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Censorship) ProtoMessage 

func (*Censorship) ProtoMessage()

func (*Censorship) Reset 

func (m *Censorship) Reset()

func (*Censorship) Size 

func (m *Censorship) Size() (n int)

func (*Censorship) String 

func (m *Censorship) String() string

func (*Censorship) Unmarshal 

func (m *Censorship) Unmarshal(dAtA []byte) error

func (Censorship) ValidateBasic 

func (c Censorship) ValidateBasic() error

func (*Censorship) XXX_DiscardUnknown 

func (m *Censorship) XXX_DiscardUnknown()

func (*Censorship) XXX_Marshal 

func (m *Censorship) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Censorship) XXX_Merge 

func (m *Censorship) XXX_Merge(src proto.Message)

func (*Censorship) XXX_Size 

func (m *Censorship) XXX_Size() int

func (*Censorship) XXX_Unmarshal 

func (m *Censorship) XXX_Unmarshal(b []byte) error

type CensorshipAuthority 

type CensorshipAuthority int32
const (
	// CENSORSHIP_AUTHORITY_UNSPECIFIED defines an invalid authority.
	CensorshipAuthorityUnspecified CensorshipAuthority = 0
	// CENSORSHIP_AUTHORITY_GOVERNANCE defines x/gov authority.
	CensorshipAuthorityGovernance CensorshipAuthority = 1
	// CENSORSHIP_AUTHORITY_FOUNDATION defines x/foundation authority.
	CensorshipAuthorityFoundation CensorshipAuthority = 2
)

func (CensorshipAuthority) EnumDescriptor 

func (CensorshipAuthority) EnumDescriptor() ([]byte, []int)

func (CensorshipAuthority) String 

func (x CensorshipAuthority) String() string

type Config 

type Config struct {
	// MaxExecutionPeriod defines the max duration after a proposal's voting period ends that members can send a MsgExec to execute the proposal.
	MaxExecutionPeriod time.Duration
	// MaxMetadataLen defines the max length of the metadata bytes field for various entities within the foundation module. Defaults to 255 if not explicitly set.
	MaxMetadataLen uint64
}

Config is a config struct used for intialising the group module to avoid using globals.

func DefaultConfig 

func DefaultConfig() Config

type DecisionPolicy 

type DecisionPolicy interface {
	codec.ProtoMarshaler

	// GetVotingPeriod returns the duration after proposal submission where
	// votes are accepted.
	GetVotingPeriod() time.Duration
	// Allow defines policy-specific logic to allow a proposal to pass or not,
	// based on its tally result, the foundation's total power and the time since
	// the proposal was submitted.
	Allow(tallyResult TallyResult, totalPower sdk.Dec, sinceSubmission time.Duration) (*DecisionPolicyResult, error)

	ValidateBasic() error
	Validate(info FoundationInfo, config Config) error
}

func DefaultDecisionPolicy 

func DefaultDecisionPolicy() DecisionPolicy

type DecisionPolicyResult 

type DecisionPolicyResult struct {
	Allow bool
	Final bool
}

type DecisionPolicyWindows 

type DecisionPolicyWindows struct {
	// voting_period is the duration from submission of a proposal to the end of voting period
	// Within this times votes can be submitted with MsgVote.
	VotingPeriod time.Duration `protobuf:"bytes,1,opt,name=voting_period,json=votingPeriod,proto3,stdduration" json:"voting_period"`
	// min_execution_period is the minimum duration after the proposal submission
	// where members can start sending MsgExec. This means that the window for
	// sending a MsgExec transaction is:
	// `[ submission + min_execution_period ; submission + voting_period + max_execution_period]`
	// where max_execution_period is a app-specific config, defined in the keeper.
	// If not set, min_execution_period will default to 0.
	//
	// Please make sure to set a `min_execution_period` that is smaller than
	// `voting_period + max_execution_period`, or else the above execution window
	// is empty, meaning that all proposals created with this decision policy
	// won't be able to be executed.
	MinExecutionPeriod time.Duration `protobuf:"bytes,2,opt,name=min_execution_period,json=minExecutionPeriod,proto3,stdduration" json:"min_execution_period"`
}

DecisionPolicyWindows defines the different windows for voting and execution.

func (*DecisionPolicyWindows) Descriptor 

func (*DecisionPolicyWindows) Descriptor() ([]byte, []int)

func (*DecisionPolicyWindows) Equal 

func (this *DecisionPolicyWindows) Equal(that interface{}) bool

func (*DecisionPolicyWindows) GetMinExecutionPeriod 

func (m *DecisionPolicyWindows) GetMinExecutionPeriod() time.Duration

func (*DecisionPolicyWindows) GetVotingPeriod 

func (m *DecisionPolicyWindows) GetVotingPeriod() time.Duration

func (*DecisionPolicyWindows) Marshal 

func (m *DecisionPolicyWindows) Marshal() (dAtA []byte, err error)

func (*DecisionPolicyWindows) MarshalTo 

func (m *DecisionPolicyWindows) MarshalTo(dAtA []byte) (int, error)

func (*DecisionPolicyWindows) MarshalToSizedBuffer 

func (m *DecisionPolicyWindows) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*DecisionPolicyWindows) ProtoMessage 

func (*DecisionPolicyWindows) ProtoMessage()

func (*DecisionPolicyWindows) Reset 

func (m *DecisionPolicyWindows) Reset()

func (*DecisionPolicyWindows) Size 

func (m *DecisionPolicyWindows) Size() (n int)

func (*DecisionPolicyWindows) String 

func (m *DecisionPolicyWindows) String() string

func (*DecisionPolicyWindows) Unmarshal 

func (m *DecisionPolicyWindows) Unmarshal(dAtA []byte) error

func (*DecisionPolicyWindows) XXX_DiscardUnknown 

func (m *DecisionPolicyWindows) XXX_DiscardUnknown()

func (*DecisionPolicyWindows) XXX_Marshal 

func (m *DecisionPolicyWindows) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*DecisionPolicyWindows) XXX_Merge 

func (m *DecisionPolicyWindows) XXX_Merge(src proto.Message)

func (*DecisionPolicyWindows) XXX_Size 

func (m *DecisionPolicyWindows) XXX_Size() int

func (*DecisionPolicyWindows) XXX_Unmarshal 

func (m *DecisionPolicyWindows) XXX_Unmarshal(b []byte) error

type EventExec 

type EventExec struct {
	// proposal_id is the unique ID of the proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	// result is the proposal execution result.
	Result ProposalExecutorResult `protobuf:"varint,2,opt,name=result,proto3,enum=lbm.foundation.v1.ProposalExecutorResult" json:"result,omitempty"`
	// logs contains error logs in case the execution result is FAILURE.
	Logs string `protobuf:"bytes,3,opt,name=logs,proto3" json:"logs,omitempty"`
}

EventExec is an event emitted when a proposal is executed.

func (*EventExec) Descriptor 

func (*EventExec) Descriptor() ([]byte, []int)

func (*EventExec) GetLogs 

func (m *EventExec) GetLogs() string

func (*EventExec) GetProposalId 

func (m *EventExec) GetProposalId() uint64

func (*EventExec) GetResult 

func (m *EventExec) GetResult() ProposalExecutorResult

func (*EventExec) Marshal 

func (m *EventExec) Marshal() (dAtA []byte, err error)

func (*EventExec) MarshalTo 

func (m *EventExec) MarshalTo(dAtA []byte) (int, error)

func (*EventExec) MarshalToSizedBuffer 

func (m *EventExec) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventExec) ProtoMessage 

func (*EventExec) ProtoMessage()

func (*EventExec) Reset 

func (m *EventExec) Reset()

func (*EventExec) Size 

func (m *EventExec) Size() (n int)

func (*EventExec) String 

func (m *EventExec) String() string

func (*EventExec) Unmarshal 

func (m *EventExec) Unmarshal(dAtA []byte) error

func (*EventExec) XXX_DiscardUnknown 

func (m *EventExec) XXX_DiscardUnknown()

func (*EventExec) XXX_Marshal 

func (m *EventExec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventExec) XXX_Merge 

func (m *EventExec) XXX_Merge(src proto.Message)

func (*EventExec) XXX_Size 

func (m *EventExec) XXX_Size() int

func (*EventExec) XXX_Unmarshal 

func (m *EventExec) XXX_Unmarshal(b []byte) error

type EventFundTreasury 

type EventFundTreasury struct {
	From   string                                          `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	Amount github_com_PikeEcosystem_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/PikeEcosystem/cosmos-sdk/types.Coins" json:"amount"`
}

EventFundTreasury is an event emitted when one funds the treasury.

func (*EventFundTreasury) Descriptor 

func (*EventFundTreasury) Descriptor() ([]byte, []int)

func (*EventFundTreasury) GetAmount 

func (m *EventFundTreasury) GetAmount() github_com_PikeEcosystem_cosmos_sdk_types.Coins

func (*EventFundTreasury) GetFrom 

func (m *EventFundTreasury) GetFrom() string

func (*EventFundTreasury) Marshal 

func (m *EventFundTreasury) Marshal() (dAtA []byte, err error)

func (*EventFundTreasury) MarshalTo 

func (m *EventFundTreasury) MarshalTo(dAtA []byte) (int, error)

func (*EventFundTreasury) MarshalToSizedBuffer 

func (m *EventFundTreasury) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventFundTreasury) ProtoMessage 

func (*EventFundTreasury) ProtoMessage()

func (*EventFundTreasury) Reset 

func (m *EventFundTreasury) Reset()

func (*EventFundTreasury) Size 

func (m *EventFundTreasury) Size() (n int)

func (*EventFundTreasury) String 

func (m *EventFundTreasury) String() string

func (*EventFundTreasury) Unmarshal 

func (m *EventFundTreasury) Unmarshal(dAtA []byte) error

func (*EventFundTreasury) XXX_DiscardUnknown 

func (m *EventFundTreasury) XXX_DiscardUnknown()

func (*EventFundTreasury) XXX_Marshal 

func (m *EventFundTreasury) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventFundTreasury) XXX_Merge 

func (m *EventFundTreasury) XXX_Merge(src proto.Message)

func (*EventFundTreasury) XXX_Size 

func (m *EventFundTreasury) XXX_Size() int

func (*EventFundTreasury) XXX_Unmarshal 

func (m *EventFundTreasury) XXX_Unmarshal(b []byte) error

type EventGrant 

type EventGrant struct {
	// the address of the grantee.
	Grantee string `protobuf:"bytes,1,opt,name=grantee,proto3" json:"grantee,omitempty"`
	// authorization granted.
	Authorization *types1.Any `protobuf:"bytes,2,opt,name=authorization,proto3" json:"authorization,omitempty"`
}

EventGrant is emitted on Msg/Grant

func (*EventGrant) Descriptor 

func (*EventGrant) Descriptor() ([]byte, []int)

func (*EventGrant) GetAuthorization 

func (m *EventGrant) GetAuthorization() *types1.Any

func (*EventGrant) GetGrantee 

func (m *EventGrant) GetGrantee() string

func (*EventGrant) Marshal 

func (m *EventGrant) Marshal() (dAtA []byte, err error)

func (*EventGrant) MarshalTo 

func (m *EventGrant) MarshalTo(dAtA []byte) (int, error)

func (*EventGrant) MarshalToSizedBuffer 

func (m *EventGrant) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventGrant) ProtoMessage 

func (*EventGrant) ProtoMessage()

func (*EventGrant) Reset 

func (m *EventGrant) Reset()

func (*EventGrant) Size 

func (m *EventGrant) Size() (n int)

func (*EventGrant) String 

func (m *EventGrant) String() string

func (*EventGrant) Unmarshal 

func (m *EventGrant) Unmarshal(dAtA []byte) error

func (*EventGrant) XXX_DiscardUnknown 

func (m *EventGrant) XXX_DiscardUnknown()

func (*EventGrant) XXX_Marshal 

func (m *EventGrant) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventGrant) XXX_Merge 

func (m *EventGrant) XXX_Merge(src proto.Message)

func (*EventGrant) XXX_Size 

func (m *EventGrant) XXX_Size() int

func (*EventGrant) XXX_Unmarshal 

func (m *EventGrant) XXX_Unmarshal(b []byte) error

type EventLeaveFoundation 

type EventLeaveFoundation struct {
	// address is the account address of the foundation member.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

EventLeaveFoundation is an event emitted when a foundation member leaves the foundation.

func (*EventLeaveFoundation) Descriptor 

func (*EventLeaveFoundation) Descriptor() ([]byte, []int)

func (*EventLeaveFoundation) GetAddress 

func (m *EventLeaveFoundation) GetAddress() string

func (*EventLeaveFoundation) Marshal 

func (m *EventLeaveFoundation) Marshal() (dAtA []byte, err error)

func (*EventLeaveFoundation) MarshalTo 

func (m *EventLeaveFoundation) MarshalTo(dAtA []byte) (int, error)

func (*EventLeaveFoundation) MarshalToSizedBuffer 

func (m *EventLeaveFoundation) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventLeaveFoundation) ProtoMessage 

func (*EventLeaveFoundation) ProtoMessage()

func (*EventLeaveFoundation) Reset 

func (m *EventLeaveFoundation) Reset()

func (*EventLeaveFoundation) Size 

func (m *EventLeaveFoundation) Size() (n int)

func (*EventLeaveFoundation) String 

func (m *EventLeaveFoundation) String() string

func (*EventLeaveFoundation) Unmarshal 

func (m *EventLeaveFoundation) Unmarshal(dAtA []byte) error

func (*EventLeaveFoundation) XXX_DiscardUnknown 

func (m *EventLeaveFoundation) XXX_DiscardUnknown()

func (*EventLeaveFoundation) XXX_Marshal 

func (m *EventLeaveFoundation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventLeaveFoundation) XXX_Merge 

func (m *EventLeaveFoundation) XXX_Merge(src proto.Message)

func (*EventLeaveFoundation) XXX_Size 

func (m *EventLeaveFoundation) XXX_Size() int

func (*EventLeaveFoundation) XXX_Unmarshal 

func (m *EventLeaveFoundation) XXX_Unmarshal(b []byte) error

type EventRevoke 

type EventRevoke struct {
	// address of the grantee.
	Grantee string `protobuf:"bytes,1,opt,name=grantee,proto3" json:"grantee,omitempty"`
	// message type url for which an autorization is revoked.
	MsgTypeUrl string `protobuf:"bytes,2,opt,name=msg_type_url,json=msgTypeUrl,proto3" json:"msg_type_url,omitempty"`
}

EventRevoke is emitted on Msg/Revoke

func (*EventRevoke) Descriptor 

func (*EventRevoke) Descriptor() ([]byte, []int)

func (*EventRevoke) GetGrantee 

func (m *EventRevoke) GetGrantee() string

func (*EventRevoke) GetMsgTypeUrl 

func (m *EventRevoke) GetMsgTypeUrl() string

func (*EventRevoke) Marshal 

func (m *EventRevoke) Marshal() (dAtA []byte, err error)

func (*EventRevoke) MarshalTo 

func (m *EventRevoke) MarshalTo(dAtA []byte) (int, error)

func (*EventRevoke) MarshalToSizedBuffer 

func (m *EventRevoke) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventRevoke) ProtoMessage 

func (*EventRevoke) ProtoMessage()

func (*EventRevoke) Reset 

func (m *EventRevoke) Reset()

func (*EventRevoke) Size 

func (m *EventRevoke) Size() (n int)

func (*EventRevoke) String 

func (m *EventRevoke) String() string

func (*EventRevoke) Unmarshal 

func (m *EventRevoke) Unmarshal(dAtA []byte) error

func (*EventRevoke) XXX_DiscardUnknown 

func (m *EventRevoke) XXX_DiscardUnknown()

func (*EventRevoke) XXX_Marshal 

func (m *EventRevoke) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventRevoke) XXX_Merge 

func (m *EventRevoke) XXX_Merge(src proto.Message)

func (*EventRevoke) XXX_Size 

func (m *EventRevoke) XXX_Size() int

func (*EventRevoke) XXX_Unmarshal 

func (m *EventRevoke) XXX_Unmarshal(b []byte) error

type EventSubmitProposal 

type EventSubmitProposal struct {
	// proposal is the unique ID of the proposal.
	Proposal Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal"`
}

EventSubmitProposal is an event emitted when a proposal is created.

func (*EventSubmitProposal) Descriptor 

func (*EventSubmitProposal) Descriptor() ([]byte, []int)

func (*EventSubmitProposal) GetProposal 

func (m *EventSubmitProposal) GetProposal() Proposal

func (*EventSubmitProposal) Marshal 

func (m *EventSubmitProposal) Marshal() (dAtA []byte, err error)

func (*EventSubmitProposal) MarshalTo 

func (m *EventSubmitProposal) MarshalTo(dAtA []byte) (int, error)

func (*EventSubmitProposal) MarshalToSizedBuffer 

func (m *EventSubmitProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventSubmitProposal) ProtoMessage 

func (*EventSubmitProposal) ProtoMessage()

func (*EventSubmitProposal) Reset 

func (m *EventSubmitProposal) Reset()

func (*EventSubmitProposal) Size 

func (m *EventSubmitProposal) Size() (n int)

func (*EventSubmitProposal) String 

func (m *EventSubmitProposal) String() string

func (*EventSubmitProposal) Unmarshal 

func (m *EventSubmitProposal) Unmarshal(dAtA []byte) error

func (*EventSubmitProposal) XXX_DiscardUnknown 

func (m *EventSubmitProposal) XXX_DiscardUnknown()

func (*EventSubmitProposal) XXX_Marshal 

func (m *EventSubmitProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventSubmitProposal) XXX_Merge 

func (m *EventSubmitProposal) XXX_Merge(src proto.Message)

func (*EventSubmitProposal) XXX_Size 

func (m *EventSubmitProposal) XXX_Size() int

func (*EventSubmitProposal) XXX_Unmarshal 

func (m *EventSubmitProposal) XXX_Unmarshal(b []byte) error

type EventUpdateCensorship 

type EventUpdateCensorship struct {
	Censorship Censorship `protobuf:"bytes,1,opt,name=censorship,proto3" json:"censorship"`
}

EventUpdateCensorship is emitted when a censorship information updated.

func (*EventUpdateCensorship) Descriptor 

func (*EventUpdateCensorship) Descriptor() ([]byte, []int)

func (*EventUpdateCensorship) GetCensorship 

func (m *EventUpdateCensorship) GetCensorship() Censorship

func (*EventUpdateCensorship) Marshal 

func (m *EventUpdateCensorship) Marshal() (dAtA []byte, err error)

func (*EventUpdateCensorship) MarshalTo 

func (m *EventUpdateCensorship) MarshalTo(dAtA []byte) (int, error)

func (*EventUpdateCensorship) MarshalToSizedBuffer 

func (m *EventUpdateCensorship) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventUpdateCensorship) ProtoMessage 

func (*EventUpdateCensorship) ProtoMessage()

func (*EventUpdateCensorship) Reset 

func (m *EventUpdateCensorship) Reset()

func (*EventUpdateCensorship) Size 

func (m *EventUpdateCensorship) Size() (n int)

func (*EventUpdateCensorship) String 

func (m *EventUpdateCensorship) String() string

func (*EventUpdateCensorship) Unmarshal 

func (m *EventUpdateCensorship) Unmarshal(dAtA []byte) error

func (*EventUpdateCensorship) XXX_DiscardUnknown 

func (m *EventUpdateCensorship) XXX_DiscardUnknown()

func (*EventUpdateCensorship) XXX_Marshal 

func (m *EventUpdateCensorship) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventUpdateCensorship) XXX_Merge 

func (m *EventUpdateCensorship) XXX_Merge(src proto.Message)

func (*EventUpdateCensorship) XXX_Size 

func (m *EventUpdateCensorship) XXX_Size() int

func (*EventUpdateCensorship) XXX_Unmarshal 

func (m *EventUpdateCensorship) XXX_Unmarshal(b []byte) error

type EventUpdateDecisionPolicy 

type EventUpdateDecisionPolicy struct {
	DecisionPolicy *types1.Any `protobuf:"bytes,1,opt,name=decision_policy,json=decisionPolicy,proto3" json:"decision_policy,omitempty"`
}

EventUpdateDecisionPolicy is an event emitted when the decision policy have been updated.

func (*EventUpdateDecisionPolicy) Descriptor 

func (*EventUpdateDecisionPolicy) Descriptor() ([]byte, []int)

func (EventUpdateDecisionPolicy) GetDecisionPolicy 

func (m EventUpdateDecisionPolicy) GetDecisionPolicy() DecisionPolicy

func (*EventUpdateDecisionPolicy) Marshal 

func (m *EventUpdateDecisionPolicy) Marshal() (dAtA []byte, err error)

func (*EventUpdateDecisionPolicy) MarshalTo 

func (m *EventUpdateDecisionPolicy) MarshalTo(dAtA []byte) (int, error)

func (*EventUpdateDecisionPolicy) MarshalToSizedBuffer 

func (m *EventUpdateDecisionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventUpdateDecisionPolicy) ProtoMessage 

func (*EventUpdateDecisionPolicy) ProtoMessage()

func (*EventUpdateDecisionPolicy) Reset 

func (m *EventUpdateDecisionPolicy) Reset()

func (*EventUpdateDecisionPolicy) SetDecisionPolicy 

func (m *EventUpdateDecisionPolicy) SetDecisionPolicy(policy DecisionPolicy) error

func (*EventUpdateDecisionPolicy) Size 

func (m *EventUpdateDecisionPolicy) Size() (n int)

func (*EventUpdateDecisionPolicy) String 

func (m *EventUpdateDecisionPolicy) String() string

func (*EventUpdateDecisionPolicy) Unmarshal 

func (m *EventUpdateDecisionPolicy) Unmarshal(dAtA []byte) error

func (EventUpdateDecisionPolicy) UnpackInterfaces 

func (m EventUpdateDecisionPolicy) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (*EventUpdateDecisionPolicy) XXX_DiscardUnknown 

func (m *EventUpdateDecisionPolicy) XXX_DiscardUnknown()

func (*EventUpdateDecisionPolicy) XXX_Marshal 

func (m *EventUpdateDecisionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventUpdateDecisionPolicy) XXX_Merge 

func (m *EventUpdateDecisionPolicy) XXX_Merge(src proto.Message)

func (*EventUpdateDecisionPolicy) XXX_Size 

func (m *EventUpdateDecisionPolicy) XXX_Size() int

func (*EventUpdateDecisionPolicy) XXX_Unmarshal 

func (m *EventUpdateDecisionPolicy) XXX_Unmarshal(b []byte) error

type EventUpdateMembers 

type EventUpdateMembers struct {
	MemberUpdates []MemberRequest `protobuf:"bytes,1,rep,name=member_updates,json=memberUpdates,proto3" json:"member_updates"`
}

EventUpdateMembers is an event emitted when the members have been updated.

func (*EventUpdateMembers) Descriptor 

func (*EventUpdateMembers) Descriptor() ([]byte, []int)

func (*EventUpdateMembers) GetMemberUpdates 

func (m *EventUpdateMembers) GetMemberUpdates() []MemberRequest

func (*EventUpdateMembers) Marshal 

func (m *EventUpdateMembers) Marshal() (dAtA []byte, err error)

func (*EventUpdateMembers) MarshalTo 

func (m *EventUpdateMembers) MarshalTo(dAtA []byte) (int, error)

func (*EventUpdateMembers) MarshalToSizedBuffer 

func (m *EventUpdateMembers) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventUpdateMembers) ProtoMessage 

func (*EventUpdateMembers) ProtoMessage()

func (*EventUpdateMembers) Reset 

func (m *EventUpdateMembers) Reset()

func (*EventUpdateMembers) Size 

func (m *EventUpdateMembers) Size() (n int)

func (*EventUpdateMembers) String 

func (m *EventUpdateMembers) String() string

func (*EventUpdateMembers) Unmarshal 

func (m *EventUpdateMembers) Unmarshal(dAtA []byte) error

func (*EventUpdateMembers) XXX_DiscardUnknown 

func (m *EventUpdateMembers) XXX_DiscardUnknown()

func (*EventUpdateMembers) XXX_Marshal 

func (m *EventUpdateMembers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventUpdateMembers) XXX_Merge 

func (m *EventUpdateMembers) XXX_Merge(src proto.Message)

func (*EventUpdateMembers) XXX_Size 

func (m *EventUpdateMembers) XXX_Size() int

func (*EventUpdateMembers) XXX_Unmarshal 

func (m *EventUpdateMembers) XXX_Unmarshal(b []byte) error

type EventUpdateParams 

type EventUpdateParams struct {
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

EventUpdateParams is emitted after updating foundation parameters.

func (*EventUpdateParams) Descriptor 

func (*EventUpdateParams) Descriptor() ([]byte, []int)

func (*EventUpdateParams) GetParams 

func (m *EventUpdateParams) GetParams() Params

func (*EventUpdateParams) Marshal 

func (m *EventUpdateParams) Marshal() (dAtA []byte, err error)

func (*EventUpdateParams) MarshalTo 

func (m *EventUpdateParams) MarshalTo(dAtA []byte) (int, error)

func (*EventUpdateParams) MarshalToSizedBuffer 

func (m *EventUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventUpdateParams) ProtoMessage 

func (*EventUpdateParams) ProtoMessage()

func (*EventUpdateParams) Reset 

func (m *EventUpdateParams) Reset()

func (*EventUpdateParams) Size 

func (m *EventUpdateParams) Size() (n int)

func (*EventUpdateParams) String 

func (m *EventUpdateParams) String() string

func (*EventUpdateParams) Unmarshal 

func (m *EventUpdateParams) Unmarshal(dAtA []byte) error

func (*EventUpdateParams) XXX_DiscardUnknown 

func (m *EventUpdateParams) XXX_DiscardUnknown()

func (*EventUpdateParams) XXX_Marshal 

func (m *EventUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventUpdateParams) XXX_Merge 

func (m *EventUpdateParams) XXX_Merge(src proto.Message)

func (*EventUpdateParams) XXX_Size 

func (m *EventUpdateParams) XXX_Size() int

func (*EventUpdateParams) XXX_Unmarshal 

func (m *EventUpdateParams) XXX_Unmarshal(b []byte) error

type EventVote 

type EventVote struct {
	Vote Vote `protobuf:"bytes,1,opt,name=vote,proto3" json:"vote"`
}

EventVote is an event emitted when a voter votes on a proposal.

func (*EventVote) Descriptor 

func (*EventVote) Descriptor() ([]byte, []int)

func (*EventVote) GetVote 

func (m *EventVote) GetVote() Vote

func (*EventVote) Marshal 

func (m *EventVote) Marshal() (dAtA []byte, err error)

func (*EventVote) MarshalTo 

func (m *EventVote) MarshalTo(dAtA []byte) (int, error)

func (*EventVote) MarshalToSizedBuffer 

func (m *EventVote) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventVote) ProtoMessage 

func (*EventVote) ProtoMessage()

func (*EventVote) Reset 

func (m *EventVote) Reset()

func (*EventVote) Size 

func (m *EventVote) Size() (n int)

func (*EventVote) String 

func (m *EventVote) String() string

func (*EventVote) Unmarshal 

func (m *EventVote) Unmarshal(dAtA []byte) error

func (*EventVote) XXX_DiscardUnknown 

func (m *EventVote) XXX_DiscardUnknown()

func (*EventVote) XXX_Marshal 

func (m *EventVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventVote) XXX_Merge 

func (m *EventVote) XXX_Merge(src proto.Message)

func (*EventVote) XXX_Size 

func (m *EventVote) XXX_Size() int

func (*EventVote) XXX_Unmarshal 

func (m *EventVote) XXX_Unmarshal(b []byte) error

type EventWithdrawFromTreasury 

type EventWithdrawFromTreasury struct {
	To     string                                          `protobuf:"bytes,1,opt,name=to,proto3" json:"to,omitempty"`
	Amount github_com_PikeEcosystem_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/PikeEcosystem/cosmos-sdk/types.Coins" json:"amount"`
}

EventWithdrawFromTreasury is an event emitted when coins are withdrawn from the treasury.

func (*EventWithdrawFromTreasury) Descriptor 

func (*EventWithdrawFromTreasury) Descriptor() ([]byte, []int)

func (*EventWithdrawFromTreasury) GetAmount 

func (m *EventWithdrawFromTreasury) GetAmount() github_com_PikeEcosystem_cosmos_sdk_types.Coins

func (*EventWithdrawFromTreasury) GetTo 

func (m *EventWithdrawFromTreasury) GetTo() string

func (*EventWithdrawFromTreasury) Marshal 

func (m *EventWithdrawFromTreasury) Marshal() (dAtA []byte, err error)

func (*EventWithdrawFromTreasury) MarshalTo 

func (m *EventWithdrawFromTreasury) MarshalTo(dAtA []byte) (int, error)

func (*EventWithdrawFromTreasury) MarshalToSizedBuffer 

func (m *EventWithdrawFromTreasury) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventWithdrawFromTreasury) ProtoMessage 

func (*EventWithdrawFromTreasury) ProtoMessage()

func (*EventWithdrawFromTreasury) Reset 

func (m *EventWithdrawFromTreasury) Reset()

func (*EventWithdrawFromTreasury) Size 

func (m *EventWithdrawFromTreasury) Size() (n int)

func (*EventWithdrawFromTreasury) String 

func (m *EventWithdrawFromTreasury) String() string

func (*EventWithdrawFromTreasury) Unmarshal 

func (m *EventWithdrawFromTreasury) Unmarshal(dAtA []byte) error

func (*EventWithdrawFromTreasury) XXX_DiscardUnknown 

func (m *EventWithdrawFromTreasury) XXX_DiscardUnknown()

func (*EventWithdrawFromTreasury) XXX_Marshal 

func (m *EventWithdrawFromTreasury) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventWithdrawFromTreasury) XXX_Merge 

func (m *EventWithdrawFromTreasury) XXX_Merge(src proto.Message)

func (*EventWithdrawFromTreasury) XXX_Size 

func (m *EventWithdrawFromTreasury) XXX_Size() int

func (*EventWithdrawFromTreasury) XXX_Unmarshal 

func (m *EventWithdrawFromTreasury) XXX_Unmarshal(b []byte) error

type EventWithdrawProposal 

type EventWithdrawProposal struct {
	// proposal_id is the unique ID of the proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
}

EventWithdrawProposal is an event emitted when a proposal is withdrawn.

func (*EventWithdrawProposal) Descriptor 

func (*EventWithdrawProposal) Descriptor() ([]byte, []int)

func (*EventWithdrawProposal) GetProposalId 

func (m *EventWithdrawProposal) GetProposalId() uint64

func (*EventWithdrawProposal) Marshal 

func (m *EventWithdrawProposal) Marshal() (dAtA []byte, err error)

func (*EventWithdrawProposal) MarshalTo 

func (m *EventWithdrawProposal) MarshalTo(dAtA []byte) (int, error)

func (*EventWithdrawProposal) MarshalToSizedBuffer 

func (m *EventWithdrawProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*EventWithdrawProposal) ProtoMessage 

func (*EventWithdrawProposal) ProtoMessage()

func (*EventWithdrawProposal) Reset 

func (m *EventWithdrawProposal) Reset()

func (*EventWithdrawProposal) Size 

func (m *EventWithdrawProposal) Size() (n int)

func (*EventWithdrawProposal) String 

func (m *EventWithdrawProposal) String() string

func (*EventWithdrawProposal) Unmarshal 

func (m *EventWithdrawProposal) Unmarshal(dAtA []byte) error

func (*EventWithdrawProposal) XXX_DiscardUnknown 

func (m *EventWithdrawProposal) XXX_DiscardUnknown()

func (*EventWithdrawProposal) XXX_Marshal 

func (m *EventWithdrawProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*EventWithdrawProposal) XXX_Merge 

func (m *EventWithdrawProposal) XXX_Merge(src proto.Message)

func (*EventWithdrawProposal) XXX_Size 

func (m *EventWithdrawProposal) XXX_Size() int

func (*EventWithdrawProposal) XXX_Unmarshal 

func (m *EventWithdrawProposal) XXX_Unmarshal(b []byte) error

type Exec 

type Exec int32

Exec defines modes of execution of a proposal on creation or on new vote. 

const (
	// An empty value means that there should be a separate
	// MsgExec request for the proposal to execute.
	Exec_EXEC_UNSPECIFIED Exec = 0
	// Try to execute the proposal immediately.
	// If the proposal is not allowed per the DecisionPolicy,
	// the proposal will still be open and could
	// be executed at a later point.
	Exec_EXEC_TRY Exec = 1
)

func (Exec) EnumDescriptor 

func (Exec) EnumDescriptor() ([]byte, []int)

func (Exec) String 

func (x Exec) String() string

type FoundationExecProposal 

type FoundationExecProposal struct {
	Title       string `protobuf:"bytes,1,opt,name=title,proto3" json:"title,omitempty"`
	Description string `protobuf:"bytes,2,opt,name=description,proto3" json:"description,omitempty"`
	// x/foundation messages to execute
	// all the signers must be x/gov authority.
	Messages []*types.Any `protobuf:"bytes,3,rep,name=messages,proto3" json:"messages,omitempty"`
}

FoundationExecProposal is x/gov proposal to trigger the x/foundation messages on behalf of x/gov.

func (*FoundationExecProposal) Descriptor 

func (*FoundationExecProposal) Descriptor() ([]byte, []int)

func (*FoundationExecProposal) Equal 

func (this *FoundationExecProposal) Equal(that interface{}) bool

func (*FoundationExecProposal) GetDescription 

func (m *FoundationExecProposal) GetDescription() string

func (*FoundationExecProposal) GetMessages 

func (m *FoundationExecProposal) GetMessages() []*types.Any

func (*FoundationExecProposal) GetTitle 

func (m *FoundationExecProposal) GetTitle() string

func (*FoundationExecProposal) Marshal 

func (m *FoundationExecProposal) Marshal() (dAtA []byte, err error)

func (*FoundationExecProposal) MarshalTo 

func (m *FoundationExecProposal) MarshalTo(dAtA []byte) (int, error)

func (*FoundationExecProposal) MarshalToSizedBuffer 

func (m *FoundationExecProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (FoundationExecProposal) ProposalRoute 

func (p FoundationExecProposal) ProposalRoute() string

func (FoundationExecProposal) ProposalType 

func (p FoundationExecProposal) ProposalType() string

func (*FoundationExecProposal) ProtoMessage 

func (*FoundationExecProposal) ProtoMessage()

func (*FoundationExecProposal) Reset 

func (m *FoundationExecProposal) Reset()

func (*FoundationExecProposal) SetMessages 

func (p *FoundationExecProposal) SetMessages(msgs []sdk.Msg)

func (*FoundationExecProposal) Size 

func (m *FoundationExecProposal) Size() (n int)

func (*FoundationExecProposal) String 

func (m *FoundationExecProposal) String() string

func (*FoundationExecProposal) Unmarshal 

func (m *FoundationExecProposal) Unmarshal(dAtA []byte) error

func (FoundationExecProposal) UnpackInterfaces 

func (p FoundationExecProposal) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (FoundationExecProposal) ValidateBasic 

func (p FoundationExecProposal) ValidateBasic() error

func (*FoundationExecProposal) XXX_DiscardUnknown 

func (m *FoundationExecProposal) XXX_DiscardUnknown()

func (*FoundationExecProposal) XXX_Marshal 

func (m *FoundationExecProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FoundationExecProposal) XXX_Merge 

func (m *FoundationExecProposal) XXX_Merge(src proto.Message)

func (*FoundationExecProposal) XXX_Size 

func (m *FoundationExecProposal) XXX_Size() int

func (*FoundationExecProposal) XXX_Unmarshal 

func (m *FoundationExecProposal) XXX_Unmarshal(b []byte) error

type FoundationInfo 

type FoundationInfo struct {
	// version is used to track changes to the foundation's membership structure that
	// would break existing proposals. Whenever any member is added or removed,
	// this version is incremented and will cause proposals based on older versions
	// of the foundation to fail
	Version uint64 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"`
	// total_weight is the number of the foundation members.
	TotalWeight github_com_PikeEcosystem_cosmos_sdk_types.Dec `` /* 141-byte string literal not displayed */
	// decision_policy specifies the foundation's decision policy.
	DecisionPolicy *types.Any `protobuf:"bytes,3,opt,name=decision_policy,json=decisionPolicy,proto3" json:"decision_policy,omitempty"`
}

FoundationInfo represents the high-level on-chain information for the foundation.

func DefaultFoundation 

func DefaultFoundation() FoundationInfo

func (*FoundationInfo) Descriptor 

func (*FoundationInfo) Descriptor() ([]byte, []int)

func (*FoundationInfo) Equal 

func (this *FoundationInfo) Equal(that interface{}) bool

func (FoundationInfo) GetDecisionPolicy 

func (i FoundationInfo) GetDecisionPolicy() DecisionPolicy

func (*FoundationInfo) Marshal 

func (m *FoundationInfo) Marshal() (dAtA []byte, err error)

func (*FoundationInfo) MarshalTo 

func (m *FoundationInfo) MarshalTo(dAtA []byte) (int, error)

func (*FoundationInfo) MarshalToSizedBuffer 

func (m *FoundationInfo) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*FoundationInfo) ProtoMessage 

func (*FoundationInfo) ProtoMessage()

func (*FoundationInfo) Reset 

func (m *FoundationInfo) Reset()

func (*FoundationInfo) SetDecisionPolicy 

func (i *FoundationInfo) SetDecisionPolicy(policy DecisionPolicy) error

func (*FoundationInfo) Size 

func (m *FoundationInfo) Size() (n int)

func (*FoundationInfo) String 

func (m *FoundationInfo) String() string

func (*FoundationInfo) Unmarshal 

func (m *FoundationInfo) Unmarshal(dAtA []byte) error

func (*FoundationInfo) UnpackInterfaces 

func (i *FoundationInfo) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (FoundationInfo) ValidateBasic 

func (i FoundationInfo) ValidateBasic() error

func (FoundationInfo) WithDecisionPolicy 

func (i FoundationInfo) WithDecisionPolicy(policy DecisionPolicy) *FoundationInfo

for the tests

func (*FoundationInfo) XXX_DiscardUnknown 

func (m *FoundationInfo) XXX_DiscardUnknown()

func (*FoundationInfo) XXX_Marshal 

func (m *FoundationInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FoundationInfo) XXX_Merge 

func (m *FoundationInfo) XXX_Merge(src proto.Message)

func (*FoundationInfo) XXX_Size 

func (m *FoundationInfo) XXX_Size() int

func (*FoundationInfo) XXX_Unmarshal 

func (m *FoundationInfo) XXX_Unmarshal(b []byte) error

type GenesisState 

type GenesisState struct {
	// params defines the module parameters at genesis.
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
	// foundation is the foundation info.
	Foundation FoundationInfo `protobuf:"bytes,2,opt,name=foundation,proto3" json:"foundation"`
	// members is the list of the foundation members.
	Members []Member `protobuf:"bytes,3,rep,name=members,proto3" json:"members"`
	// it is used to get the next proposal ID.
	PreviousProposalId uint64 `protobuf:"varint,4,opt,name=previous_proposal_id,json=previousProposalId,proto3" json:"previous_proposal_id,omitempty"`
	// proposals is the list of proposals.
	Proposals []Proposal `protobuf:"bytes,5,rep,name=proposals,proto3" json:"proposals"`
	// votes is the list of votes.
	Votes []Vote `protobuf:"bytes,6,rep,name=votes,proto3" json:"votes"`
	// grants
	Authorizations []GrantAuthorization `protobuf:"bytes,7,rep,name=authorizations,proto3" json:"authorizations"`
	// pool
	Pool        Pool         `protobuf:"bytes,8,opt,name=pool,proto3" json:"pool"`
	Censorships []Censorship `protobuf:"bytes,10,rep,name=censorships,proto3" json:"censorships"`
}

GenesisState defines the foundation module's genesis state.

func DefaultGenesisState 

func DefaultGenesisState() *GenesisState

DefaultGenesisState creates a default GenesisState object

func (*GenesisState) Descriptor 

func (*GenesisState) Descriptor() ([]byte, []int)

func (*GenesisState) Marshal 

func (m *GenesisState) Marshal() (dAtA []byte, err error)

func (*GenesisState) MarshalTo 

func (m *GenesisState) MarshalTo(dAtA []byte) (int, error)

func (*GenesisState) MarshalToSizedBuffer 

func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*GenesisState) ProtoMessage 

func (*GenesisState) ProtoMessage()

func (*GenesisState) Reset 

func (m *GenesisState) Reset()

func (*GenesisState) Size 

func (m *GenesisState) Size() (n int)

func (*GenesisState) String 

func (m *GenesisState) String() string

func (*GenesisState) Unmarshal 

func (m *GenesisState) Unmarshal(dAtA []byte) error

func (GenesisState) UnpackInterfaces 

func (data GenesisState) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (*GenesisState) XXX_DiscardUnknown 

func (m *GenesisState) XXX_DiscardUnknown()

func (*GenesisState) XXX_Marshal 

func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GenesisState) XXX_Merge 

func (m *GenesisState) XXX_Merge(src proto.Message)

func (*GenesisState) XXX_Size 

func (m *GenesisState) XXX_Size() int

func (*GenesisState) XXX_Unmarshal 

func (m *GenesisState) XXX_Unmarshal(b []byte) error

type GrantAuthorization 

type GrantAuthorization struct {
	Grantee       string     `protobuf:"bytes,1,opt,name=grantee,proto3" json:"grantee,omitempty"`
	Authorization *types.Any `protobuf:"bytes,2,opt,name=authorization,proto3" json:"authorization,omitempty"`
}

GrantAuthorization defines authorization grant to grantee via route.

func (*GrantAuthorization) Descriptor 

func (*GrantAuthorization) Descriptor() ([]byte, []int)

func (*GrantAuthorization) Equal 

func (this *GrantAuthorization) Equal(that interface{}) bool

func (GrantAuthorization) GetAuthorization 

func (g GrantAuthorization) GetAuthorization() Authorization

func (*GrantAuthorization) Marshal 

func (m *GrantAuthorization) Marshal() (dAtA []byte, err error)

func (*GrantAuthorization) MarshalTo 

func (m *GrantAuthorization) MarshalTo(dAtA []byte) (int, error)

func (*GrantAuthorization) MarshalToSizedBuffer 

func (m *GrantAuthorization) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*GrantAuthorization) ProtoMessage 

func (*GrantAuthorization) ProtoMessage()

func (*GrantAuthorization) Reset 

func (m *GrantAuthorization) Reset()

func (*GrantAuthorization) SetAuthorization 

func (g *GrantAuthorization) SetAuthorization(a Authorization) error

func (*GrantAuthorization) Size 

func (m *GrantAuthorization) Size() (n int)

func (*GrantAuthorization) String 

func (m *GrantAuthorization) String() string

func (*GrantAuthorization) Unmarshal 

func (m *GrantAuthorization) Unmarshal(dAtA []byte) error

func (GrantAuthorization) UnpackInterfaces 

func (g GrantAuthorization) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (GrantAuthorization) WithAuthorization 

func (g GrantAuthorization) WithAuthorization(authorization Authorization) *GrantAuthorization

for the tests

func (*GrantAuthorization) XXX_DiscardUnknown 

func (m *GrantAuthorization) XXX_DiscardUnknown()

func (*GrantAuthorization) XXX_Marshal 

func (m *GrantAuthorization) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*GrantAuthorization) XXX_Merge 

func (m *GrantAuthorization) XXX_Merge(src proto.Message)

func (*GrantAuthorization) XXX_Size 

func (m *GrantAuthorization) XXX_Size() int

func (*GrantAuthorization) XXX_Unmarshal 

func (m *GrantAuthorization) XXX_Unmarshal(b []byte) error

type Member 

type Member struct {
	// address is the member's account address.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// metadata is any arbitrary metadata to attached to the member.
	Metadata string `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// added_at is a timestamp specifying when a member was added.
	AddedAt time.Time `protobuf:"bytes,4,opt,name=added_at,json=addedAt,proto3,stdtime" json:"added_at"`
}

Member represents a foundation member with an account address and metadata.

func (*Member) Descriptor 

func (*Member) Descriptor() ([]byte, []int)

func (*Member) Equal 

func (this *Member) Equal(that interface{}) bool

func (*Member) GetAddedAt 

func (m *Member) GetAddedAt() time.Time

func (*Member) GetAddress 

func (m *Member) GetAddress() string

func (*Member) GetMetadata 

func (m *Member) GetMetadata() string

func (*Member) Marshal 

func (m *Member) Marshal() (dAtA []byte, err error)

func (*Member) MarshalTo 

func (m *Member) MarshalTo(dAtA []byte) (int, error)

func (*Member) MarshalToSizedBuffer 

func (m *Member) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Member) ProtoMessage 

func (*Member) ProtoMessage()

func (*Member) Reset 

func (m *Member) Reset()

func (*Member) Size 

func (m *Member) Size() (n int)

func (*Member) String 

func (m *Member) String() string

func (*Member) Unmarshal 

func (m *Member) Unmarshal(dAtA []byte) error

func (Member) ValidateBasic 

func (m Member) ValidateBasic() error

func (*Member) XXX_DiscardUnknown 

func (m *Member) XXX_DiscardUnknown()

func (*Member) XXX_Marshal 

func (m *Member) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Member) XXX_Merge 

func (m *Member) XXX_Merge(src proto.Message)

func (*Member) XXX_Size 

func (m *Member) XXX_Size() int

func (*Member) XXX_Unmarshal 

func (m *Member) XXX_Unmarshal(b []byte) error

type MemberRequest 

type MemberRequest struct {
	// address is the member's account address.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	// remove is the flag which allows one to remove the member by setting the flag to true.
	Remove bool `protobuf:"varint,2,opt,name=remove,proto3" json:"remove,omitempty"`
	// metadata is any arbitrary metadata attached to the member.
	Metadata string `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"`
}

MemberRequest represents a foundation member to be used in Msg server requests. Contrary to `Member`, it doesn't have any `added_at` field since this field cannot be set as part of requests.

func (*MemberRequest) Descriptor 

func (*MemberRequest) Descriptor() ([]byte, []int)

func (*MemberRequest) Equal 

func (this *MemberRequest) Equal(that interface{}) bool

func (*MemberRequest) GetAddress 

func (m *MemberRequest) GetAddress() string

func (*MemberRequest) GetMetadata 

func (m *MemberRequest) GetMetadata() string

func (*MemberRequest) GetRemove 

func (m *MemberRequest) GetRemove() bool

func (*MemberRequest) Marshal 

func (m *MemberRequest) Marshal() (dAtA []byte, err error)

func (*MemberRequest) MarshalTo 

func (m *MemberRequest) MarshalTo(dAtA []byte) (int, error)

func (*MemberRequest) MarshalToSizedBuffer 

func (m *MemberRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MemberRequest) ProtoMessage 

func (*MemberRequest) ProtoMessage()

func (*MemberRequest) Reset 

func (m *MemberRequest) Reset()

func (*MemberRequest) Size 

func (m *MemberRequest) Size() (n int)

func (*MemberRequest) String 

func (m *MemberRequest) String() string

func (*MemberRequest) Unmarshal 

func (m *MemberRequest) Unmarshal(dAtA []byte) error

func (MemberRequest) ValidateBasic 

func (m MemberRequest) ValidateBasic() error

ValidateBasic performs stateless validation on a member.

func (*MemberRequest) XXX_DiscardUnknown 

func (m *MemberRequest) XXX_DiscardUnknown()

func (*MemberRequest) XXX_Marshal 

func (m *MemberRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MemberRequest) XXX_Merge 

func (m *MemberRequest) XXX_Merge(src proto.Message)

func (*MemberRequest) XXX_Size 

func (m *MemberRequest) XXX_Size() int

func (*MemberRequest) XXX_Unmarshal 

func (m *MemberRequest) XXX_Unmarshal(b []byte) error

type MemberRequests 

type MemberRequests struct {
	Members []MemberRequest
}

MemberRequests defines a repeated slice of MemberRequest objects.

func (MemberRequests) ValidateBasic 

func (ms MemberRequests) ValidateBasic() error

ValidateBasic performs stateless validation on an array of members. On top of validating each member individually, it also makes sure there are no duplicate addresses.

type Members 

type Members struct {
	Members []Member
}

Members defines a repeated slice of Member objects.

func (Members) ValidateBasic 

func (ms Members) ValidateBasic() error

ValidateBasic performs stateless validation on an array of members. On top of validating each member individually, it also makes sure there are no duplicate addresses.

type MsgClient 

type MsgClient interface {
	// UpdateParams defines an operation for updating the x/foundation module
	// parameters.
	UpdateParams(ctx context.Context, in *MsgUpdateParams, opts ...grpc.CallOption) (*MsgUpdateParamsResponse, error)
	// FundTreasury defines a method to fund the treasury.
	FundTreasury(ctx context.Context, in *MsgFundTreasury, opts ...grpc.CallOption) (*MsgFundTreasuryResponse, error)
	// WithdrawFromTreasury defines a method to withdraw coins from the treasury.
	WithdrawFromTreasury(ctx context.Context, in *MsgWithdrawFromTreasury, opts ...grpc.CallOption) (*MsgWithdrawFromTreasuryResponse, error)
	// UpdateMembers updates the foundation members.
	UpdateMembers(ctx context.Context, in *MsgUpdateMembers, opts ...grpc.CallOption) (*MsgUpdateMembersResponse, error)
	// UpdateDecisionPolicy allows a group policy's decision policy to be updated.
	UpdateDecisionPolicy(ctx context.Context, in *MsgUpdateDecisionPolicy, opts ...grpc.CallOption) (*MsgUpdateDecisionPolicyResponse, error)
	// SubmitProposal submits a new proposal.
	SubmitProposal(ctx context.Context, in *MsgSubmitProposal, opts ...grpc.CallOption) (*MsgSubmitProposalResponse, error)
	// WithdrawProposal aborts a proposal.
	WithdrawProposal(ctx context.Context, in *MsgWithdrawProposal, opts ...grpc.CallOption) (*MsgWithdrawProposalResponse, error)
	// Vote allows a voter to vote on a proposal.
	Vote(ctx context.Context, in *MsgVote, opts ...grpc.CallOption) (*MsgVoteResponse, error)
	// Exec executes a proposal.
	Exec(ctx context.Context, in *MsgExec, opts ...grpc.CallOption) (*MsgExecResponse, error)
	// LeaveFoundation allows a member to leave the foundation.
	LeaveFoundation(ctx context.Context, in *MsgLeaveFoundation, opts ...grpc.CallOption) (*MsgLeaveFoundationResponse, error)
	// UpdateCensorship updates censorship information.
	UpdateCensorship(ctx context.Context, in *MsgUpdateCensorship, opts ...grpc.CallOption) (*MsgUpdateCensorshipResponse, error)
	// Grant grants the provided authorization to the grantee with authority of
	// the foundation. If there is already a grant for the given
	// (grantee, Authorization) tuple, then the grant will be overwritten.
	Grant(ctx context.Context, in *MsgGrant, opts ...grpc.CallOption) (*MsgGrantResponse, error)
	// Revoke revokes any authorization corresponding to the provided method name
	// that has been granted to the grantee.
	Revoke(ctx context.Context, in *MsgRevoke, opts ...grpc.CallOption) (*MsgRevokeResponse, error)
}

MsgClient is the client API for Msg service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewMsgClient 

func NewMsgClient(cc grpc1.ClientConn) MsgClient

type MsgExec 

type MsgExec struct {
	// proposal is the unique ID of the proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	// signer is the account address used to execute the proposal.
	Signer string `protobuf:"bytes,2,opt,name=signer,proto3" json:"signer,omitempty"`
}

MsgExec is the Msg/Exec request type.

func (*MsgExec) Descriptor 

func (*MsgExec) Descriptor() ([]byte, []int)

func (MsgExec) GetSignBytes 

func (m MsgExec) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgExec) GetSigners 

func (m MsgExec) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgExec) Marshal 

func (m *MsgExec) Marshal() (dAtA []byte, err error)

func (*MsgExec) MarshalTo 

func (m *MsgExec) MarshalTo(dAtA []byte) (int, error)

func (*MsgExec) MarshalToSizedBuffer 

func (m *MsgExec) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgExec) ProtoMessage 

func (*MsgExec) ProtoMessage()

func (*MsgExec) Reset 

func (m *MsgExec) Reset()

func (MsgExec) Route 

func (m MsgExec) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgExec) Size 

func (m *MsgExec) Size() (n int)

func (*MsgExec) String 

func (m *MsgExec) String() string

func (MsgExec) Type 

func (m MsgExec) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgExec) Unmarshal 

func (m *MsgExec) Unmarshal(dAtA []byte) error

func (MsgExec) ValidateBasic 

func (m MsgExec) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgExec) XXX_DiscardUnknown 

func (m *MsgExec) XXX_DiscardUnknown()

func (*MsgExec) XXX_Marshal 

func (m *MsgExec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgExec) XXX_Merge 

func (m *MsgExec) XXX_Merge(src proto.Message)

func (*MsgExec) XXX_Size 

func (m *MsgExec) XXX_Size() int

func (*MsgExec) XXX_Unmarshal 

func (m *MsgExec) XXX_Unmarshal(b []byte) error

type MsgExecResponse 

type MsgExecResponse struct {
}

MsgExecResponse is the Msg/Exec request type.

func (*MsgExecResponse) Descriptor 

func (*MsgExecResponse) Descriptor() ([]byte, []int)

func (*MsgExecResponse) Marshal 

func (m *MsgExecResponse) Marshal() (dAtA []byte, err error)

func (*MsgExecResponse) MarshalTo 

func (m *MsgExecResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgExecResponse) MarshalToSizedBuffer 

func (m *MsgExecResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgExecResponse) ProtoMessage 

func (*MsgExecResponse) ProtoMessage()

func (*MsgExecResponse) Reset 

func (m *MsgExecResponse) Reset()

func (*MsgExecResponse) Size 

func (m *MsgExecResponse) Size() (n int)

func (*MsgExecResponse) String 

func (m *MsgExecResponse) String() string

func (*MsgExecResponse) Unmarshal 

func (m *MsgExecResponse) Unmarshal(dAtA []byte) error

func (*MsgExecResponse) XXX_DiscardUnknown 

func (m *MsgExecResponse) XXX_DiscardUnknown()

func (*MsgExecResponse) XXX_Marshal 

func (m *MsgExecResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgExecResponse) XXX_Merge 

func (m *MsgExecResponse) XXX_Merge(src proto.Message)

func (*MsgExecResponse) XXX_Size 

func (m *MsgExecResponse) XXX_Size() int

func (*MsgExecResponse) XXX_Unmarshal 

func (m *MsgExecResponse) XXX_Unmarshal(b []byte) error

type MsgFundTreasury 

type MsgFundTreasury struct {
	From   string                                          `protobuf:"bytes,1,opt,name=from,proto3" json:"from,omitempty"`
	Amount github_com_PikeEcosystem_cosmos_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/PikeEcosystem/cosmos-sdk/types.Coins" json:"amount"`
}

MsgFundTreasury is the Msg/FundTreasury request type.

func (*MsgFundTreasury) Descriptor 

func (*MsgFundTreasury) Descriptor() ([]byte, []int)

func (MsgFundTreasury) GetSignBytes 

func (m MsgFundTreasury) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgFundTreasury) GetSigners 

func (m MsgFundTreasury) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgFundTreasury) Marshal 

func (m *MsgFundTreasury) Marshal() (dAtA []byte, err error)

func (*MsgFundTreasury) MarshalTo 

func (m *MsgFundTreasury) MarshalTo(dAtA []byte) (int, error)

func (*MsgFundTreasury) MarshalToSizedBuffer 

func (m *MsgFundTreasury) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgFundTreasury) ProtoMessage 

func (*MsgFundTreasury) ProtoMessage()

func (*MsgFundTreasury) Reset 

func (m *MsgFundTreasury) Reset()

func (MsgFundTreasury) Route 

func (m MsgFundTreasury) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgFundTreasury) Size 

func (m *MsgFundTreasury) Size() (n int)

func (*MsgFundTreasury) String 

func (m *MsgFundTreasury) String() string

func (MsgFundTreasury) Type 

func (m MsgFundTreasury) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgFundTreasury) Unmarshal 

func (m *MsgFundTreasury) Unmarshal(dAtA []byte) error

func (MsgFundTreasury) ValidateBasic 

func (m MsgFundTreasury) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgFundTreasury) XXX_DiscardUnknown 

func (m *MsgFundTreasury) XXX_DiscardUnknown()

func (*MsgFundTreasury) XXX_Marshal 

func (m *MsgFundTreasury) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgFundTreasury) XXX_Merge 

func (m *MsgFundTreasury) XXX_Merge(src proto.Message)

func (*MsgFundTreasury) XXX_Size 

func (m *MsgFundTreasury) XXX_Size() int

func (*MsgFundTreasury) XXX_Unmarshal 

func (m *MsgFundTreasury) XXX_Unmarshal(b []byte) error

type MsgFundTreasuryResponse 

type MsgFundTreasuryResponse struct {
}

MsgFundTreasuryResponse is the Msg/FundTreasury response type.

func (*MsgFundTreasuryResponse) Descriptor 

func (*MsgFundTreasuryResponse) Descriptor() ([]byte, []int)

func (*MsgFundTreasuryResponse) Marshal 

func (m *MsgFundTreasuryResponse) Marshal() (dAtA []byte, err error)

func (*MsgFundTreasuryResponse) MarshalTo 

func (m *MsgFundTreasuryResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgFundTreasuryResponse) MarshalToSizedBuffer 

func (m *MsgFundTreasuryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgFundTreasuryResponse) ProtoMessage 

func (*MsgFundTreasuryResponse) ProtoMessage()

func (*MsgFundTreasuryResponse) Reset 

func (m *MsgFundTreasuryResponse) Reset()

func (*MsgFundTreasuryResponse) Size 

func (m *MsgFundTreasuryResponse) Size() (n int)

func (*MsgFundTreasuryResponse) String 

func (m *MsgFundTreasuryResponse) String() string

func (*MsgFundTreasuryResponse) Unmarshal 

func (m *MsgFundTreasuryResponse) Unmarshal(dAtA []byte) error

func (*MsgFundTreasuryResponse) XXX_DiscardUnknown 

func (m *MsgFundTreasuryResponse) XXX_DiscardUnknown()

func (*MsgFundTreasuryResponse) XXX_Marshal 

func (m *MsgFundTreasuryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgFundTreasuryResponse) XXX_Merge 

func (m *MsgFundTreasuryResponse) XXX_Merge(src proto.Message)

func (*MsgFundTreasuryResponse) XXX_Size 

func (m *MsgFundTreasuryResponse) XXX_Size() int

func (*MsgFundTreasuryResponse) XXX_Unmarshal 

func (m *MsgFundTreasuryResponse) XXX_Unmarshal(b []byte) error

type MsgGrant 

type MsgGrant struct {
	// authority is the address of the privileged account.
	Authority     string      `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	Grantee       string      `protobuf:"bytes,2,opt,name=grantee,proto3" json:"grantee,omitempty"`
	Authorization *types1.Any `protobuf:"bytes,3,opt,name=authorization,proto3" json:"authorization,omitempty"`
}

MsgGrant is the Msg/Grant request type. on behalf of the foundation.

func (*MsgGrant) Descriptor 

func (*MsgGrant) Descriptor() ([]byte, []int)

func (MsgGrant) GetAuthorization 

func (m MsgGrant) GetAuthorization() Authorization

func (MsgGrant) GetSignBytes 

func (m MsgGrant) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgGrant) GetSigners 

func (m MsgGrant) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgGrant) Marshal 

func (m *MsgGrant) Marshal() (dAtA []byte, err error)

func (*MsgGrant) MarshalTo 

func (m *MsgGrant) MarshalTo(dAtA []byte) (int, error)

func (*MsgGrant) MarshalToSizedBuffer 

func (m *MsgGrant) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgGrant) ProtoMessage 

func (*MsgGrant) ProtoMessage()

func (*MsgGrant) Reset 

func (m *MsgGrant) Reset()

func (MsgGrant) Route 

func (m MsgGrant) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgGrant) SetAuthorization 

func (m *MsgGrant) SetAuthorization(a Authorization) error

func (*MsgGrant) Size 

func (m *MsgGrant) Size() (n int)

func (*MsgGrant) String 

func (m *MsgGrant) String() string

func (MsgGrant) Type 

func (m MsgGrant) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgGrant) Unmarshal 

func (m *MsgGrant) Unmarshal(dAtA []byte) error

func (MsgGrant) UnpackInterfaces 

func (m MsgGrant) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (MsgGrant) ValidateBasic 

func (m MsgGrant) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgGrant) XXX_DiscardUnknown 

func (m *MsgGrant) XXX_DiscardUnknown()

func (*MsgGrant) XXX_Marshal 

func (m *MsgGrant) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgGrant) XXX_Merge 

func (m *MsgGrant) XXX_Merge(src proto.Message)

func (*MsgGrant) XXX_Size 

func (m *MsgGrant) XXX_Size() int

func (*MsgGrant) XXX_Unmarshal 

func (m *MsgGrant) XXX_Unmarshal(b []byte) error

type MsgGrantResponse 

type MsgGrantResponse struct {
}

MsgGrantResponse is the Msg/MsgGrant response type.

func (*MsgGrantResponse) Descriptor 

func (*MsgGrantResponse) Descriptor() ([]byte, []int)

func (*MsgGrantResponse) Marshal 

func (m *MsgGrantResponse) Marshal() (dAtA []byte, err error)

func (*MsgGrantResponse) MarshalTo 

func (m *MsgGrantResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgGrantResponse) MarshalToSizedBuffer 

func (m *MsgGrantResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgGrantResponse) ProtoMessage 

func (*MsgGrantResponse) ProtoMessage()

func (*MsgGrantResponse) Reset 

func (m *MsgGrantResponse) Reset()

func (*MsgGrantResponse) Size 

func (m *MsgGrantResponse) Size() (n int)

func (*MsgGrantResponse) String 

func (m *MsgGrantResponse) String() string

func (*MsgGrantResponse) Unmarshal 

func (m *MsgGrantResponse) Unmarshal(dAtA []byte) error

func (*MsgGrantResponse) XXX_DiscardUnknown 

func (m *MsgGrantResponse) XXX_DiscardUnknown()

func (*MsgGrantResponse) XXX_Marshal 

func (m *MsgGrantResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgGrantResponse) XXX_Merge 

func (m *MsgGrantResponse) XXX_Merge(src proto.Message)

func (*MsgGrantResponse) XXX_Size 

func (m *MsgGrantResponse) XXX_Size() int

func (*MsgGrantResponse) XXX_Unmarshal 

func (m *MsgGrantResponse) XXX_Unmarshal(b []byte) error

type MsgLeaveFoundation 

type MsgLeaveFoundation struct {
	// address is the account address of the foundation member.
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

MsgLeaveFoundation is the Msg/LeaveFoundation request type.

func (*MsgLeaveFoundation) Descriptor 

func (*MsgLeaveFoundation) Descriptor() ([]byte, []int)

func (MsgLeaveFoundation) GetSignBytes 

func (m MsgLeaveFoundation) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgLeaveFoundation) GetSigners 

func (m MsgLeaveFoundation) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgLeaveFoundation) Marshal 

func (m *MsgLeaveFoundation) Marshal() (dAtA []byte, err error)

func (*MsgLeaveFoundation) MarshalTo 

func (m *MsgLeaveFoundation) MarshalTo(dAtA []byte) (int, error)

func (*MsgLeaveFoundation) MarshalToSizedBuffer 

func (m *MsgLeaveFoundation) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgLeaveFoundation) ProtoMessage 

func (*MsgLeaveFoundation) ProtoMessage()

func (*MsgLeaveFoundation) Reset 

func (m *MsgLeaveFoundation) Reset()

func (MsgLeaveFoundation) Route 

func (m MsgLeaveFoundation) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgLeaveFoundation) Size 

func (m *MsgLeaveFoundation) Size() (n int)

func (*MsgLeaveFoundation) String 

func (m *MsgLeaveFoundation) String() string

func (MsgLeaveFoundation) Type 

func (m MsgLeaveFoundation) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgLeaveFoundation) Unmarshal 

func (m *MsgLeaveFoundation) Unmarshal(dAtA []byte) error

func (MsgLeaveFoundation) ValidateBasic 

func (m MsgLeaveFoundation) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgLeaveFoundation) XXX_DiscardUnknown 

func (m *MsgLeaveFoundation) XXX_DiscardUnknown()

func (*MsgLeaveFoundation) XXX_Marshal 

func (m *MsgLeaveFoundation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgLeaveFoundation) XXX_Merge 

func (m *MsgLeaveFoundation) XXX_Merge(src proto.Message)

func (*MsgLeaveFoundation) XXX_Size 

func (m *MsgLeaveFoundation) XXX_Size() int

func (*MsgLeaveFoundation) XXX_Unmarshal 

func (m *MsgLeaveFoundation) XXX_Unmarshal(b []byte) error

type MsgLeaveFoundationResponse 

type MsgLeaveFoundationResponse struct {
}

MsgLeaveFoundationResponse is the Msg/LeaveFoundation response type.

func (*MsgLeaveFoundationResponse) Descriptor 

func (*MsgLeaveFoundationResponse) Descriptor() ([]byte, []int)

func (*MsgLeaveFoundationResponse) Marshal 

func (m *MsgLeaveFoundationResponse) Marshal() (dAtA []byte, err error)

func (*MsgLeaveFoundationResponse) MarshalTo 

func (m *MsgLeaveFoundationResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgLeaveFoundationResponse) MarshalToSizedBuffer 

func (m *MsgLeaveFoundationResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgLeaveFoundationResponse) ProtoMessage 

func (*MsgLeaveFoundationResponse) ProtoMessage()

func (*MsgLeaveFoundationResponse) Reset 

func (m *MsgLeaveFoundationResponse) Reset()

func (*MsgLeaveFoundationResponse) Size 

func (m *MsgLeaveFoundationResponse) Size() (n int)

func (*MsgLeaveFoundationResponse) String 

func (m *MsgLeaveFoundationResponse) String() string

func (*MsgLeaveFoundationResponse) Unmarshal 

func (m *MsgLeaveFoundationResponse) Unmarshal(dAtA []byte) error

func (*MsgLeaveFoundationResponse) XXX_DiscardUnknown 

func (m *MsgLeaveFoundationResponse) XXX_DiscardUnknown()

func (*MsgLeaveFoundationResponse) XXX_Marshal 

func (m *MsgLeaveFoundationResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgLeaveFoundationResponse) XXX_Merge 

func (m *MsgLeaveFoundationResponse) XXX_Merge(src proto.Message)

func (*MsgLeaveFoundationResponse) XXX_Size 

func (m *MsgLeaveFoundationResponse) XXX_Size() int

func (*MsgLeaveFoundationResponse) XXX_Unmarshal 

func (m *MsgLeaveFoundationResponse) XXX_Unmarshal(b []byte) error

type MsgRevoke 

type MsgRevoke struct {
	// authority is the address of the privileged account.
	Authority  string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	Grantee    string `protobuf:"bytes,2,opt,name=grantee,proto3" json:"grantee,omitempty"`
	MsgTypeUrl string `protobuf:"bytes,3,opt,name=msg_type_url,json=msgTypeUrl,proto3" json:"msg_type_url,omitempty"`
}

MsgRevoke is the Msg/Revoke request type.

func (*MsgRevoke) Descriptor 

func (*MsgRevoke) Descriptor() ([]byte, []int)

func (MsgRevoke) GetSignBytes 

func (m MsgRevoke) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgRevoke) GetSigners 

func (m MsgRevoke) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgRevoke) Marshal 

func (m *MsgRevoke) Marshal() (dAtA []byte, err error)

func (*MsgRevoke) MarshalTo 

func (m *MsgRevoke) MarshalTo(dAtA []byte) (int, error)

func (*MsgRevoke) MarshalToSizedBuffer 

func (m *MsgRevoke) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgRevoke) ProtoMessage 

func (*MsgRevoke) ProtoMessage()

func (*MsgRevoke) Reset 

func (m *MsgRevoke) Reset()

func (MsgRevoke) Route 

func (m MsgRevoke) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgRevoke) Size 

func (m *MsgRevoke) Size() (n int)

func (*MsgRevoke) String 

func (m *MsgRevoke) String() string

func (MsgRevoke) Type 

func (m MsgRevoke) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgRevoke) Unmarshal 

func (m *MsgRevoke) Unmarshal(dAtA []byte) error

func (MsgRevoke) ValidateBasic 

func (m MsgRevoke) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgRevoke) XXX_DiscardUnknown 

func (m *MsgRevoke) XXX_DiscardUnknown()

func (*MsgRevoke) XXX_Marshal 

func (m *MsgRevoke) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgRevoke) XXX_Merge 

func (m *MsgRevoke) XXX_Merge(src proto.Message)

func (*MsgRevoke) XXX_Size 

func (m *MsgRevoke) XXX_Size() int

func (*MsgRevoke) XXX_Unmarshal 

func (m *MsgRevoke) XXX_Unmarshal(b []byte) error

type MsgRevokeResponse 

type MsgRevokeResponse struct {
}

MsgRevokeResponse is the Msg/MsgRevokeResponse response type.

func (*MsgRevokeResponse) Descriptor 

func (*MsgRevokeResponse) Descriptor() ([]byte, []int)

func (*MsgRevokeResponse) Marshal 

func (m *MsgRevokeResponse) Marshal() (dAtA []byte, err error)

func (*MsgRevokeResponse) MarshalTo 

func (m *MsgRevokeResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgRevokeResponse) MarshalToSizedBuffer 

func (m *MsgRevokeResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgRevokeResponse) ProtoMessage 

func (*MsgRevokeResponse) ProtoMessage()

func (*MsgRevokeResponse) Reset 

func (m *MsgRevokeResponse) Reset()

func (*MsgRevokeResponse) Size 

func (m *MsgRevokeResponse) Size() (n int)

func (*MsgRevokeResponse) String 

func (m *MsgRevokeResponse) String() string

func (*MsgRevokeResponse) Unmarshal 

func (m *MsgRevokeResponse) Unmarshal(dAtA []byte) error

func (*MsgRevokeResponse) XXX_DiscardUnknown 

func (m *MsgRevokeResponse) XXX_DiscardUnknown()

func (*MsgRevokeResponse) XXX_Marshal 

func (m *MsgRevokeResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgRevokeResponse) XXX_Merge 

func (m *MsgRevokeResponse) XXX_Merge(src proto.Message)

func (*MsgRevokeResponse) XXX_Size 

func (m *MsgRevokeResponse) XXX_Size() int

func (*MsgRevokeResponse) XXX_Unmarshal 

func (m *MsgRevokeResponse) XXX_Unmarshal(b []byte) error

type MsgServer 

type MsgServer interface {
	// UpdateParams defines an operation for updating the x/foundation module
	// parameters.
	UpdateParams(context.Context, *MsgUpdateParams) (*MsgUpdateParamsResponse, error)
	// FundTreasury defines a method to fund the treasury.
	FundTreasury(context.Context, *MsgFundTreasury) (*MsgFundTreasuryResponse, error)
	// WithdrawFromTreasury defines a method to withdraw coins from the treasury.
	WithdrawFromTreasury(context.Context, *MsgWithdrawFromTreasury) (*MsgWithdrawFromTreasuryResponse, error)
	// UpdateMembers updates the foundation members.
	UpdateMembers(context.Context, *MsgUpdateMembers) (*MsgUpdateMembersResponse, error)
	// UpdateDecisionPolicy allows a group policy's decision policy to be updated.
	UpdateDecisionPolicy(context.Context, *MsgUpdateDecisionPolicy) (*MsgUpdateDecisionPolicyResponse, error)
	// SubmitProposal submits a new proposal.
	SubmitProposal(context.Context, *MsgSubmitProposal) (*MsgSubmitProposalResponse, error)
	// WithdrawProposal aborts a proposal.
	WithdrawProposal(context.Context, *MsgWithdrawProposal) (*MsgWithdrawProposalResponse, error)
	// Vote allows a voter to vote on a proposal.
	Vote(context.Context, *MsgVote) (*MsgVoteResponse, error)
	// Exec executes a proposal.
	Exec(context.Context, *MsgExec) (*MsgExecResponse, error)
	// LeaveFoundation allows a member to leave the foundation.
	LeaveFoundation(context.Context, *MsgLeaveFoundation) (*MsgLeaveFoundationResponse, error)
	// UpdateCensorship updates censorship information.
	UpdateCensorship(context.Context, *MsgUpdateCensorship) (*MsgUpdateCensorshipResponse, error)
	// Grant grants the provided authorization to the grantee with authority of
	// the foundation. If there is already a grant for the given
	// (grantee, Authorization) tuple, then the grant will be overwritten.
	Grant(context.Context, *MsgGrant) (*MsgGrantResponse, error)
	// Revoke revokes any authorization corresponding to the provided method name
	// that has been granted to the grantee.
	Revoke(context.Context, *MsgRevoke) (*MsgRevokeResponse, error)
}

MsgServer is the server API for Msg service.

type MsgSubmitProposal 

type MsgSubmitProposal struct {
	// proposers are the account addresses of the proposers.
	// Proposers signatures will be counted as yes votes.
	Proposers []string `protobuf:"bytes,1,rep,name=proposers,proto3" json:"proposers,omitempty"`
	// metadata is any arbitrary metadata to attached to the proposal.
	Metadata string `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// messages is a list of `sdk.Msg`s that will be executed if the proposal passes.
	Messages []*types1.Any `protobuf:"bytes,3,rep,name=messages,proto3" json:"messages,omitempty"`
	// exec defines the mode of execution of the proposal,
	// whether it should be executed immediately on creation or not.
	// If so, proposers signatures are considered as Yes votes.
	Exec Exec `protobuf:"varint,4,opt,name=exec,proto3,enum=lbm.foundation.v1.Exec" json:"exec,omitempty"`
}

MsgSubmitProposal is the Msg/SubmitProposal request type.

func (*MsgSubmitProposal) Descriptor 

func (*MsgSubmitProposal) Descriptor() ([]byte, []int)

func (MsgSubmitProposal) GetMsgs 

func (m MsgSubmitProposal) GetMsgs() []sdk.Msg

func (MsgSubmitProposal) GetSignBytes 

func (m MsgSubmitProposal) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgSubmitProposal) GetSigners 

func (m MsgSubmitProposal) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgSubmitProposal) Marshal 

func (m *MsgSubmitProposal) Marshal() (dAtA []byte, err error)

func (*MsgSubmitProposal) MarshalTo 

func (m *MsgSubmitProposal) MarshalTo(dAtA []byte) (int, error)

func (*MsgSubmitProposal) MarshalToSizedBuffer 

func (m *MsgSubmitProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgSubmitProposal) ProtoMessage 

func (*MsgSubmitProposal) ProtoMessage()

func (*MsgSubmitProposal) Reset 

func (m *MsgSubmitProposal) Reset()

func (MsgSubmitProposal) Route 

func (m MsgSubmitProposal) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgSubmitProposal) SetMsgs 

func (m *MsgSubmitProposal) SetMsgs(msgs []sdk.Msg) error

func (*MsgSubmitProposal) Size 

func (m *MsgSubmitProposal) Size() (n int)

func (*MsgSubmitProposal) String 

func (m *MsgSubmitProposal) String() string

func (MsgSubmitProposal) Type 

func (m MsgSubmitProposal) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgSubmitProposal) Unmarshal 

func (m *MsgSubmitProposal) Unmarshal(dAtA []byte) error

func (MsgSubmitProposal) UnpackInterfaces 

func (m MsgSubmitProposal) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (MsgSubmitProposal) ValidateBasic 

func (m MsgSubmitProposal) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgSubmitProposal) XXX_DiscardUnknown 

func (m *MsgSubmitProposal) XXX_DiscardUnknown()

func (*MsgSubmitProposal) XXX_Marshal 

func (m *MsgSubmitProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgSubmitProposal) XXX_Merge 

func (m *MsgSubmitProposal) XXX_Merge(src proto.Message)

func (*MsgSubmitProposal) XXX_Size 

func (m *MsgSubmitProposal) XXX_Size() int

func (*MsgSubmitProposal) XXX_Unmarshal 

func (m *MsgSubmitProposal) XXX_Unmarshal(b []byte) error

type MsgSubmitProposalResponse 

type MsgSubmitProposalResponse struct {
	// proposal is the unique ID of the proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
}

MsgSubmitProposalResponse is the Msg/SubmitProposal response type.

func (*MsgSubmitProposalResponse) Descriptor 

func (*MsgSubmitProposalResponse) Descriptor() ([]byte, []int)

func (*MsgSubmitProposalResponse) Marshal 

func (m *MsgSubmitProposalResponse) Marshal() (dAtA []byte, err error)

func (*MsgSubmitProposalResponse) MarshalTo 

func (m *MsgSubmitProposalResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgSubmitProposalResponse) MarshalToSizedBuffer 

func (m *MsgSubmitProposalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgSubmitProposalResponse) ProtoMessage 

func (*MsgSubmitProposalResponse) ProtoMessage()

func (*MsgSubmitProposalResponse) Reset 

func (m *MsgSubmitProposalResponse) Reset()

func (*MsgSubmitProposalResponse) Size 

func (m *MsgSubmitProposalResponse) Size() (n int)

func (*MsgSubmitProposalResponse) String 

func (m *MsgSubmitProposalResponse) String() string

func (*MsgSubmitProposalResponse) Unmarshal 

func (m *MsgSubmitProposalResponse) Unmarshal(dAtA []byte) error

func (*MsgSubmitProposalResponse) XXX_DiscardUnknown 

func (m *MsgSubmitProposalResponse) XXX_DiscardUnknown()

func (*MsgSubmitProposalResponse) XXX_Marshal 

func (m *MsgSubmitProposalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgSubmitProposalResponse) XXX_Merge 

func (m *MsgSubmitProposalResponse) XXX_Merge(src proto.Message)

func (*MsgSubmitProposalResponse) XXX_Size 

func (m *MsgSubmitProposalResponse) XXX_Size() int

func (*MsgSubmitProposalResponse) XXX_Unmarshal 

func (m *MsgSubmitProposalResponse) XXX_Unmarshal(b []byte) error

type MsgUpdateCensorship 

type MsgUpdateCensorship struct {
	// authority over the target censorship.
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// new censorship information
	Censorship Censorship `protobuf:"bytes,2,opt,name=censorship,proto3" json:"censorship"`
}

MsgUpdateCensorship is the Msg/UpdateCensorship request type.

func (*MsgUpdateCensorship) Descriptor 

func (*MsgUpdateCensorship) Descriptor() ([]byte, []int)

func (MsgUpdateCensorship) GetSignBytes 

func (m MsgUpdateCensorship) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgUpdateCensorship) GetSigners 

func (m MsgUpdateCensorship) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgUpdateCensorship) Marshal 

func (m *MsgUpdateCensorship) Marshal() (dAtA []byte, err error)

func (*MsgUpdateCensorship) MarshalTo 

func (m *MsgUpdateCensorship) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateCensorship) MarshalToSizedBuffer 

func (m *MsgUpdateCensorship) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateCensorship) ProtoMessage 

func (*MsgUpdateCensorship) ProtoMessage()

func (*MsgUpdateCensorship) Reset 

func (m *MsgUpdateCensorship) Reset()

func (MsgUpdateCensorship) Route 

func (m MsgUpdateCensorship) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgUpdateCensorship) Size 

func (m *MsgUpdateCensorship) Size() (n int)

func (*MsgUpdateCensorship) String 

func (m *MsgUpdateCensorship) String() string

func (MsgUpdateCensorship) Type 

func (m MsgUpdateCensorship) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgUpdateCensorship) Unmarshal 

func (m *MsgUpdateCensorship) Unmarshal(dAtA []byte) error

func (MsgUpdateCensorship) ValidateBasic 

func (m MsgUpdateCensorship) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgUpdateCensorship) XXX_DiscardUnknown 

func (m *MsgUpdateCensorship) XXX_DiscardUnknown()

func (*MsgUpdateCensorship) XXX_Marshal 

func (m *MsgUpdateCensorship) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateCensorship) XXX_Merge 

func (m *MsgUpdateCensorship) XXX_Merge(src proto.Message)

func (*MsgUpdateCensorship) XXX_Size 

func (m *MsgUpdateCensorship) XXX_Size() int

func (*MsgUpdateCensorship) XXX_Unmarshal 

func (m *MsgUpdateCensorship) XXX_Unmarshal(b []byte) error

type MsgUpdateCensorshipResponse 

type MsgUpdateCensorshipResponse struct {
}

MsgUpdateCensorshipResponse is the Msg/UpdateCensorship response type.

func (*MsgUpdateCensorshipResponse) Descriptor 

func (*MsgUpdateCensorshipResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateCensorshipResponse) Marshal 

func (m *MsgUpdateCensorshipResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateCensorshipResponse) MarshalTo 

func (m *MsgUpdateCensorshipResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateCensorshipResponse) MarshalToSizedBuffer 

func (m *MsgUpdateCensorshipResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateCensorshipResponse) ProtoMessage 

func (*MsgUpdateCensorshipResponse) ProtoMessage()

func (*MsgUpdateCensorshipResponse) Reset 

func (m *MsgUpdateCensorshipResponse) Reset()

func (*MsgUpdateCensorshipResponse) Size 

func (m *MsgUpdateCensorshipResponse) Size() (n int)

func (*MsgUpdateCensorshipResponse) String 

func (m *MsgUpdateCensorshipResponse) String() string

func (*MsgUpdateCensorshipResponse) Unmarshal 

func (m *MsgUpdateCensorshipResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateCensorshipResponse) XXX_DiscardUnknown 

func (m *MsgUpdateCensorshipResponse) XXX_DiscardUnknown()

func (*MsgUpdateCensorshipResponse) XXX_Marshal 

func (m *MsgUpdateCensorshipResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateCensorshipResponse) XXX_Merge 

func (m *MsgUpdateCensorshipResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateCensorshipResponse) XXX_Size 

func (m *MsgUpdateCensorshipResponse) XXX_Size() int

func (*MsgUpdateCensorshipResponse) XXX_Unmarshal 

func (m *MsgUpdateCensorshipResponse) XXX_Unmarshal(b []byte) error

type MsgUpdateDecisionPolicy 

type MsgUpdateDecisionPolicy struct {
	// authority is the address of the privileged account.
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// decision_policy is the updated decision policy.
	DecisionPolicy *types1.Any `protobuf:"bytes,2,opt,name=decision_policy,json=decisionPolicy,proto3" json:"decision_policy,omitempty"`
}

MsgUpdateDecisionPolicy is the Msg/UpdateDecisionPolicy request type.

func (*MsgUpdateDecisionPolicy) Descriptor 

func (*MsgUpdateDecisionPolicy) Descriptor() ([]byte, []int)

func (MsgUpdateDecisionPolicy) GetDecisionPolicy 

func (m MsgUpdateDecisionPolicy) GetDecisionPolicy() DecisionPolicy

func (MsgUpdateDecisionPolicy) GetSignBytes 

func (m MsgUpdateDecisionPolicy) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgUpdateDecisionPolicy) GetSigners 

func (m MsgUpdateDecisionPolicy) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgUpdateDecisionPolicy) Marshal 

func (m *MsgUpdateDecisionPolicy) Marshal() (dAtA []byte, err error)

func (*MsgUpdateDecisionPolicy) MarshalTo 

func (m *MsgUpdateDecisionPolicy) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateDecisionPolicy) MarshalToSizedBuffer 

func (m *MsgUpdateDecisionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateDecisionPolicy) ProtoMessage 

func (*MsgUpdateDecisionPolicy) ProtoMessage()

func (*MsgUpdateDecisionPolicy) Reset 

func (m *MsgUpdateDecisionPolicy) Reset()

func (MsgUpdateDecisionPolicy) Route 

func (m MsgUpdateDecisionPolicy) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgUpdateDecisionPolicy) SetDecisionPolicy 

func (m *MsgUpdateDecisionPolicy) SetDecisionPolicy(policy DecisionPolicy) error

func (*MsgUpdateDecisionPolicy) Size 

func (m *MsgUpdateDecisionPolicy) Size() (n int)

func (*MsgUpdateDecisionPolicy) String 

func (m *MsgUpdateDecisionPolicy) String() string

func (MsgUpdateDecisionPolicy) Type 

func (m MsgUpdateDecisionPolicy) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgUpdateDecisionPolicy) Unmarshal 

func (m *MsgUpdateDecisionPolicy) Unmarshal(dAtA []byte) error

func (MsgUpdateDecisionPolicy) UnpackInterfaces 

func (m MsgUpdateDecisionPolicy) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (MsgUpdateDecisionPolicy) ValidateBasic 

func (m MsgUpdateDecisionPolicy) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgUpdateDecisionPolicy) XXX_DiscardUnknown 

func (m *MsgUpdateDecisionPolicy) XXX_DiscardUnknown()

func (*MsgUpdateDecisionPolicy) XXX_Marshal 

func (m *MsgUpdateDecisionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateDecisionPolicy) XXX_Merge 

func (m *MsgUpdateDecisionPolicy) XXX_Merge(src proto.Message)

func (*MsgUpdateDecisionPolicy) XXX_Size 

func (m *MsgUpdateDecisionPolicy) XXX_Size() int

func (*MsgUpdateDecisionPolicy) XXX_Unmarshal 

func (m *MsgUpdateDecisionPolicy) XXX_Unmarshal(b []byte) error

type MsgUpdateDecisionPolicyResponse 

type MsgUpdateDecisionPolicyResponse struct {
}

MsgUpdateDecisionPolicyResponse is the Msg/UpdateDecisionPolicy response type.

func (*MsgUpdateDecisionPolicyResponse) Descriptor 

func (*MsgUpdateDecisionPolicyResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateDecisionPolicyResponse) Marshal 

func (m *MsgUpdateDecisionPolicyResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateDecisionPolicyResponse) MarshalTo 

func (m *MsgUpdateDecisionPolicyResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateDecisionPolicyResponse) MarshalToSizedBuffer 

func (m *MsgUpdateDecisionPolicyResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateDecisionPolicyResponse) ProtoMessage 

func (*MsgUpdateDecisionPolicyResponse) ProtoMessage()

func (*MsgUpdateDecisionPolicyResponse) Reset 

func (m *MsgUpdateDecisionPolicyResponse) Reset()

func (*MsgUpdateDecisionPolicyResponse) Size 

func (m *MsgUpdateDecisionPolicyResponse) Size() (n int)

func (*MsgUpdateDecisionPolicyResponse) String 

func (m *MsgUpdateDecisionPolicyResponse) String() string

func (*MsgUpdateDecisionPolicyResponse) Unmarshal 

func (m *MsgUpdateDecisionPolicyResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateDecisionPolicyResponse) XXX_DiscardUnknown 

func (m *MsgUpdateDecisionPolicyResponse) XXX_DiscardUnknown()

func (*MsgUpdateDecisionPolicyResponse) XXX_Marshal 

func (m *MsgUpdateDecisionPolicyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateDecisionPolicyResponse) XXX_Merge 

func (m *MsgUpdateDecisionPolicyResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateDecisionPolicyResponse) XXX_Size 

func (m *MsgUpdateDecisionPolicyResponse) XXX_Size() int

func (*MsgUpdateDecisionPolicyResponse) XXX_Unmarshal 

func (m *MsgUpdateDecisionPolicyResponse) XXX_Unmarshal(b []byte) error

type MsgUpdateMembers 

type MsgUpdateMembers struct {
	// authority is the address of the privileged account.
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// member_updates is the list of members to update,
	// set remove to true to remove a member.
	MemberUpdates []MemberRequest `protobuf:"bytes,2,rep,name=member_updates,json=memberUpdates,proto3" json:"member_updates"`
}

MsgUpdateMembers is the Msg/UpdateMembers request type.

func (*MsgUpdateMembers) Descriptor 

func (*MsgUpdateMembers) Descriptor() ([]byte, []int)

func (MsgUpdateMembers) GetSignBytes 

func (m MsgUpdateMembers) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgUpdateMembers) GetSigners 

func (m MsgUpdateMembers) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgUpdateMembers) Marshal 

func (m *MsgUpdateMembers) Marshal() (dAtA []byte, err error)

func (*MsgUpdateMembers) MarshalTo 

func (m *MsgUpdateMembers) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateMembers) MarshalToSizedBuffer 

func (m *MsgUpdateMembers) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateMembers) ProtoMessage 

func (*MsgUpdateMembers) ProtoMessage()

func (*MsgUpdateMembers) Reset 

func (m *MsgUpdateMembers) Reset()

func (MsgUpdateMembers) Route 

func (m MsgUpdateMembers) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgUpdateMembers) Size 

func (m *MsgUpdateMembers) Size() (n int)

func (*MsgUpdateMembers) String 

func (m *MsgUpdateMembers) String() string

func (MsgUpdateMembers) Type 

func (m MsgUpdateMembers) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgUpdateMembers) Unmarshal 

func (m *MsgUpdateMembers) Unmarshal(dAtA []byte) error

func (MsgUpdateMembers) ValidateBasic 

func (m MsgUpdateMembers) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgUpdateMembers) XXX_DiscardUnknown 

func (m *MsgUpdateMembers) XXX_DiscardUnknown()

func (*MsgUpdateMembers) XXX_Marshal 

func (m *MsgUpdateMembers) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateMembers) XXX_Merge 

func (m *MsgUpdateMembers) XXX_Merge(src proto.Message)

func (*MsgUpdateMembers) XXX_Size 

func (m *MsgUpdateMembers) XXX_Size() int

func (*MsgUpdateMembers) XXX_Unmarshal 

func (m *MsgUpdateMembers) XXX_Unmarshal(b []byte) error

type MsgUpdateMembersResponse 

type MsgUpdateMembersResponse struct {
}

MsgUpdateMembersResponse is the Msg/UpdateMembers response type.

func (*MsgUpdateMembersResponse) Descriptor 

func (*MsgUpdateMembersResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateMembersResponse) Marshal 

func (m *MsgUpdateMembersResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateMembersResponse) MarshalTo 

func (m *MsgUpdateMembersResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateMembersResponse) MarshalToSizedBuffer 

func (m *MsgUpdateMembersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateMembersResponse) ProtoMessage 

func (*MsgUpdateMembersResponse) ProtoMessage()

func (*MsgUpdateMembersResponse) Reset 

func (m *MsgUpdateMembersResponse) Reset()

func (*MsgUpdateMembersResponse) Size 

func (m *MsgUpdateMembersResponse) Size() (n int)

func (*MsgUpdateMembersResponse) String 

func (m *MsgUpdateMembersResponse) String() string

func (*MsgUpdateMembersResponse) Unmarshal 

func (m *MsgUpdateMembersResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateMembersResponse) XXX_DiscardUnknown 

func (m *MsgUpdateMembersResponse) XXX_DiscardUnknown()

func (*MsgUpdateMembersResponse) XXX_Marshal 

func (m *MsgUpdateMembersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateMembersResponse) XXX_Merge 

func (m *MsgUpdateMembersResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateMembersResponse) XXX_Size 

func (m *MsgUpdateMembersResponse) XXX_Size() int

func (*MsgUpdateMembersResponse) XXX_Unmarshal 

func (m *MsgUpdateMembersResponse) XXX_Unmarshal(b []byte) error

type MsgUpdateParams 

type MsgUpdateParams struct {
	// authority is the address of the privileged account.
	Authority string `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	// params defines the x/foundation parameters to update.
	//
	// NOTE: All parameters must be supplied.
	Params Params `protobuf:"bytes,2,opt,name=params,proto3" json:"params"`
}

MsgUpdateParams is the Msg/UpdateParams request type.

func (*MsgUpdateParams) Descriptor 

func (*MsgUpdateParams) Descriptor() ([]byte, []int)

func (MsgUpdateParams) GetSignBytes 

func (m MsgUpdateParams) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgUpdateParams) GetSigners 

func (m MsgUpdateParams) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgUpdateParams) Marshal 

func (m *MsgUpdateParams) Marshal() (dAtA []byte, err error)

func (*MsgUpdateParams) MarshalTo 

func (m *MsgUpdateParams) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateParams) MarshalToSizedBuffer 

func (m *MsgUpdateParams) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateParams) ProtoMessage 

func (*MsgUpdateParams) ProtoMessage()

func (*MsgUpdateParams) Reset 

func (m *MsgUpdateParams) Reset()

func (MsgUpdateParams) Route 

func (m MsgUpdateParams) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgUpdateParams) Size 

func (m *MsgUpdateParams) Size() (n int)

func (*MsgUpdateParams) String 

func (m *MsgUpdateParams) String() string

func (MsgUpdateParams) Type 

func (m MsgUpdateParams) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgUpdateParams) Unmarshal 

func (m *MsgUpdateParams) Unmarshal(dAtA []byte) error

func (MsgUpdateParams) ValidateBasic 

func (m MsgUpdateParams) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgUpdateParams) XXX_DiscardUnknown 

func (m *MsgUpdateParams) XXX_DiscardUnknown()

func (*MsgUpdateParams) XXX_Marshal 

func (m *MsgUpdateParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateParams) XXX_Merge 

func (m *MsgUpdateParams) XXX_Merge(src proto.Message)

func (*MsgUpdateParams) XXX_Size 

func (m *MsgUpdateParams) XXX_Size() int

func (*MsgUpdateParams) XXX_Unmarshal 

func (m *MsgUpdateParams) XXX_Unmarshal(b []byte) error

type MsgUpdateParamsResponse 

type MsgUpdateParamsResponse struct {
}

MsgUpdateParamsResponse is the Msg/UpdateParams response type.

func (*MsgUpdateParamsResponse) Descriptor 

func (*MsgUpdateParamsResponse) Descriptor() ([]byte, []int)

func (*MsgUpdateParamsResponse) Marshal 

func (m *MsgUpdateParamsResponse) Marshal() (dAtA []byte, err error)

func (*MsgUpdateParamsResponse) MarshalTo 

func (m *MsgUpdateParamsResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgUpdateParamsResponse) MarshalToSizedBuffer 

func (m *MsgUpdateParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgUpdateParamsResponse) ProtoMessage 

func (*MsgUpdateParamsResponse) ProtoMessage()

func (*MsgUpdateParamsResponse) Reset 

func (m *MsgUpdateParamsResponse) Reset()

func (*MsgUpdateParamsResponse) Size 

func (m *MsgUpdateParamsResponse) Size() (n int)

func (*MsgUpdateParamsResponse) String 

func (m *MsgUpdateParamsResponse) String() string

func (*MsgUpdateParamsResponse) Unmarshal 

func (m *MsgUpdateParamsResponse) Unmarshal(dAtA []byte) error

func (*MsgUpdateParamsResponse) XXX_DiscardUnknown 

func (m *MsgUpdateParamsResponse) XXX_DiscardUnknown()

func (*MsgUpdateParamsResponse) XXX_Marshal 

func (m *MsgUpdateParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgUpdateParamsResponse) XXX_Merge 

func (m *MsgUpdateParamsResponse) XXX_Merge(src proto.Message)

func (*MsgUpdateParamsResponse) XXX_Size 

func (m *MsgUpdateParamsResponse) XXX_Size() int

func (*MsgUpdateParamsResponse) XXX_Unmarshal 

func (m *MsgUpdateParamsResponse) XXX_Unmarshal(b []byte) error

type MsgVote 

type MsgVote struct {
	// proposal is the unique ID of the proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	// voter is the voter account address.
	Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
	// option is the voter's choice on the proposal.
	Option VoteOption `protobuf:"varint,3,opt,name=option,proto3,enum=lbm.foundation.v1.VoteOption" json:"option,omitempty"`
	// metadata is any arbitrary metadata to attached to the vote.
	Metadata string `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// exec defines whether the proposal should be executed
	// immediately after voting or not.
	Exec Exec `protobuf:"varint,5,opt,name=exec,proto3,enum=lbm.foundation.v1.Exec" json:"exec,omitempty"`
}

MsgVote is the Msg/Vote request type.

func (*MsgVote) Descriptor 

func (*MsgVote) Descriptor() ([]byte, []int)

func (MsgVote) GetSignBytes 

func (m MsgVote) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgVote) GetSigners 

func (m MsgVote) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgVote) Marshal 

func (m *MsgVote) Marshal() (dAtA []byte, err error)

func (*MsgVote) MarshalTo 

func (m *MsgVote) MarshalTo(dAtA []byte) (int, error)

func (*MsgVote) MarshalToSizedBuffer 

func (m *MsgVote) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgVote) ProtoMessage 

func (*MsgVote) ProtoMessage()

func (*MsgVote) Reset 

func (m *MsgVote) Reset()

func (MsgVote) Route 

func (m MsgVote) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgVote) Size 

func (m *MsgVote) Size() (n int)

func (*MsgVote) String 

func (m *MsgVote) String() string

func (MsgVote) Type 

func (m MsgVote) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgVote) Unmarshal 

func (m *MsgVote) Unmarshal(dAtA []byte) error

func (MsgVote) ValidateBasic 

func (m MsgVote) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgVote) XXX_DiscardUnknown 

func (m *MsgVote) XXX_DiscardUnknown()

func (*MsgVote) XXX_Marshal 

func (m *MsgVote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgVote) XXX_Merge 

func (m *MsgVote) XXX_Merge(src proto.Message)

func (*MsgVote) XXX_Size 

func (m *MsgVote) XXX_Size() int

func (*MsgVote) XXX_Unmarshal 

func (m *MsgVote) XXX_Unmarshal(b []byte) error

type MsgVoteResponse 

type MsgVoteResponse struct {
}

MsgVoteResponse is the Msg/Vote response type.

func (*MsgVoteResponse) Descriptor 

func (*MsgVoteResponse) Descriptor() ([]byte, []int)

func (*MsgVoteResponse) Marshal 

func (m *MsgVoteResponse) Marshal() (dAtA []byte, err error)

func (*MsgVoteResponse) MarshalTo 

func (m *MsgVoteResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgVoteResponse) MarshalToSizedBuffer 

func (m *MsgVoteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgVoteResponse) ProtoMessage 

func (*MsgVoteResponse) ProtoMessage()

func (*MsgVoteResponse) Reset 

func (m *MsgVoteResponse) Reset()

func (*MsgVoteResponse) Size 

func (m *MsgVoteResponse) Size() (n int)

func (*MsgVoteResponse) String 

func (m *MsgVoteResponse) String() string

func (*MsgVoteResponse) Unmarshal 

func (m *MsgVoteResponse) Unmarshal(dAtA []byte) error

func (*MsgVoteResponse) XXX_DiscardUnknown 

func (m *MsgVoteResponse) XXX_DiscardUnknown()

func (*MsgVoteResponse) XXX_Marshal 

func (m *MsgVoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgVoteResponse) XXX_Merge 

func (m *MsgVoteResponse) XXX_Merge(src proto.Message)

func (*MsgVoteResponse) XXX_Size 

func (m *MsgVoteResponse) XXX_Size() int

func (*MsgVoteResponse) XXX_Unmarshal 

func (m *MsgVoteResponse) XXX_Unmarshal(b []byte) error

type MsgWithdrawFromTreasury 

type MsgWithdrawFromTreasury struct {
	// authority is the address of the privileged account.
	Authority string                                          `protobuf:"bytes,1,opt,name=authority,proto3" json:"authority,omitempty"`
	To        string                                          `protobuf:"bytes,2,opt,name=to,proto3" json:"to,omitempty"`
	Amount    github_com_PikeEcosystem_cosmos_sdk_types.Coins `protobuf:"bytes,3,rep,name=amount,proto3,castrepeated=github.com/PikeEcosystem/cosmos-sdk/types.Coins" json:"amount"`
}

MsgWithdrawFromTreasury is the Msg/WithdrawFromTreasury request type.

func (*MsgWithdrawFromTreasury) Descriptor 

func (*MsgWithdrawFromTreasury) Descriptor() ([]byte, []int)

func (MsgWithdrawFromTreasury) GetSignBytes 

func (m MsgWithdrawFromTreasury) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgWithdrawFromTreasury) GetSigners 

func (m MsgWithdrawFromTreasury) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgWithdrawFromTreasury) Marshal 

func (m *MsgWithdrawFromTreasury) Marshal() (dAtA []byte, err error)

func (*MsgWithdrawFromTreasury) MarshalTo 

func (m *MsgWithdrawFromTreasury) MarshalTo(dAtA []byte) (int, error)

func (*MsgWithdrawFromTreasury) MarshalToSizedBuffer 

func (m *MsgWithdrawFromTreasury) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgWithdrawFromTreasury) ProtoMessage 

func (*MsgWithdrawFromTreasury) ProtoMessage()

func (*MsgWithdrawFromTreasury) Reset 

func (m *MsgWithdrawFromTreasury) Reset()

func (MsgWithdrawFromTreasury) Route 

func (m MsgWithdrawFromTreasury) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgWithdrawFromTreasury) Size 

func (m *MsgWithdrawFromTreasury) Size() (n int)

func (*MsgWithdrawFromTreasury) String 

func (m *MsgWithdrawFromTreasury) String() string

func (MsgWithdrawFromTreasury) Type 

func (m MsgWithdrawFromTreasury) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgWithdrawFromTreasury) Unmarshal 

func (m *MsgWithdrawFromTreasury) Unmarshal(dAtA []byte) error

func (MsgWithdrawFromTreasury) ValidateBasic 

func (m MsgWithdrawFromTreasury) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgWithdrawFromTreasury) XXX_DiscardUnknown 

func (m *MsgWithdrawFromTreasury) XXX_DiscardUnknown()

func (*MsgWithdrawFromTreasury) XXX_Marshal 

func (m *MsgWithdrawFromTreasury) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgWithdrawFromTreasury) XXX_Merge 

func (m *MsgWithdrawFromTreasury) XXX_Merge(src proto.Message)

func (*MsgWithdrawFromTreasury) XXX_Size 

func (m *MsgWithdrawFromTreasury) XXX_Size() int

func (*MsgWithdrawFromTreasury) XXX_Unmarshal 

func (m *MsgWithdrawFromTreasury) XXX_Unmarshal(b []byte) error

type MsgWithdrawFromTreasuryResponse 

type MsgWithdrawFromTreasuryResponse struct {
}

MsgWithdrawFromTreasuryResponse is the Msg/WithdrawFromTreasury response type.

func (*MsgWithdrawFromTreasuryResponse) Descriptor 

func (*MsgWithdrawFromTreasuryResponse) Descriptor() ([]byte, []int)

func (*MsgWithdrawFromTreasuryResponse) Marshal 

func (m *MsgWithdrawFromTreasuryResponse) Marshal() (dAtA []byte, err error)

func (*MsgWithdrawFromTreasuryResponse) MarshalTo 

func (m *MsgWithdrawFromTreasuryResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgWithdrawFromTreasuryResponse) MarshalToSizedBuffer 

func (m *MsgWithdrawFromTreasuryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgWithdrawFromTreasuryResponse) ProtoMessage 

func (*MsgWithdrawFromTreasuryResponse) ProtoMessage()

func (*MsgWithdrawFromTreasuryResponse) Reset 

func (m *MsgWithdrawFromTreasuryResponse) Reset()

func (*MsgWithdrawFromTreasuryResponse) Size 

func (m *MsgWithdrawFromTreasuryResponse) Size() (n int)

func (*MsgWithdrawFromTreasuryResponse) String 

func (m *MsgWithdrawFromTreasuryResponse) String() string

func (*MsgWithdrawFromTreasuryResponse) Unmarshal 

func (m *MsgWithdrawFromTreasuryResponse) Unmarshal(dAtA []byte) error

func (*MsgWithdrawFromTreasuryResponse) XXX_DiscardUnknown 

func (m *MsgWithdrawFromTreasuryResponse) XXX_DiscardUnknown()

func (*MsgWithdrawFromTreasuryResponse) XXX_Marshal 

func (m *MsgWithdrawFromTreasuryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgWithdrawFromTreasuryResponse) XXX_Merge 

func (m *MsgWithdrawFromTreasuryResponse) XXX_Merge(src proto.Message)

func (*MsgWithdrawFromTreasuryResponse) XXX_Size 

func (m *MsgWithdrawFromTreasuryResponse) XXX_Size() int

func (*MsgWithdrawFromTreasuryResponse) XXX_Unmarshal 

func (m *MsgWithdrawFromTreasuryResponse) XXX_Unmarshal(b []byte) error

type MsgWithdrawProposal 

type MsgWithdrawProposal struct {
	// proposal is the unique ID of the proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	// address of one of the proposer of the proposal.
	Address string `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
}

MsgWithdrawProposal is the Msg/WithdrawProposal request type.

func (*MsgWithdrawProposal) Descriptor 

func (*MsgWithdrawProposal) Descriptor() ([]byte, []int)

func (MsgWithdrawProposal) GetSignBytes 

func (m MsgWithdrawProposal) GetSignBytes() []byte

GetSignBytes implements the LegacyMsg.GetSignBytes method.

func (MsgWithdrawProposal) GetSigners 

func (m MsgWithdrawProposal) GetSigners() []sdk.AccAddress

GetSigners implements Msg.

func (*MsgWithdrawProposal) Marshal 

func (m *MsgWithdrawProposal) Marshal() (dAtA []byte, err error)

func (*MsgWithdrawProposal) MarshalTo 

func (m *MsgWithdrawProposal) MarshalTo(dAtA []byte) (int, error)

func (*MsgWithdrawProposal) MarshalToSizedBuffer 

func (m *MsgWithdrawProposal) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgWithdrawProposal) ProtoMessage 

func (*MsgWithdrawProposal) ProtoMessage()

func (*MsgWithdrawProposal) Reset 

func (m *MsgWithdrawProposal) Reset()

func (MsgWithdrawProposal) Route 

func (m MsgWithdrawProposal) Route() string

Route implements the LegacyMsg.Route method.

func (*MsgWithdrawProposal) Size 

func (m *MsgWithdrawProposal) Size() (n int)

func (*MsgWithdrawProposal) String 

func (m *MsgWithdrawProposal) String() string

func (MsgWithdrawProposal) Type 

func (m MsgWithdrawProposal) Type() string

Type implements the LegacyMsg.Type method.

func (*MsgWithdrawProposal) Unmarshal 

func (m *MsgWithdrawProposal) Unmarshal(dAtA []byte) error

func (MsgWithdrawProposal) ValidateBasic 

func (m MsgWithdrawProposal) ValidateBasic() error

ValidateBasic implements Msg.

func (*MsgWithdrawProposal) XXX_DiscardUnknown 

func (m *MsgWithdrawProposal) XXX_DiscardUnknown()

func (*MsgWithdrawProposal) XXX_Marshal 

func (m *MsgWithdrawProposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgWithdrawProposal) XXX_Merge 

func (m *MsgWithdrawProposal) XXX_Merge(src proto.Message)

func (*MsgWithdrawProposal) XXX_Size 

func (m *MsgWithdrawProposal) XXX_Size() int

func (*MsgWithdrawProposal) XXX_Unmarshal 

func (m *MsgWithdrawProposal) XXX_Unmarshal(b []byte) error

type MsgWithdrawProposalResponse 

type MsgWithdrawProposalResponse struct {
}

MsgWithdrawProposalResponse is the Msg/WithdrawProposal response type.

func (*MsgWithdrawProposalResponse) Descriptor 

func (*MsgWithdrawProposalResponse) Descriptor() ([]byte, []int)

func (*MsgWithdrawProposalResponse) Marshal 

func (m *MsgWithdrawProposalResponse) Marshal() (dAtA []byte, err error)

func (*MsgWithdrawProposalResponse) MarshalTo 

func (m *MsgWithdrawProposalResponse) MarshalTo(dAtA []byte) (int, error)

func (*MsgWithdrawProposalResponse) MarshalToSizedBuffer 

func (m *MsgWithdrawProposalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*MsgWithdrawProposalResponse) ProtoMessage 

func (*MsgWithdrawProposalResponse) ProtoMessage()

func (*MsgWithdrawProposalResponse) Reset 

func (m *MsgWithdrawProposalResponse) Reset()

func (*MsgWithdrawProposalResponse) Size 

func (m *MsgWithdrawProposalResponse) Size() (n int)

func (*MsgWithdrawProposalResponse) String 

func (m *MsgWithdrawProposalResponse) String() string

func (*MsgWithdrawProposalResponse) Unmarshal 

func (m *MsgWithdrawProposalResponse) Unmarshal(dAtA []byte) error

func (*MsgWithdrawProposalResponse) XXX_DiscardUnknown 

func (m *MsgWithdrawProposalResponse) XXX_DiscardUnknown()

func (*MsgWithdrawProposalResponse) XXX_Marshal 

func (m *MsgWithdrawProposalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*MsgWithdrawProposalResponse) XXX_Merge 

func (m *MsgWithdrawProposalResponse) XXX_Merge(src proto.Message)

func (*MsgWithdrawProposalResponse) XXX_Size 

func (m *MsgWithdrawProposalResponse) XXX_Size() int

func (*MsgWithdrawProposalResponse) XXX_Unmarshal 

func (m *MsgWithdrawProposalResponse) XXX_Unmarshal(b []byte) error

type OutsourcingDecisionPolicy 

type OutsourcingDecisionPolicy struct {
	Description string `protobuf:"bytes,1,opt,name=description,proto3" json:"description,omitempty"`
}

OutsourcingDecisionPolicy is a dummy decision policy which is set after the proposal feature has been outsourced to x/group.

func (OutsourcingDecisionPolicy) Allow 

func (p OutsourcingDecisionPolicy) Allow(result TallyResult, totalWeight sdk.Dec, sinceSubmission time.Duration) (*DecisionPolicyResult, error)

func (*OutsourcingDecisionPolicy) Descriptor 

func (*OutsourcingDecisionPolicy) Descriptor() ([]byte, []int)

func (*OutsourcingDecisionPolicy) Equal 

func (this *OutsourcingDecisionPolicy) Equal(that interface{}) bool

func (*OutsourcingDecisionPolicy) GetDescription 

func (m *OutsourcingDecisionPolicy) GetDescription() string

func (OutsourcingDecisionPolicy) GetVotingPeriod 

func (p OutsourcingDecisionPolicy) GetVotingPeriod() time.Duration

func (*OutsourcingDecisionPolicy) Marshal 

func (m *OutsourcingDecisionPolicy) Marshal() (dAtA []byte, err error)

func (*OutsourcingDecisionPolicy) MarshalTo 

func (m *OutsourcingDecisionPolicy) MarshalTo(dAtA []byte) (int, error)

func (*OutsourcingDecisionPolicy) MarshalToSizedBuffer 

func (m *OutsourcingDecisionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*OutsourcingDecisionPolicy) ProtoMessage 

func (*OutsourcingDecisionPolicy) ProtoMessage()

func (*OutsourcingDecisionPolicy) Reset 

func (m *OutsourcingDecisionPolicy) Reset()

func (*OutsourcingDecisionPolicy) Size 

func (m *OutsourcingDecisionPolicy) Size() (n int)

func (*OutsourcingDecisionPolicy) String 

func (m *OutsourcingDecisionPolicy) String() string

func (*OutsourcingDecisionPolicy) Unmarshal 

func (m *OutsourcingDecisionPolicy) Unmarshal(dAtA []byte) error

func (OutsourcingDecisionPolicy) Validate 

func (p OutsourcingDecisionPolicy) Validate(info FoundationInfo, config Config) error

func (OutsourcingDecisionPolicy) ValidateBasic 

func (p OutsourcingDecisionPolicy) ValidateBasic() error

func (*OutsourcingDecisionPolicy) XXX_DiscardUnknown 

func (m *OutsourcingDecisionPolicy) XXX_DiscardUnknown()

func (*OutsourcingDecisionPolicy) XXX_Marshal 

func (m *OutsourcingDecisionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*OutsourcingDecisionPolicy) XXX_Merge 

func (m *OutsourcingDecisionPolicy) XXX_Merge(src proto.Message)

func (*OutsourcingDecisionPolicy) XXX_Size 

func (m *OutsourcingDecisionPolicy) XXX_Size() int

func (*OutsourcingDecisionPolicy) XXX_Unmarshal 

func (m *OutsourcingDecisionPolicy) XXX_Unmarshal(b []byte) error

type Params 

type Params struct {
	FoundationTax github_com_PikeEcosystem_cosmos_sdk_types.Dec `` /* 147-byte string literal not displayed */
}

Params defines the parameters for the foundation module.

func DefaultParams 

func DefaultParams() Params

func (*Params) Descriptor 

func (*Params) Descriptor() ([]byte, []int)

func (*Params) Equal 

func (this *Params) Equal(that interface{}) bool

func (*Params) Marshal 

func (m *Params) Marshal() (dAtA []byte, err error)

func (*Params) MarshalTo 

func (m *Params) MarshalTo(dAtA []byte) (int, error)

func (*Params) MarshalToSizedBuffer 

func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Params) ProtoMessage 

func (*Params) ProtoMessage()

func (*Params) Reset 

func (m *Params) Reset()

func (*Params) Size 

func (m *Params) Size() (n int)

func (*Params) String 

func (m *Params) String() string

func (*Params) Unmarshal 

func (m *Params) Unmarshal(dAtA []byte) error

func (Params) ValidateBasic 

func (p Params) ValidateBasic() error

func (*Params) XXX_DiscardUnknown 

func (m *Params) XXX_DiscardUnknown()

func (*Params) XXX_Marshal 

func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Params) XXX_Merge 

func (m *Params) XXX_Merge(src proto.Message)

func (*Params) XXX_Size 

func (m *Params) XXX_Size() int

func (*Params) XXX_Unmarshal 

func (m *Params) XXX_Unmarshal(b []byte) error

type PercentageDecisionPolicy 

type PercentageDecisionPolicy struct {
	// percentage is the minimum percentage the sum of yes votes must meet for a proposal to succeed.
	Percentage github_com_PikeEcosystem_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=percentage,proto3,customtype=github.com/PikeEcosystem/cosmos-sdk/types.Dec" json:"percentage"`
	// windows defines the different windows for voting and execution.
	Windows *DecisionPolicyWindows `protobuf:"bytes,2,opt,name=windows,proto3" json:"windows,omitempty"`
}

PercentageDecisionPolicy is a decision policy where a proposal passes when it satisfies the two following conditions:

  1. The percentage of all `YES` voters' weights out of the total group weight is greater or equal than the given `percentage`.
  2. The voting and execution periods of the proposal respect the parameters given by `windows`.

func (PercentageDecisionPolicy) Allow 

func (p PercentageDecisionPolicy) Allow(result TallyResult, totalWeight sdk.Dec, sinceSubmission time.Duration) (*DecisionPolicyResult, error)

func (*PercentageDecisionPolicy) Descriptor 

func (*PercentageDecisionPolicy) Descriptor() ([]byte, []int)

func (*PercentageDecisionPolicy) Equal 

func (this *PercentageDecisionPolicy) Equal(that interface{}) bool

func (PercentageDecisionPolicy) GetVotingPeriod 

func (p PercentageDecisionPolicy) GetVotingPeriod() time.Duration

func (*PercentageDecisionPolicy) GetWindows 

func (m *PercentageDecisionPolicy) GetWindows() *DecisionPolicyWindows

func (*PercentageDecisionPolicy) Marshal 

func (m *PercentageDecisionPolicy) Marshal() (dAtA []byte, err error)

func (*PercentageDecisionPolicy) MarshalTo 

func (m *PercentageDecisionPolicy) MarshalTo(dAtA []byte) (int, error)

func (*PercentageDecisionPolicy) MarshalToSizedBuffer 

func (m *PercentageDecisionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*PercentageDecisionPolicy) ProtoMessage 

func (*PercentageDecisionPolicy) ProtoMessage()

func (*PercentageDecisionPolicy) Reset 

func (m *PercentageDecisionPolicy) Reset()

func (*PercentageDecisionPolicy) Size 

func (m *PercentageDecisionPolicy) Size() (n int)

func (*PercentageDecisionPolicy) String 

func (m *PercentageDecisionPolicy) String() string

func (*PercentageDecisionPolicy) Unmarshal 

func (m *PercentageDecisionPolicy) Unmarshal(dAtA []byte) error

func (PercentageDecisionPolicy) Validate 

func (p PercentageDecisionPolicy) Validate(info FoundationInfo, config Config) error

func (PercentageDecisionPolicy) ValidateBasic 

func (p PercentageDecisionPolicy) ValidateBasic() error

func (*PercentageDecisionPolicy) XXX_DiscardUnknown 

func (m *PercentageDecisionPolicy) XXX_DiscardUnknown()

func (*PercentageDecisionPolicy) XXX_Marshal 

func (m *PercentageDecisionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*PercentageDecisionPolicy) XXX_Merge 

func (m *PercentageDecisionPolicy) XXX_Merge(src proto.Message)

func (*PercentageDecisionPolicy) XXX_Size 

func (m *PercentageDecisionPolicy) XXX_Size() int

func (*PercentageDecisionPolicy) XXX_Unmarshal 

func (m *PercentageDecisionPolicy) XXX_Unmarshal(b []byte) error

type Pool 

type Pool struct {
	Treasury github_com_PikeEcosystem_cosmos_sdk_types.DecCoins `protobuf:"bytes,1,rep,name=treasury,proto3,castrepeated=github.com/PikeEcosystem/cosmos-sdk/types.DecCoins" json:"treasury"`
}

Pool is used for tracking treasury.

func (*Pool) Descriptor 

func (*Pool) Descriptor() ([]byte, []int)

func (*Pool) Equal 

func (this *Pool) Equal(that interface{}) bool

func (*Pool) GetTreasury 

func (m *Pool) GetTreasury() github_com_PikeEcosystem_cosmos_sdk_types.DecCoins

func (*Pool) Marshal 

func (m *Pool) Marshal() (dAtA []byte, err error)

func (*Pool) MarshalTo 

func (m *Pool) MarshalTo(dAtA []byte) (int, error)

func (*Pool) MarshalToSizedBuffer 

func (m *Pool) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Pool) ProtoMessage 

func (*Pool) ProtoMessage()

func (*Pool) Reset 

func (m *Pool) Reset()

func (*Pool) Size 

func (m *Pool) Size() (n int)

func (*Pool) String 

func (m *Pool) String() string

func (*Pool) Unmarshal 

func (m *Pool) Unmarshal(dAtA []byte) error

func (Pool) ValidateBasic 

func (p Pool) ValidateBasic() error

func (*Pool) XXX_DiscardUnknown 

func (m *Pool) XXX_DiscardUnknown()

func (*Pool) XXX_Marshal 

func (m *Pool) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Pool) XXX_Merge 

func (m *Pool) XXX_Merge(src proto.Message)

func (*Pool) XXX_Size 

func (m *Pool) XXX_Size() int

func (*Pool) XXX_Unmarshal 

func (m *Pool) XXX_Unmarshal(b []byte) error

type Proposal 

type Proposal struct {
	// id is the unique id of the proposal.
	Id uint64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// metadata is any arbitrary metadata to attached to the proposal.
	Metadata string `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// proposers are the account addresses of the proposers.
	Proposers []string `protobuf:"bytes,3,rep,name=proposers,proto3" json:"proposers,omitempty"`
	// submit_time is a timestamp specifying when a proposal was submitted.
	SubmitTime time.Time `protobuf:"bytes,4,opt,name=submit_time,json=submitTime,proto3,stdtime" json:"submit_time"`
	// foundation_version tracks the version of the foundation that this proposal corresponds to.
	// When foundation info is changed, existing proposals from previous foundation versions will become invalid.
	FoundationVersion uint64 `protobuf:"varint,5,opt,name=foundation_version,json=foundationVersion,proto3" json:"foundation_version,omitempty"`
	// status represents the high level position in the life cycle of the proposal. Initial value is Submitted.
	Status ProposalStatus `protobuf:"varint,6,opt,name=status,proto3,enum=lbm.foundation.v1.ProposalStatus" json:"status,omitempty"`
	// final_tally_result contains the sums of all votes for this
	// proposal for each vote option, after tallying. When querying a proposal
	// via gRPC, this field is not populated until the proposal's voting period
	// has ended.
	FinalTallyResult TallyResult `protobuf:"bytes,7,opt,name=final_tally_result,json=finalTallyResult,proto3" json:"final_tally_result"`
	// voting_period_end is the timestamp before which voting must be done.
	// Unless a successfull MsgExec is called before (to execute a proposal whose
	// tally is successful before the voting period ends), tallying will be done
	// at this point, and the `final_tally_result`, as well
	// as `status` and `result` fields will be accordingly updated.
	VotingPeriodEnd time.Time `protobuf:"bytes,8,opt,name=voting_period_end,json=votingPeriodEnd,proto3,stdtime" json:"voting_period_end"`
	// executor_result is the final result based on the votes and election rule. Initial value is NotRun.
	ExecutorResult ProposalExecutorResult `` /* 150-byte string literal not displayed */
	// messages is a list of Msgs that will be executed if the proposal passes.
	Messages []*types.Any `protobuf:"bytes,10,rep,name=messages,proto3" json:"messages,omitempty"`
}

Proposal defines a foundation proposal. Any member of the foundation can submit a proposal for a group policy to decide upon. A proposal consists of a set of `sdk.Msg`s that will be executed if the proposal passes as well as some optional metadata associated with the proposal.

func (*Proposal) Descriptor 

func (*Proposal) Descriptor() ([]byte, []int)

func (*Proposal) Equal 

func (this *Proposal) Equal(that interface{}) bool

func (*Proposal) GetMsgs 

func (p *Proposal) GetMsgs() []sdk.Msg

func (*Proposal) Marshal 

func (m *Proposal) Marshal() (dAtA []byte, err error)

func (*Proposal) MarshalTo 

func (m *Proposal) MarshalTo(dAtA []byte) (int, error)

func (*Proposal) MarshalToSizedBuffer 

func (m *Proposal) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Proposal) ProtoMessage 

func (*Proposal) ProtoMessage()

func (*Proposal) Reset 

func (m *Proposal) Reset()

func (*Proposal) SetMsgs 

func (p *Proposal) SetMsgs(msgs []sdk.Msg) error

func (*Proposal) Size 

func (m *Proposal) Size() (n int)

func (*Proposal) String 

func (m *Proposal) String() string

func (*Proposal) Unmarshal 

func (m *Proposal) Unmarshal(dAtA []byte) error

func (Proposal) UnpackInterfaces 

func (p Proposal) UnpackInterfaces(unpacker codectypes.AnyUnpacker) error

func (Proposal) ValidateBasic 

func (p Proposal) ValidateBasic() error

func (Proposal) WithMsgs 

func (p Proposal) WithMsgs(msgs []sdk.Msg) *Proposal

for the tests

func (*Proposal) XXX_DiscardUnknown 

func (m *Proposal) XXX_DiscardUnknown()

func (*Proposal) XXX_Marshal 

func (m *Proposal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Proposal) XXX_Merge 

func (m *Proposal) XXX_Merge(src proto.Message)

func (*Proposal) XXX_Size 

func (m *Proposal) XXX_Size() int

func (*Proposal) XXX_Unmarshal 

func (m *Proposal) XXX_Unmarshal(b []byte) error

type ProposalExecutorResult 

type ProposalExecutorResult int32

ProposalExecutorResult defines types of proposal executor results. 

const (
	// An empty value is not allowed.
	PROPOSAL_EXECUTOR_RESULT_UNSPECIFIED ProposalExecutorResult = 0
	// We have not yet run the executor.
	PROPOSAL_EXECUTOR_RESULT_NOT_RUN ProposalExecutorResult = 1
	// The executor was successful and proposed action updated state.
	PROPOSAL_EXECUTOR_RESULT_SUCCESS ProposalExecutorResult = 2
	// The executor returned an error and proposed action didn't update state.
	PROPOSAL_EXECUTOR_RESULT_FAILURE ProposalExecutorResult = 3
)

func (ProposalExecutorResult) EnumDescriptor 

func (ProposalExecutorResult) EnumDescriptor() ([]byte, []int)

func (ProposalExecutorResult) String 

func (x ProposalExecutorResult) String() string

type ProposalStatus 

type ProposalStatus int32

ProposalStatus defines proposal statuses. 

const (
	// An empty value is invalid and not allowed.
	PROPOSAL_STATUS_UNSPECIFIED ProposalStatus = 0
	// Initial status of a proposal when submitted.
	PROPOSAL_STATUS_SUBMITTED ProposalStatus = 1
	// Final status of a proposal when the final tally is done and the outcome
	// passes the foundation's decision policy.
	PROPOSAL_STATUS_ACCEPTED ProposalStatus = 2
	// Final status of a proposal when the final tally is done and the outcome
	// is rejected by the foundation's decision policy.
	PROPOSAL_STATUS_REJECTED ProposalStatus = 3
	// Final status of a proposal when the decision policy is modified before the
	// final tally.
	PROPOSAL_STATUS_ABORTED ProposalStatus = 4
	// A proposal can be withdrawn before the voting start time by the owner.
	// When this happens the final status is Withdrawn.
	PROPOSAL_STATUS_WITHDRAWN ProposalStatus = 5
)

func (ProposalStatus) EnumDescriptor 

func (ProposalStatus) EnumDescriptor() ([]byte, []int)

func (ProposalStatus) String 

func (x ProposalStatus) String() string

type QueryCensorshipsRequest 

type QueryCensorshipsRequest struct {
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryCensorshipsRequest is the request type for the Query/Censorships RPC method.

func (*QueryCensorshipsRequest) Descriptor 

func (*QueryCensorshipsRequest) Descriptor() ([]byte, []int)

func (*QueryCensorshipsRequest) GetPagination 

func (m *QueryCensorshipsRequest) GetPagination() *query.PageRequest

func (*QueryCensorshipsRequest) Marshal 

func (m *QueryCensorshipsRequest) Marshal() (dAtA []byte, err error)

func (*QueryCensorshipsRequest) MarshalTo 

func (m *QueryCensorshipsRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryCensorshipsRequest) MarshalToSizedBuffer 

func (m *QueryCensorshipsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryCensorshipsRequest) ProtoMessage 

func (*QueryCensorshipsRequest) ProtoMessage()

func (*QueryCensorshipsRequest) Reset 

func (m *QueryCensorshipsRequest) Reset()

func (*QueryCensorshipsRequest) Size 

func (m *QueryCensorshipsRequest) Size() (n int)

func (*QueryCensorshipsRequest) String 

func (m *QueryCensorshipsRequest) String() string

func (*QueryCensorshipsRequest) Unmarshal 

func (m *QueryCensorshipsRequest) Unmarshal(dAtA []byte) error

func (*QueryCensorshipsRequest) XXX_DiscardUnknown 

func (m *QueryCensorshipsRequest) XXX_DiscardUnknown()

func (*QueryCensorshipsRequest) XXX_Marshal 

func (m *QueryCensorshipsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryCensorshipsRequest) XXX_Merge 

func (m *QueryCensorshipsRequest) XXX_Merge(src proto.Message)

func (*QueryCensorshipsRequest) XXX_Size 

func (m *QueryCensorshipsRequest) XXX_Size() int

func (*QueryCensorshipsRequest) XXX_Unmarshal 

func (m *QueryCensorshipsRequest) XXX_Unmarshal(b []byte) error

type QueryCensorshipsResponse 

type QueryCensorshipsResponse struct {
	// authorizations is a list of grants granted for grantee.
	Censorships []Censorship `protobuf:"bytes,1,rep,name=censorships,proto3" json:"censorships"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryCensorshipsResponse is the response type for the Query/Censorships RPC method.

func (*QueryCensorshipsResponse) Descriptor 

func (*QueryCensorshipsResponse) Descriptor() ([]byte, []int)

func (*QueryCensorshipsResponse) GetCensorships 

func (m *QueryCensorshipsResponse) GetCensorships() []Censorship

func (*QueryCensorshipsResponse) GetPagination 

func (m *QueryCensorshipsResponse) GetPagination() *query.PageResponse

func (*QueryCensorshipsResponse) Marshal 

func (m *QueryCensorshipsResponse) Marshal() (dAtA []byte, err error)

func (*QueryCensorshipsResponse) MarshalTo 

func (m *QueryCensorshipsResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryCensorshipsResponse) MarshalToSizedBuffer 

func (m *QueryCensorshipsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryCensorshipsResponse) ProtoMessage 

func (*QueryCensorshipsResponse) ProtoMessage()

func (*QueryCensorshipsResponse) Reset 

func (m *QueryCensorshipsResponse) Reset()

func (*QueryCensorshipsResponse) Size 

func (m *QueryCensorshipsResponse) Size() (n int)

func (*QueryCensorshipsResponse) String 

func (m *QueryCensorshipsResponse) String() string

func (*QueryCensorshipsResponse) Unmarshal 

func (m *QueryCensorshipsResponse) Unmarshal(dAtA []byte) error

func (*QueryCensorshipsResponse) XXX_DiscardUnknown 

func (m *QueryCensorshipsResponse) XXX_DiscardUnknown()

func (*QueryCensorshipsResponse) XXX_Marshal 

func (m *QueryCensorshipsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryCensorshipsResponse) XXX_Merge 

func (m *QueryCensorshipsResponse) XXX_Merge(src proto.Message)

func (*QueryCensorshipsResponse) XXX_Size 

func (m *QueryCensorshipsResponse) XXX_Size() int

func (*QueryCensorshipsResponse) XXX_Unmarshal 

func (m *QueryCensorshipsResponse) XXX_Unmarshal(b []byte) error

type QueryClient 

type QueryClient interface {
	// Params queries the module params.
	Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
	// Treasury queries the foundation treasury.
	Treasury(ctx context.Context, in *QueryTreasuryRequest, opts ...grpc.CallOption) (*QueryTreasuryResponse, error)
	// FoundationInfo queries foundation info.
	FoundationInfo(ctx context.Context, in *QueryFoundationInfoRequest, opts ...grpc.CallOption) (*QueryFoundationInfoResponse, error)
	// Member queries a member of the foundation
	Member(ctx context.Context, in *QueryMemberRequest, opts ...grpc.CallOption) (*QueryMemberResponse, error)
	// Members queries members of the foundation
	Members(ctx context.Context, in *QueryMembersRequest, opts ...grpc.CallOption) (*QueryMembersResponse, error)
	// Proposal queries a proposal based on proposal id.
	Proposal(ctx context.Context, in *QueryProposalRequest, opts ...grpc.CallOption) (*QueryProposalResponse, error)
	// Proposals queries all proposals.
	Proposals(ctx context.Context, in *QueryProposalsRequest, opts ...grpc.CallOption) (*QueryProposalsResponse, error)
	// Vote queries a vote by proposal id and voter.
	Vote(ctx context.Context, in *QueryVoteRequest, opts ...grpc.CallOption) (*QueryVoteResponse, error)
	// Votes queries a vote by proposal.
	Votes(ctx context.Context, in *QueryVotesRequest, opts ...grpc.CallOption) (*QueryVotesResponse, error)
	// TallyResult queries the tally of a proposal votes.
	TallyResult(ctx context.Context, in *QueryTallyResultRequest, opts ...grpc.CallOption) (*QueryTallyResultResponse, error)
	// Censorships queries the censorship informations.
	Censorships(ctx context.Context, in *QueryCensorshipsRequest, opts ...grpc.CallOption) (*QueryCensorshipsResponse, error)
	// Returns list of authorizations, granted to the grantee.
	Grants(ctx context.Context, in *QueryGrantsRequest, opts ...grpc.CallOption) (*QueryGrantsResponse, error)
}

QueryClient is the client API for Query service.

For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

func NewQueryClient 

func NewQueryClient(cc grpc1.ClientConn) QueryClient

type QueryFoundationInfoRequest 

type QueryFoundationInfoRequest struct {
}

QueryFoundationInfoRequest is the Query/FoundationInfo request type.

func (*QueryFoundationInfoRequest) Descriptor 

func (*QueryFoundationInfoRequest) Descriptor() ([]byte, []int)

func (*QueryFoundationInfoRequest) Marshal 

func (m *QueryFoundationInfoRequest) Marshal() (dAtA []byte, err error)

func (*QueryFoundationInfoRequest) MarshalTo 

func (m *QueryFoundationInfoRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryFoundationInfoRequest) MarshalToSizedBuffer 

func (m *QueryFoundationInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryFoundationInfoRequest) ProtoMessage 

func (*QueryFoundationInfoRequest) ProtoMessage()

func (*QueryFoundationInfoRequest) Reset 

func (m *QueryFoundationInfoRequest) Reset()

func (*QueryFoundationInfoRequest) Size 

func (m *QueryFoundationInfoRequest) Size() (n int)

func (*QueryFoundationInfoRequest) String 

func (m *QueryFoundationInfoRequest) String() string

func (*QueryFoundationInfoRequest) Unmarshal 

func (m *QueryFoundationInfoRequest) Unmarshal(dAtA []byte) error

func (*QueryFoundationInfoRequest) XXX_DiscardUnknown 

func (m *QueryFoundationInfoRequest) XXX_DiscardUnknown()

func (*QueryFoundationInfoRequest) XXX_Marshal 

func (m *QueryFoundationInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryFoundationInfoRequest) XXX_Merge 

func (m *QueryFoundationInfoRequest) XXX_Merge(src proto.Message)

func (*QueryFoundationInfoRequest) XXX_Size 

func (m *QueryFoundationInfoRequest) XXX_Size() int

func (*QueryFoundationInfoRequest) XXX_Unmarshal 

func (m *QueryFoundationInfoRequest) XXX_Unmarshal(b []byte) error

type QueryFoundationInfoResponse 

type QueryFoundationInfoResponse struct {
	// info is the FoundationInfo for the foundation.
	Info FoundationInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info"`
}

QueryFoundationInfoResponse is the Query/FoundationInfo response type.

func (*QueryFoundationInfoResponse) Descriptor 

func (*QueryFoundationInfoResponse) Descriptor() ([]byte, []int)

func (*QueryFoundationInfoResponse) GetInfo 

func (m *QueryFoundationInfoResponse) GetInfo() FoundationInfo

func (*QueryFoundationInfoResponse) Marshal 

func (m *QueryFoundationInfoResponse) Marshal() (dAtA []byte, err error)

func (*QueryFoundationInfoResponse) MarshalTo 

func (m *QueryFoundationInfoResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryFoundationInfoResponse) MarshalToSizedBuffer 

func (m *QueryFoundationInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryFoundationInfoResponse) ProtoMessage 

func (*QueryFoundationInfoResponse) ProtoMessage()

func (*QueryFoundationInfoResponse) Reset 

func (m *QueryFoundationInfoResponse) Reset()

func (*QueryFoundationInfoResponse) Size 

func (m *QueryFoundationInfoResponse) Size() (n int)

func (*QueryFoundationInfoResponse) String 

func (m *QueryFoundationInfoResponse) String() string

func (*QueryFoundationInfoResponse) Unmarshal 

func (m *QueryFoundationInfoResponse) Unmarshal(dAtA []byte) error

func (*QueryFoundationInfoResponse) XXX_DiscardUnknown 

func (m *QueryFoundationInfoResponse) XXX_DiscardUnknown()

func (*QueryFoundationInfoResponse) XXX_Marshal 

func (m *QueryFoundationInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryFoundationInfoResponse) XXX_Merge 

func (m *QueryFoundationInfoResponse) XXX_Merge(src proto.Message)

func (*QueryFoundationInfoResponse) XXX_Size 

func (m *QueryFoundationInfoResponse) XXX_Size() int

func (*QueryFoundationInfoResponse) XXX_Unmarshal 

func (m *QueryFoundationInfoResponse) XXX_Unmarshal(b []byte) error

type QueryGrantsRequest 

type QueryGrantsRequest struct {
	Grantee string `protobuf:"bytes,1,opt,name=grantee,proto3" json:"grantee,omitempty"`
	// Optional, msg_type_url, when set, will query only grants matching given msg type.
	MsgTypeUrl string `protobuf:"bytes,2,opt,name=msg_type_url,json=msgTypeUrl,proto3" json:"msg_type_url,omitempty"`
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,3,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryGrantsRequest is the request type for the Query/Grants RPC method.

func (*QueryGrantsRequest) Descriptor 

func (*QueryGrantsRequest) Descriptor() ([]byte, []int)

func (*QueryGrantsRequest) GetGrantee 

func (m *QueryGrantsRequest) GetGrantee() string

func (*QueryGrantsRequest) GetMsgTypeUrl 

func (m *QueryGrantsRequest) GetMsgTypeUrl() string

func (*QueryGrantsRequest) GetPagination 

func (m *QueryGrantsRequest) GetPagination() *query.PageRequest

func (*QueryGrantsRequest) Marshal 

func (m *QueryGrantsRequest) Marshal() (dAtA []byte, err error)

func (*QueryGrantsRequest) MarshalTo 

func (m *QueryGrantsRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryGrantsRequest) MarshalToSizedBuffer 

func (m *QueryGrantsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGrantsRequest) ProtoMessage 

func (*QueryGrantsRequest) ProtoMessage()

func (*QueryGrantsRequest) Reset 

func (m *QueryGrantsRequest) Reset()

func (*QueryGrantsRequest) Size 

func (m *QueryGrantsRequest) Size() (n int)

func (*QueryGrantsRequest) String 

func (m *QueryGrantsRequest) String() string

func (*QueryGrantsRequest) Unmarshal 

func (m *QueryGrantsRequest) Unmarshal(dAtA []byte) error

func (*QueryGrantsRequest) XXX_DiscardUnknown 

func (m *QueryGrantsRequest) XXX_DiscardUnknown()

func (*QueryGrantsRequest) XXX_Marshal 

func (m *QueryGrantsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGrantsRequest) XXX_Merge 

func (m *QueryGrantsRequest) XXX_Merge(src proto.Message)

func (*QueryGrantsRequest) XXX_Size 

func (m *QueryGrantsRequest) XXX_Size() int

func (*QueryGrantsRequest) XXX_Unmarshal 

func (m *QueryGrantsRequest) XXX_Unmarshal(b []byte) error

type QueryGrantsResponse 

type QueryGrantsResponse struct {
	// authorizations is a list of grants granted for grantee.
	Authorizations []*types1.Any `protobuf:"bytes,1,rep,name=authorizations,proto3" json:"authorizations,omitempty"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryGrantsResponse is the response type for the Query/Grants RPC method.

func (*QueryGrantsResponse) Descriptor 

func (*QueryGrantsResponse) Descriptor() ([]byte, []int)

func (*QueryGrantsResponse) GetAuthorizations 

func (m *QueryGrantsResponse) GetAuthorizations() []*types1.Any

func (*QueryGrantsResponse) GetPagination 

func (m *QueryGrantsResponse) GetPagination() *query.PageResponse

func (*QueryGrantsResponse) Marshal 

func (m *QueryGrantsResponse) Marshal() (dAtA []byte, err error)

func (*QueryGrantsResponse) MarshalTo 

func (m *QueryGrantsResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryGrantsResponse) MarshalToSizedBuffer 

func (m *QueryGrantsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryGrantsResponse) ProtoMessage 

func (*QueryGrantsResponse) ProtoMessage()

func (*QueryGrantsResponse) Reset 

func (m *QueryGrantsResponse) Reset()

func (*QueryGrantsResponse) Size 

func (m *QueryGrantsResponse) Size() (n int)

func (*QueryGrantsResponse) String 

func (m *QueryGrantsResponse) String() string

func (*QueryGrantsResponse) Unmarshal 

func (m *QueryGrantsResponse) Unmarshal(dAtA []byte) error

func (*QueryGrantsResponse) XXX_DiscardUnknown 

func (m *QueryGrantsResponse) XXX_DiscardUnknown()

func (*QueryGrantsResponse) XXX_Marshal 

func (m *QueryGrantsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryGrantsResponse) XXX_Merge 

func (m *QueryGrantsResponse) XXX_Merge(src proto.Message)

func (*QueryGrantsResponse) XXX_Size 

func (m *QueryGrantsResponse) XXX_Size() int

func (*QueryGrantsResponse) XXX_Unmarshal 

func (m *QueryGrantsResponse) XXX_Unmarshal(b []byte) error

type QueryMemberRequest 

type QueryMemberRequest struct {
	Address string `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
}

QueryMemberRequest is the Query/Member request type.

func (*QueryMemberRequest) Descriptor 

func (*QueryMemberRequest) Descriptor() ([]byte, []int)

func (*QueryMemberRequest) GetAddress 

func (m *QueryMemberRequest) GetAddress() string

func (*QueryMemberRequest) Marshal 

func (m *QueryMemberRequest) Marshal() (dAtA []byte, err error)

func (*QueryMemberRequest) MarshalTo 

func (m *QueryMemberRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryMemberRequest) MarshalToSizedBuffer 

func (m *QueryMemberRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryMemberRequest) ProtoMessage 

func (*QueryMemberRequest) ProtoMessage()

func (*QueryMemberRequest) Reset 

func (m *QueryMemberRequest) Reset()

func (*QueryMemberRequest) Size 

func (m *QueryMemberRequest) Size() (n int)

func (*QueryMemberRequest) String 

func (m *QueryMemberRequest) String() string

func (*QueryMemberRequest) Unmarshal 

func (m *QueryMemberRequest) Unmarshal(dAtA []byte) error

func (*QueryMemberRequest) XXX_DiscardUnknown 

func (m *QueryMemberRequest) XXX_DiscardUnknown()

func (*QueryMemberRequest) XXX_Marshal 

func (m *QueryMemberRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryMemberRequest) XXX_Merge 

func (m *QueryMemberRequest) XXX_Merge(src proto.Message)

func (*QueryMemberRequest) XXX_Size 

func (m *QueryMemberRequest) XXX_Size() int

func (*QueryMemberRequest) XXX_Unmarshal 

func (m *QueryMemberRequest) XXX_Unmarshal(b []byte) error

type QueryMemberResponse 

type QueryMemberResponse struct {
	// member is the members of the foundation.
	Member *Member `protobuf:"bytes,1,opt,name=member,proto3" json:"member,omitempty"`
}

QueryMemberResponse is the Query/MemberResponse response type.

func (*QueryMemberResponse) Descriptor 

func (*QueryMemberResponse) Descriptor() ([]byte, []int)

func (*QueryMemberResponse) GetMember 

func (m *QueryMemberResponse) GetMember() *Member

func (*QueryMemberResponse) Marshal 

func (m *QueryMemberResponse) Marshal() (dAtA []byte, err error)

func (*QueryMemberResponse) MarshalTo 

func (m *QueryMemberResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryMemberResponse) MarshalToSizedBuffer 

func (m *QueryMemberResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryMemberResponse) ProtoMessage 

func (*QueryMemberResponse) ProtoMessage()

func (*QueryMemberResponse) Reset 

func (m *QueryMemberResponse) Reset()

func (*QueryMemberResponse) Size 

func (m *QueryMemberResponse) Size() (n int)

func (*QueryMemberResponse) String 

func (m *QueryMemberResponse) String() string

func (*QueryMemberResponse) Unmarshal 

func (m *QueryMemberResponse) Unmarshal(dAtA []byte) error

func (*QueryMemberResponse) XXX_DiscardUnknown 

func (m *QueryMemberResponse) XXX_DiscardUnknown()

func (*QueryMemberResponse) XXX_Marshal 

func (m *QueryMemberResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryMemberResponse) XXX_Merge 

func (m *QueryMemberResponse) XXX_Merge(src proto.Message)

func (*QueryMemberResponse) XXX_Size 

func (m *QueryMemberResponse) XXX_Size() int

func (*QueryMemberResponse) XXX_Unmarshal 

func (m *QueryMemberResponse) XXX_Unmarshal(b []byte) error

type QueryMembersRequest 

type QueryMembersRequest struct {
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryMembersRequest is the Query/Members request type.

func (*QueryMembersRequest) Descriptor 

func (*QueryMembersRequest) Descriptor() ([]byte, []int)

func (*QueryMembersRequest) GetPagination 

func (m *QueryMembersRequest) GetPagination() *query.PageRequest

func (*QueryMembersRequest) Marshal 

func (m *QueryMembersRequest) Marshal() (dAtA []byte, err error)

func (*QueryMembersRequest) MarshalTo 

func (m *QueryMembersRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryMembersRequest) MarshalToSizedBuffer 

func (m *QueryMembersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryMembersRequest) ProtoMessage 

func (*QueryMembersRequest) ProtoMessage()

func (*QueryMembersRequest) Reset 

func (m *QueryMembersRequest) Reset()

func (*QueryMembersRequest) Size 

func (m *QueryMembersRequest) Size() (n int)

func (*QueryMembersRequest) String 

func (m *QueryMembersRequest) String() string

func (*QueryMembersRequest) Unmarshal 

func (m *QueryMembersRequest) Unmarshal(dAtA []byte) error

func (*QueryMembersRequest) XXX_DiscardUnknown 

func (m *QueryMembersRequest) XXX_DiscardUnknown()

func (*QueryMembersRequest) XXX_Marshal 

func (m *QueryMembersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryMembersRequest) XXX_Merge 

func (m *QueryMembersRequest) XXX_Merge(src proto.Message)

func (*QueryMembersRequest) XXX_Size 

func (m *QueryMembersRequest) XXX_Size() int

func (*QueryMembersRequest) XXX_Unmarshal 

func (m *QueryMembersRequest) XXX_Unmarshal(b []byte) error

type QueryMembersResponse 

type QueryMembersResponse struct {
	// members are the members of the foundation.
	Members []Member `protobuf:"bytes,1,rep,name=members,proto3" json:"members"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryMembersResponse is the Query/MembersResponse response type.

func (*QueryMembersResponse) Descriptor 

func (*QueryMembersResponse) Descriptor() ([]byte, []int)

func (*QueryMembersResponse) GetMembers 

func (m *QueryMembersResponse) GetMembers() []Member

func (*QueryMembersResponse) GetPagination 

func (m *QueryMembersResponse) GetPagination() *query.PageResponse

func (*QueryMembersResponse) Marshal 

func (m *QueryMembersResponse) Marshal() (dAtA []byte, err error)

func (*QueryMembersResponse) MarshalTo 

func (m *QueryMembersResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryMembersResponse) MarshalToSizedBuffer 

func (m *QueryMembersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryMembersResponse) ProtoMessage 

func (*QueryMembersResponse) ProtoMessage()

func (*QueryMembersResponse) Reset 

func (m *QueryMembersResponse) Reset()

func (*QueryMembersResponse) Size 

func (m *QueryMembersResponse) Size() (n int)

func (*QueryMembersResponse) String 

func (m *QueryMembersResponse) String() string

func (*QueryMembersResponse) Unmarshal 

func (m *QueryMembersResponse) Unmarshal(dAtA []byte) error

func (*QueryMembersResponse) XXX_DiscardUnknown 

func (m *QueryMembersResponse) XXX_DiscardUnknown()

func (*QueryMembersResponse) XXX_Marshal 

func (m *QueryMembersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryMembersResponse) XXX_Merge 

func (m *QueryMembersResponse) XXX_Merge(src proto.Message)

func (*QueryMembersResponse) XXX_Size 

func (m *QueryMembersResponse) XXX_Size() int

func (*QueryMembersResponse) XXX_Unmarshal 

func (m *QueryMembersResponse) XXX_Unmarshal(b []byte) error

type QueryParamsRequest 

type QueryParamsRequest struct {
}

QueryParamsRequest is the request type for the Query/Params RPC method.

func (*QueryParamsRequest) Descriptor 

func (*QueryParamsRequest) Descriptor() ([]byte, []int)

func (*QueryParamsRequest) Marshal 

func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error)

func (*QueryParamsRequest) MarshalTo 

func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryParamsRequest) MarshalToSizedBuffer 

func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryParamsRequest) ProtoMessage 

func (*QueryParamsRequest) ProtoMessage()

func (*QueryParamsRequest) Reset 

func (m *QueryParamsRequest) Reset()

func (*QueryParamsRequest) Size 

func (m *QueryParamsRequest) Size() (n int)

func (*QueryParamsRequest) String 

func (m *QueryParamsRequest) String() string

func (*QueryParamsRequest) Unmarshal 

func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error

func (*QueryParamsRequest) XXX_DiscardUnknown 

func (m *QueryParamsRequest) XXX_DiscardUnknown()

func (*QueryParamsRequest) XXX_Marshal 

func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryParamsRequest) XXX_Merge 

func (m *QueryParamsRequest) XXX_Merge(src proto.Message)

func (*QueryParamsRequest) XXX_Size 

func (m *QueryParamsRequest) XXX_Size() int

func (*QueryParamsRequest) XXX_Unmarshal 

func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error

type QueryParamsResponse 

type QueryParamsResponse struct {
	Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
}

QueryParamsResponse is the response type for the Query/Params RPC method.

func (*QueryParamsResponse) Descriptor 

func (*QueryParamsResponse) Descriptor() ([]byte, []int)

func (*QueryParamsResponse) GetParams 

func (m *QueryParamsResponse) GetParams() Params

func (*QueryParamsResponse) Marshal 

func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error)

func (*QueryParamsResponse) MarshalTo 

func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryParamsResponse) MarshalToSizedBuffer 

func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryParamsResponse) ProtoMessage 

func (*QueryParamsResponse) ProtoMessage()

func (*QueryParamsResponse) Reset 

func (m *QueryParamsResponse) Reset()

func (*QueryParamsResponse) Size 

func (m *QueryParamsResponse) Size() (n int)

func (*QueryParamsResponse) String 

func (m *QueryParamsResponse) String() string

func (*QueryParamsResponse) Unmarshal 

func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error

func (*QueryParamsResponse) XXX_DiscardUnknown 

func (m *QueryParamsResponse) XXX_DiscardUnknown()

func (*QueryParamsResponse) XXX_Marshal 

func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryParamsResponse) XXX_Merge 

func (m *QueryParamsResponse) XXX_Merge(src proto.Message)

func (*QueryParamsResponse) XXX_Size 

func (m *QueryParamsResponse) XXX_Size() int

func (*QueryParamsResponse) XXX_Unmarshal 

func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error

type QueryProposalRequest 

type QueryProposalRequest struct {
	// proposal_id is the unique ID of a proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
}

QueryProposalRequest is the Query/Proposal request type.

func (*QueryProposalRequest) Descriptor 

func (*QueryProposalRequest) Descriptor() ([]byte, []int)

func (*QueryProposalRequest) GetProposalId 

func (m *QueryProposalRequest) GetProposalId() uint64

func (*QueryProposalRequest) Marshal 

func (m *QueryProposalRequest) Marshal() (dAtA []byte, err error)

func (*QueryProposalRequest) MarshalTo 

func (m *QueryProposalRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryProposalRequest) MarshalToSizedBuffer 

func (m *QueryProposalRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryProposalRequest) ProtoMessage 

func (*QueryProposalRequest) ProtoMessage()

func (*QueryProposalRequest) Reset 

func (m *QueryProposalRequest) Reset()

func (*QueryProposalRequest) Size 

func (m *QueryProposalRequest) Size() (n int)

func (*QueryProposalRequest) String 

func (m *QueryProposalRequest) String() string

func (*QueryProposalRequest) Unmarshal 

func (m *QueryProposalRequest) Unmarshal(dAtA []byte) error

func (*QueryProposalRequest) XXX_DiscardUnknown 

func (m *QueryProposalRequest) XXX_DiscardUnknown()

func (*QueryProposalRequest) XXX_Marshal 

func (m *QueryProposalRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryProposalRequest) XXX_Merge 

func (m *QueryProposalRequest) XXX_Merge(src proto.Message)

func (*QueryProposalRequest) XXX_Size 

func (m *QueryProposalRequest) XXX_Size() int

func (*QueryProposalRequest) XXX_Unmarshal 

func (m *QueryProposalRequest) XXX_Unmarshal(b []byte) error

type QueryProposalResponse 

type QueryProposalResponse struct {
	// proposal is the proposal info.
	Proposal *Proposal `protobuf:"bytes,1,opt,name=proposal,proto3" json:"proposal,omitempty"`
}

QueryProposalResponse is the Query/Proposal response type.

func (*QueryProposalResponse) Descriptor 

func (*QueryProposalResponse) Descriptor() ([]byte, []int)

func (*QueryProposalResponse) GetProposal 

func (m *QueryProposalResponse) GetProposal() *Proposal

func (*QueryProposalResponse) Marshal 

func (m *QueryProposalResponse) Marshal() (dAtA []byte, err error)

func (*QueryProposalResponse) MarshalTo 

func (m *QueryProposalResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryProposalResponse) MarshalToSizedBuffer 

func (m *QueryProposalResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryProposalResponse) ProtoMessage 

func (*QueryProposalResponse) ProtoMessage()

func (*QueryProposalResponse) Reset 

func (m *QueryProposalResponse) Reset()

func (*QueryProposalResponse) Size 

func (m *QueryProposalResponse) Size() (n int)

func (*QueryProposalResponse) String 

func (m *QueryProposalResponse) String() string

func (*QueryProposalResponse) Unmarshal 

func (m *QueryProposalResponse) Unmarshal(dAtA []byte) error

func (*QueryProposalResponse) XXX_DiscardUnknown 

func (m *QueryProposalResponse) XXX_DiscardUnknown()

func (*QueryProposalResponse) XXX_Marshal 

func (m *QueryProposalResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryProposalResponse) XXX_Merge 

func (m *QueryProposalResponse) XXX_Merge(src proto.Message)

func (*QueryProposalResponse) XXX_Size 

func (m *QueryProposalResponse) XXX_Size() int

func (*QueryProposalResponse) XXX_Unmarshal 

func (m *QueryProposalResponse) XXX_Unmarshal(b []byte) error

type QueryProposalsRequest 

type QueryProposalsRequest struct {
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,1,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryProposals is the Query/Proposals request type.

func (*QueryProposalsRequest) Descriptor 

func (*QueryProposalsRequest) Descriptor() ([]byte, []int)

func (*QueryProposalsRequest) GetPagination 

func (m *QueryProposalsRequest) GetPagination() *query.PageRequest

func (*QueryProposalsRequest) Marshal 

func (m *QueryProposalsRequest) Marshal() (dAtA []byte, err error)

func (*QueryProposalsRequest) MarshalTo 

func (m *QueryProposalsRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryProposalsRequest) MarshalToSizedBuffer 

func (m *QueryProposalsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryProposalsRequest) ProtoMessage 

func (*QueryProposalsRequest) ProtoMessage()

func (*QueryProposalsRequest) Reset 

func (m *QueryProposalsRequest) Reset()

func (*QueryProposalsRequest) Size 

func (m *QueryProposalsRequest) Size() (n int)

func (*QueryProposalsRequest) String 

func (m *QueryProposalsRequest) String() string

func (*QueryProposalsRequest) Unmarshal 

func (m *QueryProposalsRequest) Unmarshal(dAtA []byte) error

func (*QueryProposalsRequest) XXX_DiscardUnknown 

func (m *QueryProposalsRequest) XXX_DiscardUnknown()

func (*QueryProposalsRequest) XXX_Marshal 

func (m *QueryProposalsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryProposalsRequest) XXX_Merge 

func (m *QueryProposalsRequest) XXX_Merge(src proto.Message)

func (*QueryProposalsRequest) XXX_Size 

func (m *QueryProposalsRequest) XXX_Size() int

func (*QueryProposalsRequest) XXX_Unmarshal 

func (m *QueryProposalsRequest) XXX_Unmarshal(b []byte) error

type QueryProposalsResponse 

type QueryProposalsResponse struct {
	// proposals are the proposals of the foundation.
	Proposals []Proposal `protobuf:"bytes,1,rep,name=proposals,proto3" json:"proposals"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryProposalsResponse is the Query/Proposals response type.

func (*QueryProposalsResponse) Descriptor 

func (*QueryProposalsResponse) Descriptor() ([]byte, []int)

func (*QueryProposalsResponse) GetPagination 

func (m *QueryProposalsResponse) GetPagination() *query.PageResponse

func (*QueryProposalsResponse) GetProposals 

func (m *QueryProposalsResponse) GetProposals() []Proposal

func (*QueryProposalsResponse) Marshal 

func (m *QueryProposalsResponse) Marshal() (dAtA []byte, err error)

func (*QueryProposalsResponse) MarshalTo 

func (m *QueryProposalsResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryProposalsResponse) MarshalToSizedBuffer 

func (m *QueryProposalsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryProposalsResponse) ProtoMessage 

func (*QueryProposalsResponse) ProtoMessage()

func (*QueryProposalsResponse) Reset 

func (m *QueryProposalsResponse) Reset()

func (*QueryProposalsResponse) Size 

func (m *QueryProposalsResponse) Size() (n int)

func (*QueryProposalsResponse) String 

func (m *QueryProposalsResponse) String() string

func (*QueryProposalsResponse) Unmarshal 

func (m *QueryProposalsResponse) Unmarshal(dAtA []byte) error

func (*QueryProposalsResponse) XXX_DiscardUnknown 

func (m *QueryProposalsResponse) XXX_DiscardUnknown()

func (*QueryProposalsResponse) XXX_Marshal 

func (m *QueryProposalsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryProposalsResponse) XXX_Merge 

func (m *QueryProposalsResponse) XXX_Merge(src proto.Message)

func (*QueryProposalsResponse) XXX_Size 

func (m *QueryProposalsResponse) XXX_Size() int

func (*QueryProposalsResponse) XXX_Unmarshal 

func (m *QueryProposalsResponse) XXX_Unmarshal(b []byte) error

type QueryServer 

type QueryServer interface {
	// Params queries the module params.
	Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
	// Treasury queries the foundation treasury.
	Treasury(context.Context, *QueryTreasuryRequest) (*QueryTreasuryResponse, error)
	// FoundationInfo queries foundation info.
	FoundationInfo(context.Context, *QueryFoundationInfoRequest) (*QueryFoundationInfoResponse, error)
	// Member queries a member of the foundation
	Member(context.Context, *QueryMemberRequest) (*QueryMemberResponse, error)
	// Members queries members of the foundation
	Members(context.Context, *QueryMembersRequest) (*QueryMembersResponse, error)
	// Proposal queries a proposal based on proposal id.
	Proposal(context.Context, *QueryProposalRequest) (*QueryProposalResponse, error)
	// Proposals queries all proposals.
	Proposals(context.Context, *QueryProposalsRequest) (*QueryProposalsResponse, error)
	// Vote queries a vote by proposal id and voter.
	Vote(context.Context, *QueryVoteRequest) (*QueryVoteResponse, error)
	// Votes queries a vote by proposal.
	Votes(context.Context, *QueryVotesRequest) (*QueryVotesResponse, error)
	// TallyResult queries the tally of a proposal votes.
	TallyResult(context.Context, *QueryTallyResultRequest) (*QueryTallyResultResponse, error)
	// Censorships queries the censorship informations.
	Censorships(context.Context, *QueryCensorshipsRequest) (*QueryCensorshipsResponse, error)
	// Returns list of authorizations, granted to the grantee.
	Grants(context.Context, *QueryGrantsRequest) (*QueryGrantsResponse, error)
}

QueryServer is the server API for Query service.

type QueryTallyResultRequest 

type QueryTallyResultRequest struct {
	// proposal_id is the unique id of a proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
}

QueryTallyResultRequest is the Query/TallyResult request type.

func (*QueryTallyResultRequest) Descriptor 

func (*QueryTallyResultRequest) Descriptor() ([]byte, []int)

func (*QueryTallyResultRequest) GetProposalId 

func (m *QueryTallyResultRequest) GetProposalId() uint64

func (*QueryTallyResultRequest) Marshal 

func (m *QueryTallyResultRequest) Marshal() (dAtA []byte, err error)

func (*QueryTallyResultRequest) MarshalTo 

func (m *QueryTallyResultRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryTallyResultRequest) MarshalToSizedBuffer 

func (m *QueryTallyResultRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTallyResultRequest) ProtoMessage 

func (*QueryTallyResultRequest) ProtoMessage()

func (*QueryTallyResultRequest) Reset 

func (m *QueryTallyResultRequest) Reset()

func (*QueryTallyResultRequest) Size 

func (m *QueryTallyResultRequest) Size() (n int)

func (*QueryTallyResultRequest) String 

func (m *QueryTallyResultRequest) String() string

func (*QueryTallyResultRequest) Unmarshal 

func (m *QueryTallyResultRequest) Unmarshal(dAtA []byte) error

func (*QueryTallyResultRequest) XXX_DiscardUnknown 

func (m *QueryTallyResultRequest) XXX_DiscardUnknown()

func (*QueryTallyResultRequest) XXX_Marshal 

func (m *QueryTallyResultRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTallyResultRequest) XXX_Merge 

func (m *QueryTallyResultRequest) XXX_Merge(src proto.Message)

func (*QueryTallyResultRequest) XXX_Size 

func (m *QueryTallyResultRequest) XXX_Size() int

func (*QueryTallyResultRequest) XXX_Unmarshal 

func (m *QueryTallyResultRequest) XXX_Unmarshal(b []byte) error

type QueryTallyResultResponse 

type QueryTallyResultResponse struct {
	// tally defines the requested tally.
	Tally TallyResult `protobuf:"bytes,1,opt,name=tally,proto3" json:"tally"`
}

QueryTallyResultResponse is the Query/TallyResult response type.

func (*QueryTallyResultResponse) Descriptor 

func (*QueryTallyResultResponse) Descriptor() ([]byte, []int)

func (*QueryTallyResultResponse) GetTally 

func (m *QueryTallyResultResponse) GetTally() TallyResult

func (*QueryTallyResultResponse) Marshal 

func (m *QueryTallyResultResponse) Marshal() (dAtA []byte, err error)

func (*QueryTallyResultResponse) MarshalTo 

func (m *QueryTallyResultResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryTallyResultResponse) MarshalToSizedBuffer 

func (m *QueryTallyResultResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTallyResultResponse) ProtoMessage 

func (*QueryTallyResultResponse) ProtoMessage()

func (*QueryTallyResultResponse) Reset 

func (m *QueryTallyResultResponse) Reset()

func (*QueryTallyResultResponse) Size 

func (m *QueryTallyResultResponse) Size() (n int)

func (*QueryTallyResultResponse) String 

func (m *QueryTallyResultResponse) String() string

func (*QueryTallyResultResponse) Unmarshal 

func (m *QueryTallyResultResponse) Unmarshal(dAtA []byte) error

func (*QueryTallyResultResponse) XXX_DiscardUnknown 

func (m *QueryTallyResultResponse) XXX_DiscardUnknown()

func (*QueryTallyResultResponse) XXX_Marshal 

func (m *QueryTallyResultResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTallyResultResponse) XXX_Merge 

func (m *QueryTallyResultResponse) XXX_Merge(src proto.Message)

func (*QueryTallyResultResponse) XXX_Size 

func (m *QueryTallyResultResponse) XXX_Size() int

func (*QueryTallyResultResponse) XXX_Unmarshal 

func (m *QueryTallyResultResponse) XXX_Unmarshal(b []byte) error

type QueryTreasuryRequest 

type QueryTreasuryRequest struct {
}

QueryTreasuryRequest is the request type for the Query/Treasury RPC method.

func (*QueryTreasuryRequest) Descriptor 

func (*QueryTreasuryRequest) Descriptor() ([]byte, []int)

func (*QueryTreasuryRequest) Marshal 

func (m *QueryTreasuryRequest) Marshal() (dAtA []byte, err error)

func (*QueryTreasuryRequest) MarshalTo 

func (m *QueryTreasuryRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryTreasuryRequest) MarshalToSizedBuffer 

func (m *QueryTreasuryRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTreasuryRequest) ProtoMessage 

func (*QueryTreasuryRequest) ProtoMessage()

func (*QueryTreasuryRequest) Reset 

func (m *QueryTreasuryRequest) Reset()

func (*QueryTreasuryRequest) Size 

func (m *QueryTreasuryRequest) Size() (n int)

func (*QueryTreasuryRequest) String 

func (m *QueryTreasuryRequest) String() string

func (*QueryTreasuryRequest) Unmarshal 

func (m *QueryTreasuryRequest) Unmarshal(dAtA []byte) error

func (*QueryTreasuryRequest) XXX_DiscardUnknown 

func (m *QueryTreasuryRequest) XXX_DiscardUnknown()

func (*QueryTreasuryRequest) XXX_Marshal 

func (m *QueryTreasuryRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTreasuryRequest) XXX_Merge 

func (m *QueryTreasuryRequest) XXX_Merge(src proto.Message)

func (*QueryTreasuryRequest) XXX_Size 

func (m *QueryTreasuryRequest) XXX_Size() int

func (*QueryTreasuryRequest) XXX_Unmarshal 

func (m *QueryTreasuryRequest) XXX_Unmarshal(b []byte) error

type QueryTreasuryResponse 

type QueryTreasuryResponse struct {
	Amount github_com_PikeEcosystem_cosmos_sdk_types.DecCoins `protobuf:"bytes,1,rep,name=amount,proto3,castrepeated=github.com/PikeEcosystem/cosmos-sdk/types.DecCoins" json:"amount"`
}

QueryTreasuryResponse is the response type for the Query/Treasury RPC method.

func (*QueryTreasuryResponse) Descriptor 

func (*QueryTreasuryResponse) Descriptor() ([]byte, []int)

func (*QueryTreasuryResponse) GetAmount 

func (m *QueryTreasuryResponse) GetAmount() github_com_PikeEcosystem_cosmos_sdk_types.DecCoins

func (*QueryTreasuryResponse) Marshal 

func (m *QueryTreasuryResponse) Marshal() (dAtA []byte, err error)

func (*QueryTreasuryResponse) MarshalTo 

func (m *QueryTreasuryResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryTreasuryResponse) MarshalToSizedBuffer 

func (m *QueryTreasuryResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryTreasuryResponse) ProtoMessage 

func (*QueryTreasuryResponse) ProtoMessage()

func (*QueryTreasuryResponse) Reset 

func (m *QueryTreasuryResponse) Reset()

func (*QueryTreasuryResponse) Size 

func (m *QueryTreasuryResponse) Size() (n int)

func (*QueryTreasuryResponse) String 

func (m *QueryTreasuryResponse) String() string

func (*QueryTreasuryResponse) Unmarshal 

func (m *QueryTreasuryResponse) Unmarshal(dAtA []byte) error

func (*QueryTreasuryResponse) XXX_DiscardUnknown 

func (m *QueryTreasuryResponse) XXX_DiscardUnknown()

func (*QueryTreasuryResponse) XXX_Marshal 

func (m *QueryTreasuryResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryTreasuryResponse) XXX_Merge 

func (m *QueryTreasuryResponse) XXX_Merge(src proto.Message)

func (*QueryTreasuryResponse) XXX_Size 

func (m *QueryTreasuryResponse) XXX_Size() int

func (*QueryTreasuryResponse) XXX_Unmarshal 

func (m *QueryTreasuryResponse) XXX_Unmarshal(b []byte) error

type QueryVoteRequest 

type QueryVoteRequest struct {
	// proposal_id is the unique ID of a proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	// voter is a proposal voter account address.
	Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
}

QueryVote is the Query/Vote request type.

func (*QueryVoteRequest) Descriptor 

func (*QueryVoteRequest) Descriptor() ([]byte, []int)

func (*QueryVoteRequest) GetProposalId 

func (m *QueryVoteRequest) GetProposalId() uint64

func (*QueryVoteRequest) GetVoter 

func (m *QueryVoteRequest) GetVoter() string

func (*QueryVoteRequest) Marshal 

func (m *QueryVoteRequest) Marshal() (dAtA []byte, err error)

func (*QueryVoteRequest) MarshalTo 

func (m *QueryVoteRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryVoteRequest) MarshalToSizedBuffer 

func (m *QueryVoteRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryVoteRequest) ProtoMessage 

func (*QueryVoteRequest) ProtoMessage()

func (*QueryVoteRequest) Reset 

func (m *QueryVoteRequest) Reset()

func (*QueryVoteRequest) Size 

func (m *QueryVoteRequest) Size() (n int)

func (*QueryVoteRequest) String 

func (m *QueryVoteRequest) String() string

func (*QueryVoteRequest) Unmarshal 

func (m *QueryVoteRequest) Unmarshal(dAtA []byte) error

func (*QueryVoteRequest) XXX_DiscardUnknown 

func (m *QueryVoteRequest) XXX_DiscardUnknown()

func (*QueryVoteRequest) XXX_Marshal 

func (m *QueryVoteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryVoteRequest) XXX_Merge 

func (m *QueryVoteRequest) XXX_Merge(src proto.Message)

func (*QueryVoteRequest) XXX_Size 

func (m *QueryVoteRequest) XXX_Size() int

func (*QueryVoteRequest) XXX_Unmarshal 

func (m *QueryVoteRequest) XXX_Unmarshal(b []byte) error

type QueryVoteResponse 

type QueryVoteResponse struct {
	// vote is the vote with given proposal_id and voter.
	Vote *Vote `protobuf:"bytes,1,opt,name=vote,proto3" json:"vote,omitempty"`
}

QueryVoteResponse is the Query/Vote response type.

func (*QueryVoteResponse) Descriptor 

func (*QueryVoteResponse) Descriptor() ([]byte, []int)

func (*QueryVoteResponse) GetVote 

func (m *QueryVoteResponse) GetVote() *Vote

func (*QueryVoteResponse) Marshal 

func (m *QueryVoteResponse) Marshal() (dAtA []byte, err error)

func (*QueryVoteResponse) MarshalTo 

func (m *QueryVoteResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryVoteResponse) MarshalToSizedBuffer 

func (m *QueryVoteResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryVoteResponse) ProtoMessage 

func (*QueryVoteResponse) ProtoMessage()

func (*QueryVoteResponse) Reset 

func (m *QueryVoteResponse) Reset()

func (*QueryVoteResponse) Size 

func (m *QueryVoteResponse) Size() (n int)

func (*QueryVoteResponse) String 

func (m *QueryVoteResponse) String() string

func (*QueryVoteResponse) Unmarshal 

func (m *QueryVoteResponse) Unmarshal(dAtA []byte) error

func (*QueryVoteResponse) XXX_DiscardUnknown 

func (m *QueryVoteResponse) XXX_DiscardUnknown()

func (*QueryVoteResponse) XXX_Marshal 

func (m *QueryVoteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryVoteResponse) XXX_Merge 

func (m *QueryVoteResponse) XXX_Merge(src proto.Message)

func (*QueryVoteResponse) XXX_Size 

func (m *QueryVoteResponse) XXX_Size() int

func (*QueryVoteResponse) XXX_Unmarshal 

func (m *QueryVoteResponse) XXX_Unmarshal(b []byte) error

type QueryVotesRequest 

type QueryVotesRequest struct {
	// proposal_id is the unique ID of a proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	// pagination defines an optional pagination for the request.
	Pagination *query.PageRequest `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryVotes is the Query/Votes request type.

func (*QueryVotesRequest) Descriptor 

func (*QueryVotesRequest) Descriptor() ([]byte, []int)

func (*QueryVotesRequest) GetPagination 

func (m *QueryVotesRequest) GetPagination() *query.PageRequest

func (*QueryVotesRequest) GetProposalId 

func (m *QueryVotesRequest) GetProposalId() uint64

func (*QueryVotesRequest) Marshal 

func (m *QueryVotesRequest) Marshal() (dAtA []byte, err error)

func (*QueryVotesRequest) MarshalTo 

func (m *QueryVotesRequest) MarshalTo(dAtA []byte) (int, error)

func (*QueryVotesRequest) MarshalToSizedBuffer 

func (m *QueryVotesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryVotesRequest) ProtoMessage 

func (*QueryVotesRequest) ProtoMessage()

func (*QueryVotesRequest) Reset 

func (m *QueryVotesRequest) Reset()

func (*QueryVotesRequest) Size 

func (m *QueryVotesRequest) Size() (n int)

func (*QueryVotesRequest) String 

func (m *QueryVotesRequest) String() string

func (*QueryVotesRequest) Unmarshal 

func (m *QueryVotesRequest) Unmarshal(dAtA []byte) error

func (*QueryVotesRequest) XXX_DiscardUnknown 

func (m *QueryVotesRequest) XXX_DiscardUnknown()

func (*QueryVotesRequest) XXX_Marshal 

func (m *QueryVotesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryVotesRequest) XXX_Merge 

func (m *QueryVotesRequest) XXX_Merge(src proto.Message)

func (*QueryVotesRequest) XXX_Size 

func (m *QueryVotesRequest) XXX_Size() int

func (*QueryVotesRequest) XXX_Unmarshal 

func (m *QueryVotesRequest) XXX_Unmarshal(b []byte) error

type QueryVotesResponse 

type QueryVotesResponse struct {
	// votes are the list of votes for given proposal_id.
	Votes []Vote `protobuf:"bytes,1,rep,name=votes,proto3" json:"votes"`
	// pagination defines the pagination in the response.
	Pagination *query.PageResponse `protobuf:"bytes,2,opt,name=pagination,proto3" json:"pagination,omitempty"`
}

QueryVotesResponse is the Query/Votes response type.

func (*QueryVotesResponse) Descriptor 

func (*QueryVotesResponse) Descriptor() ([]byte, []int)

func (*QueryVotesResponse) GetPagination 

func (m *QueryVotesResponse) GetPagination() *query.PageResponse

func (*QueryVotesResponse) GetVotes 

func (m *QueryVotesResponse) GetVotes() []Vote

func (*QueryVotesResponse) Marshal 

func (m *QueryVotesResponse) Marshal() (dAtA []byte, err error)

func (*QueryVotesResponse) MarshalTo 

func (m *QueryVotesResponse) MarshalTo(dAtA []byte) (int, error)

func (*QueryVotesResponse) MarshalToSizedBuffer 

func (m *QueryVotesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*QueryVotesResponse) ProtoMessage 

func (*QueryVotesResponse) ProtoMessage()

func (*QueryVotesResponse) Reset 

func (m *QueryVotesResponse) Reset()

func (*QueryVotesResponse) Size 

func (m *QueryVotesResponse) Size() (n int)

func (*QueryVotesResponse) String 

func (m *QueryVotesResponse) String() string

func (*QueryVotesResponse) Unmarshal 

func (m *QueryVotesResponse) Unmarshal(dAtA []byte) error

func (*QueryVotesResponse) XXX_DiscardUnknown 

func (m *QueryVotesResponse) XXX_DiscardUnknown()

func (*QueryVotesResponse) XXX_Marshal 

func (m *QueryVotesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueryVotesResponse) XXX_Merge 

func (m *QueryVotesResponse) XXX_Merge(src proto.Message)

func (*QueryVotesResponse) XXX_Size 

func (m *QueryVotesResponse) XXX_Size() int

func (*QueryVotesResponse) XXX_Unmarshal 

func (m *QueryVotesResponse) XXX_Unmarshal(b []byte) error

type ReceiveFromTreasuryAuthorization 

type ReceiveFromTreasuryAuthorization struct {
}

ReceiveFromTreasuryAuthorization allows the grantee to receive coins up to receive_limit from the treasury.

func (ReceiveFromTreasuryAuthorization) Accept 

func (a ReceiveFromTreasuryAuthorization) Accept(ctx sdk.Context, msg sdk.Msg) (AcceptResponse, error)

func (*ReceiveFromTreasuryAuthorization) Descriptor 

func (*ReceiveFromTreasuryAuthorization) Descriptor() ([]byte, []int)

func (*ReceiveFromTreasuryAuthorization) Marshal 

func (m *ReceiveFromTreasuryAuthorization) Marshal() (dAtA []byte, err error)

func (*ReceiveFromTreasuryAuthorization) MarshalTo 

func (m *ReceiveFromTreasuryAuthorization) MarshalTo(dAtA []byte) (int, error)

func (*ReceiveFromTreasuryAuthorization) MarshalToSizedBuffer 

func (m *ReceiveFromTreasuryAuthorization) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (ReceiveFromTreasuryAuthorization) MsgTypeURL 

func (a ReceiveFromTreasuryAuthorization) MsgTypeURL() string

func (*ReceiveFromTreasuryAuthorization) ProtoMessage 

func (*ReceiveFromTreasuryAuthorization) ProtoMessage()

func (*ReceiveFromTreasuryAuthorization) Reset 

func (m *ReceiveFromTreasuryAuthorization) Reset()

func (*ReceiveFromTreasuryAuthorization) Size 

func (m *ReceiveFromTreasuryAuthorization) Size() (n int)

func (*ReceiveFromTreasuryAuthorization) String 

func (m *ReceiveFromTreasuryAuthorization) String() string

func (*ReceiveFromTreasuryAuthorization) Unmarshal 

func (m *ReceiveFromTreasuryAuthorization) Unmarshal(dAtA []byte) error

func (ReceiveFromTreasuryAuthorization) ValidateBasic 

func (a ReceiveFromTreasuryAuthorization) ValidateBasic() error

func (*ReceiveFromTreasuryAuthorization) XXX_DiscardUnknown 

func (m *ReceiveFromTreasuryAuthorization) XXX_DiscardUnknown()

func (*ReceiveFromTreasuryAuthorization) XXX_Marshal 

func (m *ReceiveFromTreasuryAuthorization) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ReceiveFromTreasuryAuthorization) XXX_Merge 

func (m *ReceiveFromTreasuryAuthorization) XXX_Merge(src proto.Message)

func (*ReceiveFromTreasuryAuthorization) XXX_Size 

func (m *ReceiveFromTreasuryAuthorization) XXX_Size() int

func (*ReceiveFromTreasuryAuthorization) XXX_Unmarshal 

func (m *ReceiveFromTreasuryAuthorization) XXX_Unmarshal(b []byte) error

type TallyResult 

type TallyResult struct {
	// yes_count is the sum of yes votes.
	YesCount github_com_PikeEcosystem_cosmos_sdk_types.Dec `` /* 132-byte string literal not displayed */
	// abstain_count is the sum of abstainers.
	AbstainCount github_com_PikeEcosystem_cosmos_sdk_types.Dec `` /* 144-byte string literal not displayed */
	// no is the sum of no votes.
	NoCount github_com_PikeEcosystem_cosmos_sdk_types.Dec `` /* 129-byte string literal not displayed */
	// no_with_veto_count is the sum of veto.
	NoWithVetoCount github_com_PikeEcosystem_cosmos_sdk_types.Dec `` /* 157-byte string literal not displayed */
}

TallyResult represents the sum of votes for each vote option.

func DefaultTallyResult 

func DefaultTallyResult() TallyResult

DefaultTallyResult returns a TallyResult with all counts set to 0.

func NewTallyResult 

func NewTallyResult(yes, abstain, no, veto sdk.Dec) TallyResult

func (*TallyResult) Add 

func (t *TallyResult) Add(option VoteOption) error

func (*TallyResult) Descriptor 

func (*TallyResult) Descriptor() ([]byte, []int)

func (*TallyResult) Equal 

func (this *TallyResult) Equal(that interface{}) bool

func (*TallyResult) Marshal 

func (m *TallyResult) Marshal() (dAtA []byte, err error)

func (*TallyResult) MarshalTo 

func (m *TallyResult) MarshalTo(dAtA []byte) (int, error)

func (*TallyResult) MarshalToSizedBuffer 

func (m *TallyResult) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*TallyResult) ProtoMessage 

func (*TallyResult) ProtoMessage()

func (*TallyResult) Reset 

func (m *TallyResult) Reset()

func (*TallyResult) Size 

func (m *TallyResult) Size() (n int)

func (*TallyResult) String 

func (m *TallyResult) String() string

func (TallyResult) TotalCounts 

func (t TallyResult) TotalCounts() sdk.Dec

TotalCounts is the sum of all weights.

func (*TallyResult) Unmarshal 

func (m *TallyResult) Unmarshal(dAtA []byte) error

func (*TallyResult) XXX_DiscardUnknown 

func (m *TallyResult) XXX_DiscardUnknown()

func (*TallyResult) XXX_Marshal 

func (m *TallyResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TallyResult) XXX_Merge 

func (m *TallyResult) XXX_Merge(src proto.Message)

func (*TallyResult) XXX_Size 

func (m *TallyResult) XXX_Size() int

func (*TallyResult) XXX_Unmarshal 

func (m *TallyResult) XXX_Unmarshal(b []byte) error

type ThresholdDecisionPolicy 

type ThresholdDecisionPolicy struct {
	// threshold is the minimum sum of yes votes that must be met or exceeded for a proposal to succeed.
	Threshold github_com_PikeEcosystem_cosmos_sdk_types.Dec `protobuf:"bytes,1,opt,name=threshold,proto3,customtype=github.com/PikeEcosystem/cosmos-sdk/types.Dec" json:"threshold"`
	// windows defines the different windows for voting and execution.
	Windows *DecisionPolicyWindows `protobuf:"bytes,2,opt,name=windows,proto3" json:"windows,omitempty"`
}

ThresholdDecisionPolicy is a decision policy where a proposal passes when it satisfies the two following conditions:

  1. The sum of all `YES` voters' weights is greater or equal than the defined `threshold`.
  2. The voting and execution periods of the proposal respect the parameters given by `windows`.

func (ThresholdDecisionPolicy) Allow 

func (p ThresholdDecisionPolicy) Allow(result TallyResult, totalWeight sdk.Dec, sinceSubmission time.Duration) (*DecisionPolicyResult, error)

func (*ThresholdDecisionPolicy) Descriptor 

func (*ThresholdDecisionPolicy) Descriptor() ([]byte, []int)

func (*ThresholdDecisionPolicy) Equal 

func (this *ThresholdDecisionPolicy) Equal(that interface{}) bool

func (ThresholdDecisionPolicy) GetVotingPeriod 

func (p ThresholdDecisionPolicy) GetVotingPeriod() time.Duration

func (*ThresholdDecisionPolicy) GetWindows 

func (m *ThresholdDecisionPolicy) GetWindows() *DecisionPolicyWindows

func (*ThresholdDecisionPolicy) Marshal 

func (m *ThresholdDecisionPolicy) Marshal() (dAtA []byte, err error)

func (*ThresholdDecisionPolicy) MarshalTo 

func (m *ThresholdDecisionPolicy) MarshalTo(dAtA []byte) (int, error)

func (*ThresholdDecisionPolicy) MarshalToSizedBuffer 

func (m *ThresholdDecisionPolicy) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*ThresholdDecisionPolicy) ProtoMessage 

func (*ThresholdDecisionPolicy) ProtoMessage()

func (*ThresholdDecisionPolicy) Reset 

func (m *ThresholdDecisionPolicy) Reset()

func (*ThresholdDecisionPolicy) Size 

func (m *ThresholdDecisionPolicy) Size() (n int)

func (*ThresholdDecisionPolicy) String 

func (m *ThresholdDecisionPolicy) String() string

func (*ThresholdDecisionPolicy) Unmarshal 

func (m *ThresholdDecisionPolicy) Unmarshal(dAtA []byte) error

func (ThresholdDecisionPolicy) Validate 

func (p ThresholdDecisionPolicy) Validate(info FoundationInfo, config Config) error

func (ThresholdDecisionPolicy) ValidateBasic 

func (p ThresholdDecisionPolicy) ValidateBasic() error

func (*ThresholdDecisionPolicy) XXX_DiscardUnknown 

func (m *ThresholdDecisionPolicy) XXX_DiscardUnknown()

func (*ThresholdDecisionPolicy) XXX_Marshal 

func (m *ThresholdDecisionPolicy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ThresholdDecisionPolicy) XXX_Merge 

func (m *ThresholdDecisionPolicy) XXX_Merge(src proto.Message)

func (*ThresholdDecisionPolicy) XXX_Size 

func (m *ThresholdDecisionPolicy) XXX_Size() int

func (*ThresholdDecisionPolicy) XXX_Unmarshal 

func (m *ThresholdDecisionPolicy) XXX_Unmarshal(b []byte) error

type UnimplementedMsgServer 

type UnimplementedMsgServer struct {
}

UnimplementedMsgServer can be embedded to have forward compatible implementations.

func (*UnimplementedMsgServer) Exec 

func (*UnimplementedMsgServer) Exec(ctx context.Context, req *MsgExec) (*MsgExecResponse, error)

func (*UnimplementedMsgServer) FundTreasury 

func (*UnimplementedMsgServer) FundTreasury(ctx context.Context, req *MsgFundTreasury) (*MsgFundTreasuryResponse, error)

func (*UnimplementedMsgServer) Grant 

func (*UnimplementedMsgServer) Grant(ctx context.Context, req *MsgGrant) (*MsgGrantResponse, error)

func (*UnimplementedMsgServer) LeaveFoundation 

func (*UnimplementedMsgServer) LeaveFoundation(ctx context.Context, req *MsgLeaveFoundation) (*MsgLeaveFoundationResponse, error)

func (*UnimplementedMsgServer) Revoke 

func (*UnimplementedMsgServer) Revoke(ctx context.Context, req *MsgRevoke) (*MsgRevokeResponse, error)

func (*UnimplementedMsgServer) SubmitProposal 

func (*UnimplementedMsgServer) SubmitProposal(ctx context.Context, req *MsgSubmitProposal) (*MsgSubmitProposalResponse, error)

func (*UnimplementedMsgServer) UpdateCensorship 

func (*UnimplementedMsgServer) UpdateCensorship(ctx context.Context, req *MsgUpdateCensorship) (*MsgUpdateCensorshipResponse, error)

func (*UnimplementedMsgServer) UpdateDecisionPolicy 

func (*UnimplementedMsgServer) UpdateDecisionPolicy(ctx context.Context, req *MsgUpdateDecisionPolicy) (*MsgUpdateDecisionPolicyResponse, error)

func (*UnimplementedMsgServer) UpdateMembers 

func (*UnimplementedMsgServer) UpdateMembers(ctx context.Context, req *MsgUpdateMembers) (*MsgUpdateMembersResponse, error)

func (*UnimplementedMsgServer) UpdateParams 

func (*UnimplementedMsgServer) UpdateParams(ctx context.Context, req *MsgUpdateParams) (*MsgUpdateParamsResponse, error)

func (*UnimplementedMsgServer) Vote 

func (*UnimplementedMsgServer) Vote(ctx context.Context, req *MsgVote) (*MsgVoteResponse, error)

func (*UnimplementedMsgServer) WithdrawFromTreasury 

func (*UnimplementedMsgServer) WithdrawFromTreasury(ctx context.Context, req *MsgWithdrawFromTreasury) (*MsgWithdrawFromTreasuryResponse, error)

func (*UnimplementedMsgServer) WithdrawProposal 

func (*UnimplementedMsgServer) WithdrawProposal(ctx context.Context, req *MsgWithdrawProposal) (*MsgWithdrawProposalResponse, error)

type UnimplementedQueryServer 

type UnimplementedQueryServer struct {
}

UnimplementedQueryServer can be embedded to have forward compatible implementations.

func (*UnimplementedQueryServer) Censorships 

func (*UnimplementedQueryServer) Censorships(ctx context.Context, req *QueryCensorshipsRequest) (*QueryCensorshipsResponse, error)

func (*UnimplementedQueryServer) FoundationInfo 

func (*UnimplementedQueryServer) FoundationInfo(ctx context.Context, req *QueryFoundationInfoRequest) (*QueryFoundationInfoResponse, error)

func (*UnimplementedQueryServer) Grants 

func (*UnimplementedQueryServer) Grants(ctx context.Context, req *QueryGrantsRequest) (*QueryGrantsResponse, error)

func (*UnimplementedQueryServer) Member 

func (*UnimplementedQueryServer) Member(ctx context.Context, req *QueryMemberRequest) (*QueryMemberResponse, error)

func (*UnimplementedQueryServer) Members 

func (*UnimplementedQueryServer) Members(ctx context.Context, req *QueryMembersRequest) (*QueryMembersResponse, error)

func (*UnimplementedQueryServer) Params 

func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error)

func (*UnimplementedQueryServer) Proposal 

func (*UnimplementedQueryServer) Proposal(ctx context.Context, req *QueryProposalRequest) (*QueryProposalResponse, error)

func (*UnimplementedQueryServer) Proposals 

func (*UnimplementedQueryServer) Proposals(ctx context.Context, req *QueryProposalsRequest) (*QueryProposalsResponse, error)

func (*UnimplementedQueryServer) TallyResult 

func (*UnimplementedQueryServer) TallyResult(ctx context.Context, req *QueryTallyResultRequest) (*QueryTallyResultResponse, error)

func (*UnimplementedQueryServer) Treasury 

func (*UnimplementedQueryServer) Treasury(ctx context.Context, req *QueryTreasuryRequest) (*QueryTreasuryResponse, error)

func (*UnimplementedQueryServer) Vote 

func (*UnimplementedQueryServer) Vote(ctx context.Context, req *QueryVoteRequest) (*QueryVoteResponse, error)

func (*UnimplementedQueryServer) Votes 

func (*UnimplementedQueryServer) Votes(ctx context.Context, req *QueryVotesRequest) (*QueryVotesResponse, error)

type Vote 

type Vote struct {
	// proposal is the unique ID of the proposal.
	ProposalId uint64 `protobuf:"varint,1,opt,name=proposal_id,json=proposalId,proto3" json:"proposal_id,omitempty"`
	// voter is the account address of the voter.
	Voter string `protobuf:"bytes,2,opt,name=voter,proto3" json:"voter,omitempty"`
	// option is the voter's choice on the proposal.
	Option VoteOption `protobuf:"varint,3,opt,name=option,proto3,enum=lbm.foundation.v1.VoteOption" json:"option,omitempty"`
	// metadata is any arbitrary metadata to attached to the vote.
	Metadata string `protobuf:"bytes,4,opt,name=metadata,proto3" json:"metadata,omitempty"`
	// submit_time is the timestamp when the vote was submitted.
	SubmitTime time.Time `protobuf:"bytes,5,opt,name=submit_time,json=submitTime,proto3,stdtime" json:"submit_time"`
}

Vote represents a vote for a proposal.

func (*Vote) Descriptor 

func (*Vote) Descriptor() ([]byte, []int)

func (*Vote) Equal 

func (this *Vote) Equal(that interface{}) bool

func (*Vote) GetMetadata 

func (m *Vote) GetMetadata() string

func (*Vote) GetOption 

func (m *Vote) GetOption() VoteOption

func (*Vote) GetProposalId 

func (m *Vote) GetProposalId() uint64

func (*Vote) GetSubmitTime 

func (m *Vote) GetSubmitTime() time.Time

func (*Vote) GetVoter 

func (m *Vote) GetVoter() string

func (*Vote) Marshal 

func (m *Vote) Marshal() (dAtA []byte, err error)

func (*Vote) MarshalTo 

func (m *Vote) MarshalTo(dAtA []byte) (int, error)

func (*Vote) MarshalToSizedBuffer 

func (m *Vote) MarshalToSizedBuffer(dAtA []byte) (int, error)

func (*Vote) ProtoMessage 

func (*Vote) ProtoMessage()

func (*Vote) Reset 

func (m *Vote) Reset()

func (*Vote) Size 

func (m *Vote) Size() (n int)

func (*Vote) String 

func (m *Vote) String() string

func (*Vote) Unmarshal 

func (m *Vote) Unmarshal(dAtA []byte) error

func (*Vote) XXX_DiscardUnknown 

func (m *Vote) XXX_DiscardUnknown()

func (*Vote) XXX_Marshal 

func (m *Vote) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Vote) XXX_Merge 

func (m *Vote) XXX_Merge(src proto.Message)

func (*Vote) XXX_Size 

func (m *Vote) XXX_Size() int

func (*Vote) XXX_Unmarshal 

func (m *Vote) XXX_Unmarshal(b []byte) error

type VoteOption 

type VoteOption int32

VoteOption enumerates the valid vote options for a given proposal. 

const (
	// VOTE_OPTION_UNSPECIFIED defines a no-op vote option.
	VOTE_OPTION_UNSPECIFIED VoteOption = 0
	// VOTE_OPTION_YES defines a yes vote option.
	VOTE_OPTION_YES VoteOption = 1
	// VOTE_OPTION_ABSTAIN defines an abstain vote option.
	VOTE_OPTION_ABSTAIN VoteOption = 2
	// VOTE_OPTION_NO defines a no vote option.
	VOTE_OPTION_NO VoteOption = 3
	// VOTE_OPTION_NO_WITH_VETO defines a no with veto vote option.
	VOTE_OPTION_NO_WITH_VETO VoteOption = 4
)

func (VoteOption) EnumDescriptor 

func (VoteOption) EnumDescriptor() ([]byte, []int)

func (VoteOption) String 

func (x VoteOption) String() string

Source Files

View all Source files

Directories

Path Synopsis
cli
testutil
internal

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.