gns.gno
9.10 Kb · 319 lines
1package gns
2
3import (
4 "chain"
5 "strings"
6 "time"
7
8 "gno.land/p/nt/grc20/v0"
9 "gno.land/p/nt/ufmt/v0"
10
11 "gno.land/r/gnoswap/access/v1"
12 "gno.land/r/nt/grc20reg/v0"
13
14 "gno.land/p/gnoswap/gnsmath/v1"
15 "gno.land/p/gnoswap/utils/v1"
16 _ "gno.land/r/gnoswap/rbac/v1"
17)
18
19const (
20 tokenID = 0
21 MAXIMUM_SUPPLY = int64(1_000_000_000_000_000)
22 INITIAL_MINT_AMOUNT = int64(100_000_000_000_000)
23 MAX_EMISSION_AMOUNT = int64(900_000_000_000_000) // MAXIMUM_SUPPLY - INITIAL_MINT_AMOUNT
24)
25
26var (
27 token *grc20.Token
28 privateLedger *grc20.PrivateLedger
29 userTeller grc20.Teller
30
31 leftEmissionAmount int64 // amount of GNS can be minted for emission
32 mintedEmissionAmount int64 // amount of GNS that has been minted for emission
33 lastMintedTimestamp int64 // last block time that gns was minted for emission
34)
35
36func init(cur realm) {
37 token, privateLedger = grc20.NewToken("Gnoswap", "GNS", 6, tokenID, cur)
38 userTeller = privateLedger.CallerTeller()
39
40 grc20reg.Register(cross(cur), token, "")
41
42 // Initial amount set to 900_000_000_000_000 (MAXIMUM_SUPPLY - INITIAL_MINT_AMOUNT).
43 // leftEmissionAmount will decrease as tokens are minted.
44 setLeftEmissionAmount(MAX_EMISSION_AMOUNT)
45 setMintedEmissionAmount(0)
46 setLastMintedTimestamp(0)
47
48 // Pre-mint the initial GNS supply.
49 setupPreMint(cur)
50}
51
52// Name returns the name of the GNS token.
53//
54// Returns:
55// - name: token name
56func Name() string { return token.GetName() }
57
58// Symbol returns the symbol of the GNS token.
59//
60// Returns:
61// - symbol: token symbol
62func Symbol() string { return token.GetSymbol() }
63
64// Decimals returns the number of decimal places for GNS token.
65//
66// Returns:
67// - decimals: number of decimal places
68func Decimals() int { return token.GetDecimals() }
69
70// TotalSupply returns the total supply of GNS tokens in circulation.
71//
72// Returns:
73// - supply: total token supply
74func TotalSupply() int64 { return token.TotalSupply() }
75
76// KnownAccounts returns the number of addresses that have held GNS.
77//
78// Returns:
79// - count: number of known accounts
80func KnownAccounts() int { return token.KnownAccounts() }
81
82// BalanceOf returns the GNS balance of a specific address.
83//
84// Parameters:
85// - owner: address to check balance for
86//
87// Returns:
88// - balance: token balance
89func BalanceOf(owner address) int64 { return token.BalanceOf(owner) }
90
91// Allowance returns the amount of GNS that a spender is allowed to transfer from an owner.
92//
93// Parameters:
94// - owner: token owner address
95// - spender: spender address
96//
97// Returns:
98// - allowance: approved amount
99func Allowance(owner, spender address) int64 { return token.Allowance(owner, spender) }
100
101// MintGns mints new GNS tokens according to the emission schedule.
102//
103// Parameters:
104// - cur: Current realm context; callers use cross(cur) when crossing into this realm.
105// - address: recipient address for minted tokens
106//
107// Returns:
108// - amount: GNS minted for the current timestamp; zero when emission is
109// already processed for that timestamp or the schedule has ended
110//
111// Only callable by emission contract.
112//
113// Note: Halt check is performed by the caller (emission.MintAndDistributeGns)
114// to allow graceful handling. This function assumes caller has already verified
115// halt status before invoking.
116func MintGns(cur realm, address address) int64 {
117 previousRealm := cur.Previous()
118 caller := previousRealm.Address()
119 access.AssertIsEmission(caller)
120
121 lastGNSMintedTimestamp := LastMintedTimestamp()
122 currentTime := time.Now().Unix()
123
124 // Skip if already minted this timestamp or emission ended.
125 if lastGNSMintedTimestamp == currentTime || lastGNSMintedTimestamp >= GetEmissionEndTimestamp() {
126 return 0
127 }
128
129 amountToMint, err := calculateAmountToMint(getEmissionState(), lastGNSMintedTimestamp+1, currentTime)
130 if err != nil {
131 panic(err)
132 }
133
134 err = validEmissionAmount(amountToMint)
135 if err != nil {
136 panic(err)
137 }
138
139 setLastMintedTimestamp(currentTime)
140 setMintedEmissionAmount(gnsmath.SafeAddInt64(MintedEmissionAmount(), amountToMint))
141 setLeftEmissionAmount(gnsmath.SafeSubInt64(LeftEmissionAmount(), amountToMint))
142
143 err = privateLedger.Mint(address, amountToMint)
144 if err != nil {
145 panic(err.Error())
146 }
147
148 chain.Emit(
149 "MintGNS",
150 "prevAddr", caller.String(),
151 "prevRealm", previousRealm.PkgPath(),
152 "mintedBlockTime", utils.FormatInt(currentTime),
153 "mintedGNSAmount", utils.FormatInt(amountToMint),
154 "accumMintedGNSAmount", utils.FormatInt(MintedEmissionAmount()),
155 "accumLeftMintGNSAmount", utils.FormatInt(LeftEmissionAmount()),
156 )
157
158 return amountToMint
159}
160
161// Transfer transfers GNS tokens from caller to recipient.
162//
163// Parameters:
164// - cur: Current realm context; callers use cross(cur) when crossing into this realm.
165// - to: recipient address
166// - amount: number of GNS base units to transfer
167func Transfer(cur realm, to address, amount int64) {
168 checkErr(userTeller.Transfer(0, cur, to, amount))
169}
170
171// Approve allows spender to transfer GNS tokens from caller's account.
172//
173// Parameters:
174// - cur: Current realm context; callers use cross(cur) when crossing into this realm.
175// - spender: address authorized to spend
176// - amount: maximum number of GNS base units spender can transfer
177func Approve(cur realm, spender address, amount int64) {
178 checkErr(userTeller.Approve(0, cur, spender, amount))
179}
180
181// TransferFrom transfers GNS tokens on behalf of owner.
182//
183// Parameters:
184// - cur: Current realm context; callers use cross(cur) when crossing into this realm.
185// - from: token owner address
186// - to: recipient address
187// - amount: number of GNS base units to transfer
188func TransferFrom(cur realm, from, to address, amount int64) {
189 checkErr(userTeller.TransferFrom(0, cur, from, to, amount))
190}
191
192// Render returns token information for web interface.
193//
194// Parameters:
195// - path: render path for specific views
196//
197// Returns:
198// - output: formatted token information
199func Render(path string) string {
200 parts := strings.Split(path, "/")
201 c := len(parts)
202
203 switch {
204 case path == "":
205 return token.RenderHome()
206 case c == 2 && parts[0] == "balance":
207 owner := address(parts[1])
208 balance := token.BalanceOf(owner)
209 return ufmt.Sprintf("%d\n", balance)
210 default:
211 return "404\n"
212 }
213}
214
215// checkErr panics if error is not nil.
216func checkErr(err error) {
217 if err != nil {
218 panic(err.Error())
219 }
220}
221
222// calculateAmountToMint calculates and allocates GNS tokens to mint for given timestamp range.
223// This function has side effects: it updates the accumulated and remaining amounts
224// for each halving year in the emission state.
225func calculateAmountToMint(state *EmissionState, fromTimestamp, toTimestamp int64) (int64, error) {
226 // Cache state to avoid repeated lookups
227 endTimestamp := state.getEndTimestamp()
228 if toTimestamp > endTimestamp {
229 toTimestamp = endTimestamp
230 }
231
232 if fromTimestamp > toTimestamp {
233 return 0, nil
234 }
235
236 startTimestamp := state.getStartTimestamp()
237 if fromTimestamp < startTimestamp {
238 fromTimestamp = startTimestamp
239 }
240
241 if toTimestamp < startTimestamp {
242 return 0, nil
243 }
244
245 fromYear := state.getCurrentYear(fromTimestamp)
246 toYear := state.getCurrentYear(toTimestamp)
247
248 if fromYear == 0 || toYear == 0 {
249 return 0, nil
250 }
251
252 totalAmountToMint := int64(0)
253
254 for year := fromYear; year <= toYear; year++ {
255 yearEndTimestamp := state.getHalvingYearEndTimestamp(year)
256 currentToTimestamp := i64Min(toTimestamp, yearEndTimestamp)
257
258 seconds := currentToTimestamp - fromTimestamp + 1
259 if seconds <= 0 {
260 break
261 }
262
263 amountPerSecond := state.getHalvingYearAmountPerSecond(year)
264 yearAmountToMint := gnsmath.SafeMulInt64(amountPerSecond, seconds)
265
266 if currentToTimestamp >= yearEndTimestamp {
267 leftover := gnsmath.SafeSubInt64(state.getHalvingYearLeftAmount(year), yearAmountToMint)
268 yearAmountToMint = gnsmath.SafeAddInt64(yearAmountToMint, leftover)
269 }
270
271 totalAmountToMint = gnsmath.SafeAddInt64(totalAmountToMint, yearAmountToMint)
272
273 err := state.addHalvingYearMintedAmount(year, yearAmountToMint)
274 if err != nil {
275 return 0, err
276 }
277
278 err = state.subHalvingYearLeftAmount(year, yearAmountToMint)
279 if err != nil {
280 return 0, err
281 }
282
283 fromTimestamp = currentToTimestamp + 1
284
285 if fromTimestamp > toTimestamp {
286 break
287 }
288 }
289
290 return totalAmountToMint, nil
291}
292
293// LastMintedTimestamp returns the timestamp of the last GNS emission mint.
294//
295// Returns:
296// - timestamp: last minted timestamp
297func LastMintedTimestamp() int64 { return lastMintedTimestamp }
298
299// LeftEmissionAmount returns the remaining GNS tokens available for emission.
300//
301// Returns:
302// - amount: remaining emission amount
303func LeftEmissionAmount() int64 { return leftEmissionAmount }
304
305// MintedEmissionAmount returns the total GNS tokens minted through emission,
306// excluding the initial mint amount.
307//
308// Returns:
309// - amount: total minted emission amount
310func MintedEmissionAmount() int64 { return mintedEmissionAmount }
311
312// setLastMintedTimestamp sets the timestamp of the last emission mint.
313func setLastMintedTimestamp(timestamp int64) { lastMintedTimestamp = timestamp }
314
315// setLeftEmissionAmount sets the remaining emission amount.
316func setLeftEmissionAmount(amount int64) { leftEmissionAmount = amount }
317
318// setMintedEmissionAmount sets the total minted emission amount.
319func setMintedEmissionAmount(amount int64) { mintedEmissionAmount = amount }
