token.gno

  1package grc20
  2
  3import (
  4	"math/overflow"
  5	"std"
  6	"strconv"
  7
  8	"gno.land/p/demo/ufmt"
  9)
 10
 11// NewToken creates a new Token.
 12// It returns a pointer to the Token and a pointer to the Ledger.
 13// Expected usage: Token, admin := NewToken("Dummy", "DUMMY", 4)
 14func NewToken(name, symbol string, decimals uint) (*Token, *PrivateLedger) {
 15	if name == "" {
 16		panic("name should not be empty")
 17	}
 18	if symbol == "" {
 19		panic("symbol should not be empty")
 20	}
 21	// XXX additional checks (length, characters, limits, etc)
 22
 23	ledger := &PrivateLedger{}
 24	token := &Token{
 25		name:     name,
 26		symbol:   symbol,
 27		decimals: decimals,
 28		ledger:   ledger,
 29	}
 30	ledger.token = token
 31	return token, ledger
 32}
 33
 34// GetName returns the name of the token.
 35func (tok Token) GetName() string { return tok.name }
 36
 37// GetSymbol returns the symbol of the token.
 38func (tok Token) GetSymbol() string { return tok.symbol }
 39
 40// GetDecimals returns the number of decimals used to get the token's precision.
 41func (tok Token) GetDecimals() uint { return tok.decimals }
 42
 43// TotalSupply returns the total supply of the token.
 44func (tok Token) TotalSupply() uint64 { return tok.ledger.totalSupply }
 45
 46// KnownAccounts returns the number of known accounts in the bank.
 47func (tok Token) KnownAccounts() int { return tok.ledger.balances.Size() }
 48
 49// BalanceOf returns the balance of the specified address.
 50func (tok Token) BalanceOf(address std.Address) uint64 {
 51	return tok.ledger.balanceOf(address)
 52}
 53
 54// Allowance returns the allowance of the specified owner and spender.
 55func (tok Token) Allowance(owner, spender std.Address) uint64 {
 56	return tok.ledger.allowance(owner, spender)
 57}
 58
 59func (tok *Token) RenderHome() string {
 60	str := ""
 61	str += ufmt.Sprintf("# %s ($%s)\n\n", tok.name, tok.symbol)
 62	str += ufmt.Sprintf("* **Decimals**: %d\n", tok.decimals)
 63	str += ufmt.Sprintf("* **Total supply**: %d\n", tok.ledger.totalSupply)
 64	str += ufmt.Sprintf("* **Known accounts**: %d\n", tok.KnownAccounts())
 65	return str
 66}
 67
 68// Getter returns a TokenGetter function that returns this token. This allows
 69// storing indirect pointers to a token in a remote realm.
 70func (tok *Token) Getter() TokenGetter {
 71	return func() *Token {
 72		return tok
 73	}
 74}
 75
 76// SpendAllowance decreases the allowance of the specified owner and spender.
 77func (led *PrivateLedger) SpendAllowance(owner, spender std.Address, amount uint64) error {
 78	if !owner.IsValid() {
 79		return ErrInvalidAddress
 80	}
 81	if !spender.IsValid() {
 82		return ErrInvalidAddress
 83	}
 84
 85	currentAllowance := led.allowance(owner, spender)
 86	if currentAllowance < amount {
 87		return ErrInsufficientAllowance
 88	}
 89
 90	key := allowanceKey(owner, spender)
 91	newAllowance := currentAllowance - amount
 92
 93	if newAllowance == 0 {
 94		led.allowances.Remove(key)
 95	} else {
 96		led.allowances.Set(key, newAllowance)
 97	}
 98
 99	return nil
100}
101
102// Transfer transfers tokens from the specified from address to the specified to address.
103func (led *PrivateLedger) Transfer(from, to std.Address, amount uint64) error {
104	if !from.IsValid() {
105		return ErrInvalidAddress
106	}
107	if !to.IsValid() {
108		return ErrInvalidAddress
109	}
110	if from == to {
111		return ErrCannotTransferToSelf
112	}
113
114	var (
115		toBalance   = led.balanceOf(to)
116		fromBalance = led.balanceOf(from)
117	)
118
119	if fromBalance < amount {
120		return ErrInsufficientBalance
121	}
122
123	var (
124		newToBalance   = toBalance + amount
125		newFromBalance = fromBalance - amount
126	)
127
128	led.balances.Set(string(to), newToBalance)
129	led.balances.Set(string(from), newFromBalance)
130
131	std.Emit(
132		TransferEvent,
133		"from", from.String(),
134		"to", to.String(),
135		"value", strconv.Itoa(int(amount)),
136	)
137
138	return nil
139}
140
141// TransferFrom transfers tokens from the specified owner to the specified to address.
142// It first checks if the owner has sufficient balance and then decreases the allowance.
143func (led *PrivateLedger) TransferFrom(owner, spender, to std.Address, amount uint64) error {
144	if led.balanceOf(owner) < amount {
145		return ErrInsufficientBalance
146	}
147
148	// allowance must be sufficient
149	currentAllowance := led.allowance(owner, spender)
150	if currentAllowance < amount {
151		return ErrInsufficientAllowance
152	}
153
154	if err := led.Transfer(owner, to, amount); err != nil {
155		return err
156	}
157
158	// decrease the allowance only when transfer is successful
159	key := allowanceKey(owner, spender)
160	newAllowance := currentAllowance - amount
161
162	if newAllowance == 0 {
163		led.allowances.Remove(key)
164	} else {
165		led.allowances.Set(key, newAllowance)
166	}
167
168	return nil
169}
170
171// Approve sets the allowance of the specified owner and spender.
172func (led *PrivateLedger) Approve(owner, spender std.Address, amount uint64) error {
173	if !owner.IsValid() || !spender.IsValid() {
174		return ErrInvalidAddress
175	}
176
177	led.allowances.Set(allowanceKey(owner, spender), amount)
178
179	std.Emit(
180		ApprovalEvent,
181		"owner", string(owner),
182		"spender", string(spender),
183		"value", strconv.Itoa(int(amount)),
184	)
185
186	return nil
187}
188
189// Mint increases the total supply of the token and adds the specified amount to the specified address.
190func (led *PrivateLedger) Mint(address std.Address, amount uint64) error {
191	if !address.IsValid() {
192		return ErrInvalidAddress
193	}
194
195	// XXX: math/overflow is not supporting uint64.
196	// This checks prevents overflow but makes the totalSupply limited to a uint63.
197	sum, ok := overflow.Add64(int64(led.totalSupply), int64(amount))
198	if !ok {
199		return ErrOverflow
200	}
201
202	led.totalSupply = uint64(sum)
203	currentBalance := led.balanceOf(address)
204	newBalance := currentBalance + amount
205
206	led.balances.Set(string(address), newBalance)
207
208	std.Emit(
209		TransferEvent,
210		"from", "",
211		"to", string(address),
212		"value", strconv.Itoa(int(amount)),
213	)
214
215	return nil
216}
217
218// Burn decreases the total supply of the token and subtracts the specified amount from the specified address.
219func (led *PrivateLedger) Burn(address std.Address, amount uint64) error {
220	if !address.IsValid() {
221		return ErrInvalidAddress
222	}
223
224	currentBalance := led.balanceOf(address)
225	if currentBalance < amount {
226		return ErrInsufficientBalance
227	}
228
229	led.totalSupply -= amount
230	newBalance := currentBalance - amount
231
232	led.balances.Set(string(address), newBalance)
233
234	std.Emit(
235		TransferEvent,
236		"from", string(address),
237		"to", "",
238		"value", strconv.Itoa(int(amount)),
239	)
240
241	return nil
242}
243
244// balanceOf returns the balance of the specified address.
245func (led PrivateLedger) balanceOf(address std.Address) uint64 {
246	balance, found := led.balances.Get(address.String())
247	if !found {
248		return 0
249	}
250	return balance.(uint64)
251}
252
253// allowance returns the allowance of the specified owner and spender.
254func (led PrivateLedger) allowance(owner, spender std.Address) uint64 {
255	allowance, found := led.allowances.Get(allowanceKey(owner, spender))
256	if !found {
257		return 0
258	}
259	return allowance.(uint64)
260}
261
262// allowanceKey returns the key for the allowance of the specified owner and spender.
263func allowanceKey(owner, spender std.Address) string {
264	return owner.String() + ":" + spender.String()
265}