proposal_data.gno

  1package governance
  2
  3import (
  4	"strings"
  5)
  6
  7// ProposalMetadata contains descriptive information about a proposal.
  8// This includes the title and description that are displayed to voters.
  9type ProposalMetadata struct {
 10	title       string // Proposal title (max 255 characters)
 11	description string // Detailed proposal description (max 10,000 characters)
 12}
 13
 14// Title returns the proposal title.
 15//
 16// Returns:
 17//   - string: proposal title
 18func (p *ProposalMetadata) Title() string {
 19	return p.title
 20}
 21
 22// Description returns the proposal description.
 23//
 24// Returns:
 25//   - string: proposal description
 26func (p *ProposalMetadata) Description() string {
 27	return p.description
 28}
 29
 30// NewProposalMetadata creates a new proposal metadata instance with trimmed input.
 31//
 32// Parameters:
 33//   - title: proposal title
 34//   - description: proposal description
 35//
 36// Returns:
 37//   - *ProposalMetadata: new metadata instance with trimmed whitespace
 38func NewProposalMetadata(title string, description string) *ProposalMetadata {
 39	return &ProposalMetadata{
 40		title:       strings.TrimSpace(title),
 41		description: strings.TrimSpace(description),
 42	}
 43}
 44
 45// ProposalData contains the type-specific data for a proposal.
 46// This structure holds different data depending on the proposal type.
 47type ProposalData struct {
 48	proposalType       ProposalType            // Type of proposal (Text, CommunityPoolSpend, ParameterChange)
 49	communityPoolSpend *CommunityPoolSpendInfo // Data for community pool spending proposals
 50	execution          *ExecutionInfo          // Data for parameter change proposals
 51}
 52
 53// ProposalType returns the type of this proposal.
 54//
 55// Returns:
 56//   - ProposalType: the proposal type
 57func (p *ProposalData) ProposalType() ProposalType {
 58	return p.proposalType
 59}
 60
 61// CommunityPoolSpend returns the community pool spending information.
 62//
 63// Returns:
 64//   - *CommunityPoolSpendInfo: community pool spending details
 65func (p *ProposalData) CommunityPoolSpend() *CommunityPoolSpendInfo {
 66	return p.communityPoolSpend
 67}
 68
 69// Execution returns the execution information for parameter changes.
 70//
 71// Returns:
 72//   - *ExecutionInfo: parameter change execution details
 73func (p *ProposalData) Execution() *ExecutionInfo {
 74	return p.execution
 75}
 76
 77// NewProposalData creates a new proposal data instance with the specified components.
 78//
 79// Parameters:
 80//   - proposalType: type of the proposal
 81//   - communityPoolSpend: community pool spending information
 82//   - execution: parameter change execution information
 83//
 84// Returns:
 85//   - *ProposalData: new proposal data instance
 86func NewProposalData(proposalType ProposalType, communityPoolSpend *CommunityPoolSpendInfo, execution *ExecutionInfo) *ProposalData {
 87	return &ProposalData{
 88		proposalType:       proposalType,
 89		communityPoolSpend: communityPoolSpend,
 90		execution:          execution,
 91	}
 92}
 93
 94// CommunityPoolSpendInfo contains information for community pool spending proposals.
 95type CommunityPoolSpendInfo struct {
 96	to        address // Recipient address for token transfer
 97	tokenPath string  // Path of the token to transfer
 98	amount    int64   // Amount of tokens to transfer
 99}
100
101// NewCommunityPoolSpendInfo creates community-pool spend data.
102//
103// Parameters:
104//   - to: Recipient address that receives the community-pool transfer.
105//   - tokenPath: Registered token path of the asset to transfer.
106//   - amount: Transfer amount in the token's smallest unit.
107//
108// Returns:
109//   - *CommunityPoolSpendInfo: spend data containing the recipient, token path, and amount.
110func NewCommunityPoolSpendInfo(to address, tokenPath string, amount int64) *CommunityPoolSpendInfo {
111	return &CommunityPoolSpendInfo{
112		to:        to,
113		tokenPath: tokenPath,
114		amount:    amount,
115	}
116}
117
118/* Getter methods */
119// Returns:
120//   - address: recipient address configured for the community-pool spend.
121//
122func (i *CommunityPoolSpendInfo) To() address { return i.to }
123
124// Returns:
125//   - string: registered token path configured for the community-pool spend.
126func (i *CommunityPoolSpendInfo) TokenPath() string { return i.tokenPath }
127
128// Returns:
129//   - int64: transfer amount in the token's smallest unit.
130func (i *CommunityPoolSpendInfo) Amount() int64 { return i.amount }
131
132// ExecutionInfo contains information for parameter change execution.
133// Messages are encoded strings that specify function calls and parameters.
134type ExecutionInfo struct {
135	num  int64    // Number of parameter changes to execute
136	msgs []string // Execution messages separated by messageSeparator (*GOV*)
137}
138
139// NewExecutionInfo creates execution data for a parameter-change proposal.
140//
141// Parameters:
142//   - num: Number of encoded parameter-change messages to execute.
143//   - msgs: Encoded parameter-change messages, one message per execution.
144//
145// Returns:
146//   - *ExecutionInfo: execution data containing the declared count and messages.
147func NewExecutionInfo(num int64, msgs []string) *ExecutionInfo {
148	return &ExecutionInfo{
149		num:  num,
150		msgs: msgs,
151	}
152}
153
154/* Getter methods */
155// Returns:
156//   - int64: declared number of parameter-change messages.
157//
158func (i *ExecutionInfo) Num() int64 { return i.num }
159
160// Returns:
161//   - []string: encoded parameter-change messages in execution order.
162func (i *ExecutionInfo) Msgs() []string { return i.msgs }
163
164// ParameterChangeInfo represents a single parameter change to be executed.
165type ParameterChangeInfo struct {
166	pkgPath  string   // Package path of the target contract
167	function string   // Function name to call
168	params   []string // Parameters to pass to the function
169}
170
171// NewParameterChangeInfo creates one encoded parameter-change target description.
172//
173// Parameters:
174//   - pkgPath: Package path containing the parameter-change handler.
175//   - function: Handler function name to invoke.
176//   - params: String arguments passed to the handler in order.
177//
178// Returns:
179//   - ParameterChangeInfo: parameter-change target and its encoded arguments.
180func NewParameterChangeInfo(pkgPath string, function string, params []string) ParameterChangeInfo {
181	return ParameterChangeInfo{
182		pkgPath:  pkgPath,
183		function: function,
184		params:   params,
185	}
186}
187
188/* Getter methods */
189// Returns:
190//   - string: package path of the parameter-change handler.
191//
192func (i *ParameterChangeInfo) PkgPath() string { return i.pkgPath }
193
194// Returns:
195//   - string: function name of the parameter-change handler.
196func (i *ParameterChangeInfo) Function() string { return i.function }
197
198// Returns:
199//   - []string: encoded arguments passed to the parameter-change handler.
200func (i *ParameterChangeInfo) Params() []string { return i.params }
201
202// Clone creates a deep copy of the ProposalMetadata.
203// Returns:
204//   - *ProposalMetadata: independent metadata copy, or nil when the receiver is nil.
205func (p *ProposalMetadata) Clone() *ProposalMetadata {
206	if p == nil {
207		return nil
208	}
209
210	return &ProposalMetadata{
211		title:       p.title,
212		description: p.description,
213	}
214}
215
216// Clone creates a deep copy of the CommunityPoolSpendInfo.
217// Returns:
218//   - *CommunityPoolSpendInfo: independent spend-data copy, or nil when the receiver is nil.
219func (i *CommunityPoolSpendInfo) Clone() *CommunityPoolSpendInfo {
220	if i == nil {
221		return nil
222	}
223
224	return &CommunityPoolSpendInfo{
225		to:        i.to,
226		tokenPath: i.tokenPath,
227		amount:    i.amount,
228	}
229}
230
231// Clone creates a deep copy of the ExecutionInfo.
232// Returns:
233//   - *ExecutionInfo: independent execution-data copy including a copied message slice, or nil when the receiver is nil.
234func (i *ExecutionInfo) Clone() *ExecutionInfo {
235	if i == nil {
236		return nil
237	}
238
239	clonedMsgs := make([]string, len(i.msgs))
240	copy(clonedMsgs, i.msgs)
241
242	return &ExecutionInfo{
243		num:  i.num,
244		msgs: clonedMsgs,
245	}
246}
247
248// Clone creates a deep copy of the ProposalData.
249// Returns:
250//   - *ProposalData: independent proposal-data copy with cloned nested values, or nil when the receiver is nil.
251func (p *ProposalData) Clone() *ProposalData {
252	if p == nil {
253		return nil
254	}
255
256	return &ProposalData{
257		proposalType:       p.proposalType,
258		communityPoolSpend: p.communityPoolSpend.Clone(),
259		execution:          p.execution.Clone(),
260	}
261}