v1 state

assertIsNotHaltedGovernanceForProposalData

assertIsNotHaltedGovernanceForProposalData panics if governance is halted, unless the proposal only targets the halt realm. This keeps a recovery path open so governance can unhalt itself.

assertIsNotHaltedGovernanceForProposal

assertIsNotHaltedGovernanceForProposal panics if governance is halted, unless the proposal only targets the halt realm.

isHaltRecoveryProposalData

isHaltRecoveryProposalData returns true if the proposal is a parameter change whose every execution targets the halt realm.

assertCallerIsProposer

assertCallerIsProposer panics if the caller is not the proposer of the given proposal.

assertIsValidSmoothingPeriod

assertIsValidToken

makeConfig

makeConfig creates a new governance configuration.

parameterSeparator

messageSeparator

maxTitleLength

maxDescriptionLength

maxNumberOfExecution

maxSmoothingPeriod

// 30 days

errInvalidInput

errDataNotFound

errNotEnoughBalance

errAlreadyVoted

errNotEnoughVotingWeight

errAlreadyCanceledProposal

errUnableToCancelVotingProposal

errTextProposalNotExecutable

errUnableToVoteOutOfPeriod

errInvalidMessageFormat

errAlreadyActiveProposal

errProposalNotFound

errProposalNotExecutable

errNotProposer

errInvalidConfiguration

errInvalidExecution

errInvalidSmoothingPeriod

errProposalIndexNeedsCleanup

makeErrorWithDetails

makeErrorWithDetails creates an error with additional context.

cloneProposalEntry

cloneProposalEntry is the transformation for the proposal tree. Proposal is mutable and its setters are declared in /r/gnoswap/gov/governance, so an external holder of the stored pointer could write realm state through it. Proposal.Clone leaves the type-specific data nil; see it for which lookups read it instead.

cloneProposalIDsEntry

cloneProposalIDsEntry is the transformation for the user proposal tree. The stored value is a slice, so hand out a copy rather than letting a reader write through the shared backing array.

executeCommunityPoolSpend

executeCommunityPoolSpend executes community pool spending proposals. Handles token transfers from community pool to specified recipients.

executeParameterChange

executeParameterChange executes parameter change proposals. Handles governance configuration updates and system parameter modifications.

init.36

registerGovernanceV1

initStoreData

formatConfigKey

governanceV1

NewGovernanceV1

NewGovernanceV1 creates a governance v1 implementation backed by the supplied state store and staker voting-weight accessor. Parameters: - governanceStore: persistence adapter for configuration, proposals, counters, and voting information - stakerAccessor: accessor that supplies delegation snapshots and total xGNS supply for governance decisions Returns: - governance.IGovernance: governance manager and getter implementation using the supplied dependencies

activeProposalSnapshotKey

globalParameterRegistry

globalParameterRegistry is initialized once and reused for all validation and execution. This provides consistent validation at proposal creation time and execution time.

init.44

GNS_TOKEN_KEY

Package paths

HALT_PATH

Package paths

RBAC_PATH

Package paths

ACCESS_PATH

Package paths

EMISSION_PATH

Package paths

COMMON_PATH

Package paths

POOL_PATH

Package paths

POSITION_PATH

Package paths

ROUTER_PATH

Package paths

STAKER_PATH

Package paths

LAUNCHPAD_PATH

Package paths

PROTOCOL_FEE_PATH

Package paths

COMMUNITY_POOL_PATH

Package paths

GOV_GOVERNANCE_PATH

Package paths

GOV_STAKER_PATH

Package paths

ParameterHandler

ParameterHandler interface defines the contract for parameter execution handlers. Each handler is responsible for executing specific parameter changes in the system.

ParameterHandlerOptions

ParameterHandlerOptions contains the configuration and execution logic for a parameter handler. This struct encapsulates all information needed to identify and execute a parameter change. NOTE: handlerFunc uses \`rlm realm\` (rather than \`cur realm\`) as the realm parameter name. The v2 preprocessor reserves the \`cur\` name for the first realm-type parameter of top-level crossing function declarations and \`t.Run\` closures only; using it as the realm-parameter name on a multi-parameter struct-field function value trips a parser check ("only the first realm type argument of a crossing function may have name \`cur\`"). Naming it \`rlm\` keeps the lowering identical without the syntax constraint.

paramValidator

paramValidator validates a single parameter value and returns an error on failure.

compositeValidator

compositeValidator validates relationships between a handler's parameters. It must only enforce deterministic, state-independent rules so that a proposal is not rejected merely because on-chain state changes while voting.

NewParameterHandlerOptions

NewParameterHandlerOptions creates a new parameter handler with the specified configuration. Parameters: - pkgPath: package path of the target contract - function: function name to be called - paramCount: expected number of parameters - handlerFunc: callback receiving the discriminator, propagated realm, and serialized parameters to execute the change - paramValidators: optional validators for each parameter (must match paramCount if provided) Returns: - ParameterHandler: configured parameter handler interface

ParameterRegistry

ParameterRegistry manages the collection of parameter handlers for governance execution. This registry allows proposals to execute parameter changes across different system contracts.

NewParameterRegistry

NewParameterRegistry creates a new empty parameter registry. Returns: - \*ParameterRegistry: new registry instance

makeHandlerKey

makeHandlerKey creates a unique identifier for a handler based on package path and function. Parameters: - pkgPath: package path of the target contract - function: function name to be called Returns: - string: unique key in format "pkgPath:function"

CreateParameterHandlers

CreateParameterHandlers initializes and configures all supported parameter handlers. This function defines all the parameter changes that can be executed through governance proposals. It covers configuration changes for various system components including pools, staking, fees, etc. Returns: - \*ParameterRegistry: fully configured registry with all supported handlers

registerHandlers

registerHandlers batch registers all configured handlers into the registry. This helper function processes the handler configuration array and adds each handler to the registry. Parameters: - registry: the parameter registry to add handlers to - handlerOptions: slice of handler configurations to register

runValidator

runValidator executes a validator function and converts panics to errors.

stringValidator

Basic reusable validators for proposal-time type checking.

boolValidator

Basic reusable validators for proposal-time type checking.

uint64Validator

Basic reusable validators for proposal-time type checking.

addressValidator

Basic reusable validators for proposal-time type checking.

numberValidator

uint8RangeValidator

roleNameValidator

updatableRoleNameValidator

removableRoleNameValidator

nonNegativeInt64Validator

positiveInt64Validator

int64RangeValidator

uint64RangeValidator

haltLevelValidator

haltOperationTypeValidator

tokenMinimumRewardAmountValidator

distributionPctCompositeValidator

splitExecutionsRaw

parseExecutionMessage

validateExecutions

validateExecutions validates that all executions in a parameter change proposal correspond to registered handlers in the global parameter registry. This function performs comprehensive validation including: - Basic format validation (count, structure) - Handler existence verification in the registry - Parameter count validation against handler expectations Parameters: - numToExecute: number of parameter changes to execute - msgs: pre-split slice of execution messages, where each message is formatted as \<pkgPath>\*EXE\*\<function>\*EXE\*\<params> Returns: - error: validation error if any execution is invalid

ProposalResolver

NewProposalResolver

NewProposalResolver wraps a persisted governance proposal and initializes resolvers for its status, type-specific data, and metadata. Parameters: - proposal: persisted proposal to resolve Returns: - \*ProposalResolver: resolver backed by proposal and its nested state

ProposalActionStatusResolver

NewProposalActionStatusResolver

NewProposalActionStatusResolver wraps a proposal action status for mutation and execution-state queries. Parameters: - status: proposal action status to resolve and update. Returns: - \*ProposalActionStatusResolver: resolver backed by status.

ProposalMetadataResolver

NewProposalMetadataResolver

NewProposalMetadataResolver wraps proposal metadata for validation. Parameters: - metadata: proposal title and description to validate. Returns: - \*ProposalMetadataResolver: resolver backed by metadata.

ProposalDataResolver

ProposalDataResolver handles business logic for proposal data.

NewProposalDataResolver

NewProposalDataResolver wraps proposal data for type-specific validation and execution-message parsing. Parameters: - proposalData: proposal data to resolve and validate. Returns: - \*ProposalDataResolver: resolver backed by proposalData.

NewProposalTextData

NewProposalTextData creates proposal data for a text proposal. Text proposals have no additional data requirements. Returns: - \*ProposalData: proposal data configured for text proposal

NewProposalCommunityPoolSpendData

NewProposalCommunityPoolSpendData creates proposal data for a community pool spend proposal. Automatically generates the execution message for the token transfer. Parameters: - tokenPath: path of the token to transfer - to: recipient address for the transfer - amount: amount of tokens to transfer - communityPoolPackagePath: package path of the community pool contract Returns: - \*ProposalData: proposal data configured for community pool spending

NewProposalExecutionData

NewProposalExecutionData creates proposal data for a parameter change proposal. Each message in executions should be formatted as \<pkgPath>\*EXE\*\<function>\*EXE\*\<params>, separated by \*GOV\* when there are multiple messages. Parameters: - numToExecute: number of parameter changes to execute - executions: raw encoded execution string with parameter changes Returns: - \*ProposalData: proposal data configured for parameter changes

makeExecuteMessage

makeExecuteMessage creates a message to execute a function. Message format: \<pkgPath>\*EXE\*\<function>\*EXE\*\<params>.

ProposalScheduleStatusResolver

NewProposalScheduleStatusResolver

NewProposalScheduleStatusResolver wraps a proposal schedule for phase-boundary queries. Parameters: - status: proposal schedule containing creation, voting, and execution timestamps Returns: - \*ProposalScheduleStatusResolver: resolver backed by status

NewProposalScheduleStatus

NewProposalScheduleStatus creates a new schedule status with calculated timestamps. This constructor takes the governance timing parameters and calculates all important timestamps for the proposal's lifecycle. Parameters: - votingStartDelay: delay before voting starts (seconds) - votingPeriod: duration of voting period (seconds) - executionDelay: delay before execution can start (seconds) - executionWindow: window during which execution is allowed (seconds) - createdAt: timestamp when proposal was created Returns: - \*ProposalScheduleStatus: new schedule status with calculated times

ProposalStatusResolver

NewProposalStatusResolver

NewProposalStatusResolver wraps proposal status components for lifecycle and vote queries. Parameters: - status: proposal status containing schedule, action, and vote state Returns: - \*ProposalStatusResolver: resolver backed by status

NewProposalStatus

NewProposalStatus creates a new proposal status with the specified configuration. This initializes all status components with the governance configuration and timing. Parameters: - config: governance configuration to use - maxVotingWeight: maximum voting weight for this proposal - executable: whether this proposal type can be executed - createdAt: timestamp when proposal was created - quorumWeight: total xGNS supply at proposal creation, used as the quorum base Returns: - \*ProposalStatus: new proposal status instance

ProposalVoteStatusResolver

NewProposalVoteStatusResolver

NewProposalVoteStatusResolver wraps persisted vote status for vote tally calculations and mutation. Parameters: - voteStatus: persisted proposal vote status to resolve Returns: - \*ProposalVoteStatusResolver: resolver backed by voteStatus

numberKind

numberKind represents the type of number to parse.

kindInt

kindInt64

kindUint64

parseNumber

parseNumber parses a string to a number (int, int64, or uint64) with proper validation.

parseBool

parseBool parses a string to a boolean.

parseInt

parseInt parses a string to int with proper validation and overflow checking.

parseInt64

parseInt64 parses a string to int64 with proper validation.

parseUint64

parseUint64 parses a string to uint64 with proper validation.