foundation

package
v0.48.0-ramus1 Latest Latest
Warning

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

Go to latest
Published: Aug 10, 2023 License: Apache-2.0 Imports: 35 Imported by: 10

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/Finschia/finschia-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/x/foundation/foundation.go#L90-L103 +++ https://github.com/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/foundation/v1/authz.proto#L9-L13

+++ https://github.com/Finschia/finschia-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/Finschia/finschia-sdk/blob/392277a33519d289154e8da27f05f9a6788ab076/proto/lbm/stakingplus/v1/authz.proto#L9-L15

+++ https://github.com/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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/Finschia/finschia-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_Finschia_finschia_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/Finschia/finschia-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 (*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_Finschia_finschia_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/Finschia/finschia-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 (*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_Finschia_finschia_sdk_types.Dec `` /* 138-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_Finschia_finschia_sdk_types.Coins `protobuf:"bytes,2,rep,name=amount,proto3,castrepeated=github.com/Finschia/finschia-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

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 (*MsgUpdateDecisionPolicyResponse) Size

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

func (*MsgUpdateDecisionPolicyResponse) 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_Finschia_finschia_sdk_types.Coins `protobuf:"bytes,3,rep,name=amount,proto3,castrepeated=github.com/Finschia/finschia-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

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 (*MsgWithdrawFromTreasuryResponse) Size

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

func (*MsgWithdrawFromTreasuryResponse) 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_Finschia_finschia_sdk_types.Dec `` /* 144-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_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,1,opt,name=percentage,proto3,customtype=github.com/Finschia/finschia-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 (*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_Finschia_finschia_sdk_types.DecCoins `protobuf:"bytes,1,rep,name=treasury,proto3,castrepeated=github.com/Finschia/finschia-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 (*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 (*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_Finschia_finschia_sdk_types.DecCoins `protobuf:"bytes,1,rep,name=amount,proto3,castrepeated=github.com/Finschia/finschia-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 (*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 (*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 (*ReceiveFromTreasuryAuthorization) ProtoMessage

func (*ReceiveFromTreasuryAuthorization) ProtoMessage()

func (*ReceiveFromTreasuryAuthorization) Reset

func (*ReceiveFromTreasuryAuthorization) Size

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

func (*ReceiveFromTreasuryAuthorization) 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 (*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_Finschia_finschia_sdk_types.Dec `` /* 129-byte string literal not displayed */
	// abstain_count is the sum of abstainers.
	AbstainCount github_com_Finschia_finschia_sdk_types.Dec `` /* 141-byte string literal not displayed */
	// no is the sum of no votes.
	NoCount github_com_Finschia_finschia_sdk_types.Dec `` /* 126-byte string literal not displayed */
	// no_with_veto_count is the sum of veto.
	NoWithVetoCount github_com_Finschia_finschia_sdk_types.Dec `` /* 154-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_Finschia_finschia_sdk_types.Dec `protobuf:"bytes,1,opt,name=threshold,proto3,customtype=github.com/Finschia/finschia-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 (*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) FundTreasury

func (*UnimplementedMsgServer) Grant

func (*UnimplementedMsgServer) LeaveFoundation

func (*UnimplementedMsgServer) Revoke

func (*UnimplementedMsgServer) SubmitProposal

func (*UnimplementedMsgServer) UpdateCensorship

func (*UnimplementedMsgServer) UpdateDecisionPolicy

func (*UnimplementedMsgServer) UpdateMembers

func (*UnimplementedMsgServer) UpdateParams

func (*UnimplementedMsgServer) Vote

func (*UnimplementedMsgServer) WithdrawFromTreasury

func (*UnimplementedMsgServer) WithdrawProposal

type UnimplementedQueryServer

type UnimplementedQueryServer struct {
}

UnimplementedQueryServer can be embedded to have forward compatible implementations.

func (*UnimplementedQueryServer) Censorships

func (*UnimplementedQueryServer) FoundationInfo

func (*UnimplementedQueryServer) Grants

func (*UnimplementedQueryServer) Member

func (*UnimplementedQueryServer) Members

func (*UnimplementedQueryServer) Params

func (*UnimplementedQueryServer) Proposal

func (*UnimplementedQueryServer) Proposals

func (*UnimplementedQueryServer) TallyResult

func (*UnimplementedQueryServer) Treasury

func (*UnimplementedQueryServer) Vote

func (*UnimplementedQueryServer) Votes

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

Directories

Path Synopsis
cli

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL