disperse.gno

  1package disperse
  2
  3import (
  4	"std"
  5
  6	tokens "gno.land/r/demo/grc20factory"
  7)
  8
  9var realmAddr = std.CurrentRealm().Address()
 10
 11// DisperseUgnot parses receivers and amounts and sends out ugnot
 12// The function will send out the coins to the addresses and return the leftover coins to the caller
 13// if there are any to return
 14func DisperseUgnot(cur realm, addresses []std.Address, coins std.Coins) {
 15	coinSent := std.OriginSend()
 16	caller := std.PreviousRealm().Address()
 17	banker := std.NewBanker(std.BankerTypeRealmSend)
 18
 19	if len(addresses) != len(coins) {
 20		panic(ErrNumAddrValMismatch)
 21	}
 22
 23	for _, coin := range coins {
 24		if coin.Amount <= 0 {
 25			panic(ErrNegativeCoinAmount)
 26		}
 27
 28		if banker.GetCoins(realmAddr).AmountOf(coin.Denom) < coin.Amount {
 29			panic(ErrMismatchBetweenSentAndParams)
 30		}
 31	}
 32
 33	// Send coins
 34	for i := range addresses {
 35		banker.SendCoins(realmAddr, addresses[i], std.NewCoins(coins[i]))
 36	}
 37
 38	// Return possible leftover coins
 39	for _, coin := range coinSent {
 40		leftoverAmt := banker.GetCoins(realmAddr).AmountOf(coin.Denom)
 41		if leftoverAmt > 0 {
 42			send := std.Coins{std.NewCoin(coin.Denom, leftoverAmt)}
 43			banker.SendCoins(realmAddr, caller, send)
 44		}
 45	}
 46}
 47
 48// DisperseUgnotString receives a string of addresses and a string of amounts
 49// and parses them to be used in DisperseUgnot
 50func DisperseUgnotString(cur realm, addresses string, amounts string) {
 51	parsedAddresses, err := parseAddresses(addresses)
 52	if err != nil {
 53		panic(err)
 54	}
 55
 56	parsedAmounts, err := parseAmounts(amounts)
 57	if err != nil {
 58		panic(err)
 59	}
 60
 61	coins := make(std.Coins, len(parsedAmounts))
 62	for i, amount := range parsedAmounts {
 63		coins[i] = std.NewCoin("ugnot", amount)
 64	}
 65
 66	DisperseUgnot(cur, parsedAddresses, coins)
 67}
 68
 69// DisperseGRC20 disperses tokens to multiple addresses
 70// Note that it is necessary to approve the realm to spend the tokens before calling this function
 71// see the corresponding filetests for examples
 72func DisperseGRC20(cur realm, addresses []std.Address, amounts []int64, symbols []string) {
 73	caller := std.PreviousRealm().Address()
 74
 75	if (len(addresses) != len(amounts)) || (len(amounts) != len(symbols)) {
 76		panic(ErrArgLenAndSentLenMismatch)
 77	}
 78	for _, amount := range amounts {
 79		if amount < 0 {
 80			panic(ErrInvalidAmount)
 81		}
 82	}
 83
 84	for i := 0; i < len(addresses); i++ {
 85		tokens.TransferFrom(cross, symbols[i], caller, addresses[i], amounts[i])
 86	}
 87}
 88
 89// DisperseGRC20String receives a string of addresses and a string of tokens
 90// and parses them to be used in DisperseGRC20
 91func DisperseGRC20String(cur realm, addresses string, tokens string) {
 92	parsedAddresses, err := parseAddresses(addresses)
 93	if err != nil {
 94		panic(err)
 95	}
 96
 97	parsedAmounts, parsedSymbols, err := parseTokens(tokens)
 98	if err != nil {
 99		panic(err)
100	}
101
102	DisperseGRC20(cur, parsedAddresses, parsedAmounts, parsedSymbols)
103}