Playground
distribution.gno
package game_vault
import (
"chain"
"chain/banker"
"strconv"
"gno.land/p/akkadia/beta/accesscontrol"
"gno.land/r/akkadia/beta/admin"
)
const (
SetDistributionBatchMaxEvent = "SetDistributionBatchMax"
distributionBatchMaxDefault = 50
distributionBatchMaxUpperBound = 100
)
var distributionBatchMax int
type RewardDistribution struct {
ID uint64
PoolID uint64
GameWorldID uint64
OperationKey string
RecipientCount uint32
TotalAmount int64
Executor address
}
type RewardDistributionView struct {
ID uint64
PoolKey string
GameWorldID uint64
OperationKey string
RecipientCount uint32
TotalAmount int64
Executor address
}
type VaultRefund struct {
ID uint64
PoolID uint64
OperationKey string
SourceKey string
Recipient address
Amount int64
Kind string
Executor address
}
func SetDistributionBatchMax(cur realm, value int) {
executor := accesscontrol.MustGetAdminCaller(0, cur, admin.IsAdmin)
assertNoAttachedCoins()
if value < 1 {
panic("limit must be at least 1")
}
if value > distributionBatchMaxUpperBound {
panic("distribution batch max exceeds limit")
}
if value == distributionBatchMax {
return
}
oldValue := distributionBatchMax
distributionBatchMax = value
chain.Emit(SetDistributionBatchMaxEvent, "executor", executor.String(), "oldValue", strconv.Itoa(oldValue), "newValue", strconv.Itoa(value))
}
func GetDistributionBatchMax() int { return distributionBatchMax }
func DistributeReward(cur realm, poolKey string, operationKey, recipientCSV, ugnotAmountCSV string) uint64 {
executor := accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
assertNewOperationKey(operationKey)
poolID, pool := mustGetRewardPoolByKey(poolKey)
if pool.Status != RewardPoolStatusLocked {
panic("reward pool must be locked before distribution")
}
if latestRewardDistributionID == maxUint64 {
panic("reward distribution id exhausted")
}
if recipientCSV == "" || ugnotAmountCSV == "" {
panic("payout list must not be empty")
}
count, total := validatePayouts(recipientCSV, ugnotAmountCSV, cur.Address(), pool.Balance)
if pool.DistributedTotal > maxInt64-total {
panic("reward pool distributed amount overflow")
}
if pool.DistributionCount == maxUint64 {
panic("reward pool distribution count overflow")
}
latestRewardDistributionID++
distributionID := latestRewardDistributionID
pool.Balance -= total
pool.DistributedTotal += total
pool.DistributionCount++
treeSet(rewardPools, poolID, pool)
treeSet(rewardDistributions, distributionID, RewardDistribution{
ID: distributionID,
PoolID: poolID,
GameWorldID: pool.GameWorldID,
OperationKey: operationKey,
RecipientCount: uint32(count),
TotalAmount: total,
Executor: executor,
})
rewardDistributionIDs.Set(operationKey, distributionID)
processedOperationKeys.Set(operationKey, distributionID)
getOrCreateIDSet(poolDistributionIDs, poolID).Set(uint64Key(distributionID), true)
accountedUgnotTotal -= total
sendPayouts(cross(cur), recipientCSV, ugnotAmountCSV)
return distributionID
}
func recordAndSendRefund(cur realm, poolID uint64, operationKey, sourceKey string, recipient address, amount int64, kind string, executor address) uint64 {
if latestVaultRefundID == maxUint64 {
panic("vault refund id exhausted")
}
latestVaultRefundID++
refundID := latestVaultRefundID
treeSet(vaultRefunds, refundID, VaultRefund{
ID: refundID,
PoolID: poolID,
OperationKey: operationKey,
SourceKey: sourceKey,
Recipient: recipient,
Amount: amount,
Kind: kind,
Executor: executor,
})
vaultRefundIDs.Set(operationKey, refundID)
processedOperationKeys.Set(operationKey, refundID)
if poolID != 0 {
getOrCreateIDSet(poolRefundIDs, poolID).Set(uint64Key(refundID), true)
}
sendUgnot(cross(cur), recipient, amount)
return refundID
}
func validatePayouts(recipientCSV, ugnotAmountCSV string, realmAddress address, balance int64) (int, int64) {
count := 0
total := int64(0)
recipientStart := 0
amountStart := 0
for {
_, nextRecipient, recipientDone := readPayoutRecipient(recipientCSV, recipientStart, realmAddress)
amount, nextAmount, amountDone := readPayoutAmount(ugnotAmountCSV, amountStart)
if recipientDone != amountDone {
panic("payout list item count mismatch")
}
count++
if count > distributionBatchMax {
panic("payout list exceeds limit")
}
if total > maxInt64-amount {
panic("distribution amount overflow")
}
total += amount
if total > balance {
panic("distribution amount exceeds reward pool balance")
}
if recipientDone {
return count, total
}
recipientStart = nextRecipient
amountStart = nextAmount
}
}
func sendPayouts(cur realm, recipientCSV, ugnotAmountCSV string) {
bnk := banker.NewBanker(banker.BankerTypeRealmSend, cur)
recipientStart := 0
amountStart := 0
for {
recipient, nextRecipient, recipientDone := readPayoutRecipient(recipientCSV, recipientStart, cur.Address())
amount, nextAmount, amountDone := readPayoutAmount(ugnotAmountCSV, amountStart)
if recipientDone != amountDone {
panic("payout list item count mismatch")
}
bnk.SendCoins(cur.Address(), recipient, chain.Coins{{"ugnot", amount}})
if recipientDone {
return
}
recipientStart = nextRecipient
amountStart = nextAmount
}
}
func readPayoutRecipient(recipientCSV string, start int, realmAddress address) (address, int, bool) {
value, next, done := readPayoutCSVEntry(recipientCSV, start)
recipient := address(value)
if !recipient.IsValid() || recipient == realmAddress {
panic("invalid payout recipient")
}
return recipient, next, done
}
func readPayoutAmount(ugnotAmountCSV string, start int) (int64, int, bool) {
value, next, done := readPayoutCSVEntry(ugnotAmountCSV, start)
amount, err := strconv.ParseInt(value, 10, 64)
if err != nil || amount <= 0 {
panic("invalid payout amount")
}
return amount, next, done
}
func readPayoutCSVEntry(csv string, start int) (string, int, bool) {
end := start
for end < len(csv) && csv[end] != ',' {
end++
}
if end == start {
panic("payout entry must not be empty")
}
if end == len(csv) {
return csv[start:end], 0, true
}
next := end + 1
if next == len(csv) {
panic("payout entry must not be empty")
}
return csv[start:end], next, false
}
func GetRewardDistribution(distributionID uint64) RewardDistribution {
value, found := treeGet(rewardDistributions, distributionID)
if !found {
panic("reward distribution not found: " + strconv.FormatUint(distributionID, 10))
}
return value.(RewardDistribution)
}
func GetLatestRewardDistributionID() uint64 { return latestRewardDistributionID }
func GetRewardDistributionByOperationKey(operationKey string) RewardDistributionView {
assertKeyLength(operationKey, "operation key")
value, found := stringGet(rewardDistributionIDs, operationKey)
if !found {
panic("reward distribution not found: " + operationKey)
}
distribution := GetRewardDistribution(value.(uint64))
return RewardDistributionView{
ID: distribution.ID,
PoolKey: GetRewardPool(distribution.PoolID).PoolKey,
GameWorldID: distribution.GameWorldID,
OperationKey: distribution.OperationKey,
RecipientCount: distribution.RecipientCount,
TotalAmount: distribution.TotalAmount,
Executor: distribution.Executor,
}
}
func GetRewardDistributionCountByPool(poolID uint64) int {
GetRewardPool(poolID)
ids, found := getIDSet(poolDistributionIDs, poolID)
if !found {
return 0
}
return ids.Size()
}
func ListRewardDistributionIDsByPool(poolID uint64, page, count int) []uint64 {
GetRewardPool(poolID)
ids, _ := getIDSet(poolDistributionIDs, poolID)
return listIDs(ids, page, count)
}
func GetVaultRefund(refundID uint64) VaultRefund {
value, found := treeGet(vaultRefunds, refundID)
if !found {
panic("vault refund not found: " + strconv.FormatUint(refundID, 10))
}
return value.(VaultRefund)
}
func GetLatestVaultRefundID() uint64 { return latestVaultRefundID }
func GetVaultRefundByOperationKey(operationKey string) VaultRefund {
assertKeyLength(operationKey, "operation key")
value, found := stringGet(vaultRefundIDs, operationKey)
if !found {
panic("vault refund not found: " + operationKey)
}
return GetVaultRefund(value.(uint64))
}
func GetVaultRefundCountByPool(poolID uint64) int {
GetRewardPool(poolID)
ids, found := getIDSet(poolRefundIDs, poolID)
if !found {
return 0
}
return ids.Size()
}
func ListVaultRefundIDsByPool(poolID uint64, page, count int) []uint64 {
GetRewardPool(poolID)
ids, _ := getIDSet(poolRefundIDs, poolID)
return listIDs(ids, page, count)
}
entry.gno
package game_vault
import (
"strconv"
"gno.land/p/akkadia/beta/accesscontrol"
"gno.land/r/akkadia/beta/admin"
)
type EntryProcessStatus int
const (
EntryProcessStatusInvalid EntryProcessStatus = iota
EntryProcessStatusOpen
EntryProcessStatusClosed
EntryProcessStatusCanceled
)
type EntryFundStatus int
const (
EntryFundStatusInvalid EntryFundStatus = iota
EntryFundStatusHeld
EntryFundStatusRefunded
)
type EntryProcess struct {
ID uint64
ProcessKey string
GameWorldID uint64
EntryFee int64
Status EntryProcessStatus
HeldBalance int64
RefundedTotal int64
FundCount uint64
}
type EntryFund struct {
ID uint64
ProcessID uint64
ParticipationKey string
EntryKey string
Owner address
Amount int64
Refunded bool
}
func CreateEntryProcess(cur realm, processKey string, gameWorldID uint64, entryFeeUgnot int64) uint64 {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
assertKeyLength(processKey, "process key")
if entryProcessIDs.Has(processKey) {
panic("entry process key already exists")
}
if entryFeeUgnot <= 0 {
panic("entry fee must be positive")
}
assertGameWorldExists(gameWorldID)
if latestEntryProcessID == maxUint64 {
panic("entry process id exhausted")
}
latestEntryProcessID++
processID := latestEntryProcessID
treeSet(entryProcesses, processID, EntryProcess{
ID: processID,
ProcessKey: processKey,
GameWorldID: gameWorldID,
EntryFee: entryFeeUgnot,
Status: EntryProcessStatusOpen,
})
entryProcessIDs.Set(processKey, processID)
getOrCreateIDSet(gameWorldEntryProcessIDs, gameWorldID).Set(uint64Key(processID), true)
return processID
}
func CloseEntryProcess(cur realm, processID uint64) {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
process := GetEntryProcess(processID)
if process.Status == EntryProcessStatusClosed {
return
}
if process.Status != EntryProcessStatusOpen {
panic("entry process cannot be closed")
}
process.Status = EntryProcessStatusClosed
treeSet(entryProcesses, processID, process)
}
func CancelEntryProcess(cur realm, processID uint64) {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
process := GetEntryProcess(processID)
if process.Status == EntryProcessStatusCanceled {
return
}
if process.Status != EntryProcessStatusOpen && process.Status != EntryProcessStatusClosed {
panic("entry process cannot be canceled")
}
process.Status = EntryProcessStatusCanceled
treeSet(entryProcesses, processID, process)
}
func DepositEntry(cur realm, processID uint64, participationKey, entryKey string) uint64 {
owner := accesscontrol.MustGetUserCaller(0, cur)
assertKeyLength(participationKey, "participation key")
assertKeyLength(entryKey, "entry key")
process := GetEntryProcess(processID)
if process.Status != EntryProcessStatusOpen {
panic("entry process is not open")
}
entryIndexKey := keyedOwnerKey(processID, owner, entryKey)
if entryFundIDs.Has(entryIndexKey) {
panic("entry key already processed")
}
assertExactUgnotPayment(process.EntryFee)
if latestEntryFundID == maxUint64 || process.FundCount == maxUint64 {
panic("entry fund id exhausted")
}
if process.HeldBalance > maxInt64-process.EntryFee || accountedUgnotTotal > maxInt64-process.EntryFee {
panic("vault fund amount overflow")
}
latestEntryFundID++
fundID := latestEntryFundID
treeSet(entryFunds, fundID, EntryFund{
ID: fundID,
ProcessID: processID,
ParticipationKey: participationKey,
EntryKey: entryKey,
Owner: owner,
Amount: process.EntryFee,
})
entryFundIDs.Set(entryIndexKey, fundID)
addStringSetID(entryOwnerFundIDs, ownerKey(processID, owner), fundID)
addStringSetID(entryGroupFundIDs, keyedOwnerKey(processID, owner, participationKey), fundID)
process.HeldBalance += process.EntryFee
process.FundCount++
treeSet(entryProcesses, processID, process)
accountedUgnotTotal += process.EntryFee
return fundID
}
func RefundEntryFund(cur realm, fundID uint64, operationKey string) uint64 {
executor := accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
assertNewOperationKey(operationKey)
fund := GetEntryFund(fundID)
if fund.Refunded {
panic("entry fund already refunded")
}
process := GetEntryProcess(fund.ProcessID)
if process.Status != EntryProcessStatusOpen && process.Status != EntryProcessStatusClosed && process.Status != EntryProcessStatusCanceled {
panic("entry fund cannot be refunded")
}
if process.HeldBalance < fund.Amount {
panic("insufficient entry fund balance")
}
process.HeldBalance -= fund.Amount
process.RefundedTotal += fund.Amount
treeSet(entryProcesses, process.ID, process)
fund.Refunded = true
treeSet(entryFunds, fund.ID, fund)
return recordAndSendRefund(cross(cur), 0, operationKey, fund.EntryKey, fund.Owner, fund.Amount, "entry", executor)
}
func GetEntryProcessID(processKey string) uint64 {
assertKeyLength(processKey, "process key")
value, found := stringGet(entryProcessIDs, processKey)
if !found {
return 0
}
return value.(uint64)
}
func GetEntryProcess(processID uint64) EntryProcess {
value, found := treeGet(entryProcesses, processID)
if !found {
panic("entry process not found: " + strconv.FormatUint(processID, 10))
}
return value.(EntryProcess)
}
func GetLatestEntryProcessID() uint64 { return latestEntryProcessID }
func ListEntryRefundStates(processKeysCSV, ownersCSV, entryKeysCSV string) []map[string]string {
result := []map[string]string{}
if processKeysCSV == "" && ownersCSV == "" && entryKeysCSV == "" {
return result
}
processStart, ownerStart, entryStart := 0, 0, 0
for {
processKey, processNext, processDone := readQueryCSVEntry(processKeysCSV, processStart)
ownerValue, ownerNext, ownerDone := readQueryCSVEntry(ownersCSV, ownerStart)
entryKey, entryNext, entryDone := readQueryCSVEntry(entryKeysCSV, entryStart)
if processDone != ownerDone || ownerDone != entryDone {
panic("entry refund value count mismatch")
}
if len(result) == gameVaultList {
panic("count exceeds game vault list limit")
}
owner := address(ownerValue)
processID := GetEntryProcessID(processKey)
assertValidOwner(owner)
assertKeyLength(entryKey, "entry key")
state := map[string]string{
"requestedProcessKey": processKey,
"owner": owner.String(),
"entryKey": entryKey,
"processId": "0",
"processKey": "",
"entryFee": "0",
"processStatus": "0",
"fundId": "0",
"fundProcessId": "0",
"participationKey": "",
"fundEntryKey": "",
"fundOwner": "",
"fundAmount": "0",
"fundRefunded": "false",
}
if processID != 0 {
process := GetEntryProcess(processID)
state["processId"] = strconv.FormatUint(process.ID, 10)
state["processKey"] = process.ProcessKey
state["entryFee"] = strconv.FormatInt(process.EntryFee, 10)
state["processStatus"] = strconv.Itoa(int(process.Status))
fundID, found := stringGet(entryFundIDs, keyedOwnerKey(processID, owner, entryKey))
if found {
fund := GetEntryFund(fundID.(uint64))
state["fundId"] = strconv.FormatUint(fund.ID, 10)
state["fundProcessId"] = strconv.FormatUint(fund.ProcessID, 10)
state["participationKey"] = fund.ParticipationKey
state["fundEntryKey"] = fund.EntryKey
state["fundOwner"] = fund.Owner.String()
state["fundAmount"] = strconv.FormatInt(fund.Amount, 10)
state["fundRefunded"] = strconv.FormatBool(fund.Refunded)
}
}
result = append(result, state)
if processDone {
return result
}
processStart, ownerStart, entryStart = processNext, ownerNext, entryNext
}
}
func GetEntryFund(fundID uint64) EntryFund {
value, found := treeGet(entryFunds, fundID)
if !found {
panic("entry fund not found: " + strconv.FormatUint(fundID, 10))
}
return value.(EntryFund)
}
func GetLatestEntryFundID() uint64 { return latestEntryFundID }
func GetEntryFundStatus(fundID uint64) EntryFundStatus {
if GetEntryFund(fundID).Refunded {
return EntryFundStatusRefunded
}
return EntryFundStatusHeld
}
func GetEntryFundID(processID uint64, owner address, entryKey string) uint64 {
GetEntryProcess(processID)
assertValidOwner(owner)
assertKeyLength(entryKey, "entry key")
value, found := stringGet(entryFundIDs, keyedOwnerKey(processID, owner, entryKey))
if !found {
return 0
}
return value.(uint64)
}
func GetEntryFundCount(processID uint64, owner address, participationKey string) int {
GetEntryProcess(processID)
assertValidOwner(owner)
assertKeyLength(participationKey, "participation key")
ids, found := getStringSet(entryGroupFundIDs, keyedOwnerKey(processID, owner, participationKey))
if !found {
return 0
}
return ids.Size()
}
func ListEntryFundIDs(processID uint64, owner address, participationKey string, page, count int) []uint64 {
GetEntryProcess(processID)
assertValidOwner(owner)
assertKeyLength(participationKey, "participation key")
ids, _ := getStringSet(entryGroupFundIDs, keyedOwnerKey(processID, owner, participationKey))
return listIDs(ids, page, count)
}
func GetEntryFundCountByOwner(processID uint64, owner address) int {
GetEntryProcess(processID)
assertValidOwner(owner)
ids, found := getStringSet(entryOwnerFundIDs, ownerKey(processID, owner))
if !found {
return 0
}
return ids.Size()
}
func ListEntryFundIDsByOwner(processID uint64, owner address, page, count int) []uint64 {
GetEntryProcess(processID)
assertValidOwner(owner)
ids, _ := getStringSet(entryOwnerFundIDs, ownerKey(processID, owner))
return listIDs(ids, page, count)
}
funding.gno
package game_vault
import (
"chain"
"chain/banker"
"strconv"
"gno.land/p/akkadia/beta/accesscontrol"
"gno.land/r/akkadia/beta/admin"
)
type SystemFunding struct {
ID uint64
PoolID uint64
FundingKey string
Depositor address
Amount int64
Refunded bool
}
func DepositSystemFunding(cur realm, poolID uint64, fundingKey string) uint64 {
depositor := accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertKeyLength(fundingKey, "funding key")
if systemFundingIDs.Has(fundingKey) {
panic("funding key already processed")
}
pool := GetRewardPool(poolID)
if pool.Status != RewardPoolStatusOpen {
panic("reward pool is not open")
}
amount := getAttachedUgnotDeposit()
if latestSystemFundingID == maxUint64 {
panic("system funding id exhausted")
}
if pool.Balance > maxInt64-amount || pool.SystemFundedTotal > maxInt64-amount || accountedUgnotTotal > maxInt64-amount {
panic("vault fund amount overflow")
}
latestSystemFundingID++
fundingID := latestSystemFundingID
treeSet(systemFundings, fundingID, SystemFunding{
ID: fundingID,
PoolID: poolID,
FundingKey: fundingKey,
Depositor: depositor,
Amount: amount,
})
systemFundingIDs.Set(fundingKey, fundingID)
getOrCreateIDSet(poolSystemFundingIDs, poolID).Set(uint64Key(fundingID), true)
pool.SystemFundedTotal += amount
pool.Balance += amount
treeSet(rewardPools, poolID, pool)
accountedUgnotTotal += amount
return fundingID
}
func RefundSystemFunding(cur realm, poolID uint64, fundingKey, operationKey string) uint64 {
executor := accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
assertNewOperationKey(operationKey)
pool := GetRewardPool(poolID)
if pool.Status != RewardPoolStatusCanceled {
panic("reward pool must be canceled before refund")
}
funding := GetSystemFundingByKey(fundingKey)
if funding.PoolID != poolID {
panic("system funding belongs to another reward pool")
}
if funding.Refunded {
panic("system funding already refunded")
}
if pool.Balance < funding.Amount {
panic("insufficient system funding balance")
}
pool.Balance -= funding.Amount
pool.SystemRefundedTotal += funding.Amount
treeSet(rewardPools, poolID, pool)
funding.Refunded = true
treeSet(systemFundings, funding.ID, funding)
return recordAndSendRefund(cross(cur), poolID, operationKey, fundingKey, funding.Depositor, funding.Amount, "system", executor)
}
func GetSystemFunding(fundingID uint64) SystemFunding {
value, found := treeGet(systemFundings, fundingID)
if !found {
panic("system funding not found: " + strconv.FormatUint(fundingID, 10))
}
return value.(SystemFunding)
}
func GetLatestSystemFundingID() uint64 { return latestSystemFundingID }
func GetSystemFundingByKey(fundingKey string) SystemFunding {
assertKeyLength(fundingKey, "funding key")
value, found := stringGet(systemFundingIDs, fundingKey)
if !found {
panic("system funding not found: " + fundingKey)
}
return GetSystemFunding(value.(uint64))
}
func GetSystemFundingCountByPool(poolID uint64) int {
GetRewardPool(poolID)
ids, found := getIDSet(poolSystemFundingIDs, poolID)
if !found {
return 0
}
return ids.Size()
}
func ListSystemFundingIDsByPool(poolID uint64, page, count int) []uint64 {
GetRewardPool(poolID)
ids, _ := getIDSet(poolSystemFundingIDs, poolID)
return listIDs(ids, page, count)
}
func GetAccountedUgnotTotal() int64 { return accountedUgnotTotal }
func GetUnaccountedUgnotTotal() int64 {
actual := banker.NewReadonlyBanker().GetCoins(chain.PackageAddress("gno.land/r/akkadia/beta/game_vault")).AmountOf("ugnot")
if actual < accountedUgnotTotal {
panic("vault fund accounting exceeds realm balance")
}
return actual - accountedUgnotTotal
}
gnomod.toml
module = "gno.land/r/akkadia/beta/game_vault" gno = "0.9" [addpkg] creator = "g1ftls0ctrrj0y96sr9dq906j7gdqhg9exgcvaey" height = 747751 max_deposit = "100000000ugnot"
participation.gno
package game_vault
import (
"chain"
"chain/banker"
"strconv"
"gno.land/p/akkadia/beta/accesscontrol"
"gno.land/r/akkadia/beta/admin"
)
type ParticipationProcessStatus int
const (
ParticipationProcessStatusInvalid ParticipationProcessStatus = iota
ParticipationProcessStatusOpen
ParticipationProcessStatusClosed
ParticipationProcessStatusCommitted
ParticipationProcessStatusCanceled
)
type ParticipationFundStatus int
const (
ParticipationFundStatusInvalid ParticipationFundStatus = iota
ParticipationFundStatusHeld
ParticipationFundStatusCommitted
ParticipationFundStatusRefunded
)
type ParticipationProcess struct {
ID uint64
ProcessKey string
GameWorldID uint64
RewardPoolID uint64
ParticipationFee int64
Status ParticipationProcessStatus
HeldBalance int64
CommittedTotal int64
RefundedTotal int64
FundCount uint64
}
type ParticipationProcessView struct {
ID uint64
ProcessKey string
GameWorldID uint64
RewardPoolKey string
ParticipationFee int64
Status ParticipationProcessStatus
HeldBalance int64
CommittedTotal int64
RefundedTotal int64
FundCount uint64
}
type ParticipationFund struct {
ID uint64
ProcessID uint64
ParticipationKey string
PaymentKey string
Owner address
Amount int64
Refunded bool
}
func CreateParticipationProcess(cur realm, processKey string, gameWorldID uint64, rewardPoolKey string, participationFeeUgnot int64) uint64 {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
assertKeyLength(processKey, "process key")
assertKeyLength(rewardPoolKey, "reward pool key")
if participationProcessIDs.Has(processKey) {
panic("participation process key already exists")
}
if participationFeeUgnot <= 0 {
panic("participation fee must be positive")
}
assertGameWorldExists(gameWorldID)
rewardPoolID := GetRewardPoolID(rewardPoolKey)
if rewardPoolID == 0 {
panic("reward pool not found: " + rewardPoolKey)
}
pool := GetRewardPool(rewardPoolID)
if pool.GameWorldID != gameWorldID {
panic("reward pool belongs to another game world")
}
if pool.Status != RewardPoolStatusOpen {
panic("reward pool is not open")
}
if latestParticipationProcessID == maxUint64 {
panic("participation process id exhausted")
}
latestParticipationProcessID++
processID := latestParticipationProcessID
treeSet(participationProcesses, processID, ParticipationProcess{
ID: processID,
ProcessKey: processKey,
GameWorldID: gameWorldID,
RewardPoolID: rewardPoolID,
ParticipationFee: participationFeeUgnot,
Status: ParticipationProcessStatusOpen,
})
participationProcessIDs.Set(processKey, processID)
getOrCreateIDSet(gameWorldParticipationProcessIDs, gameWorldID).Set(uint64Key(processID), true)
return processID
}
func CloseParticipationProcess(cur realm, processID uint64) {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
process := GetParticipationProcess(processID)
if process.Status == ParticipationProcessStatusClosed {
return
}
if process.Status != ParticipationProcessStatusOpen {
panic("participation process cannot be closed")
}
process.Status = ParticipationProcessStatusClosed
treeSet(participationProcesses, processID, process)
}
func CancelParticipationProcess(cur realm, processID uint64) {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
process := GetParticipationProcess(processID)
if process.Status == ParticipationProcessStatusCanceled {
return
}
if process.Status != ParticipationProcessStatusOpen && process.Status != ParticipationProcessStatusClosed {
panic("participation process cannot be canceled")
}
process.Status = ParticipationProcessStatusCanceled
treeSet(participationProcesses, processID, process)
}
func DepositParticipation(cur realm, processID uint64, participationKey, paymentKey string) uint64 {
owner := accesscontrol.MustGetUserCaller(0, cur)
assertKeyLength(participationKey, "participation key")
assertKeyLength(paymentKey, "payment key")
process := GetParticipationProcess(processID)
if process.Status != ParticipationProcessStatusOpen {
panic("participation process is not open")
}
paymentIndexKey := keyedOwnerKey(processID, owner, paymentKey)
if participationFundIDs.Has(paymentIndexKey) {
panic("payment key already processed")
}
assertExactUgnotPayment(process.ParticipationFee)
if latestParticipationFundID == maxUint64 || process.FundCount == maxUint64 {
panic("participation fund id exhausted")
}
if process.HeldBalance > maxInt64-process.ParticipationFee || accountedUgnotTotal > maxInt64-process.ParticipationFee {
panic("vault fund amount overflow")
}
latestParticipationFundID++
fundID := latestParticipationFundID
treeSet(participationFunds, fundID, ParticipationFund{
ID: fundID,
ProcessID: processID,
ParticipationKey: participationKey,
PaymentKey: paymentKey,
Owner: owner,
Amount: process.ParticipationFee,
})
participationFundIDs.Set(paymentIndexKey, fundID)
addStringSetID(participationOwnerFundIDs, ownerKey(processID, owner), fundID)
addStringSetID(participationGroupFundIDs, keyedOwnerKey(processID, owner, participationKey), fundID)
process.HeldBalance += process.ParticipationFee
process.FundCount++
treeSet(participationProcesses, processID, process)
accountedUgnotTotal += process.ParticipationFee
return fundID
}
func RefundParticipationFund(cur realm, fundID uint64, operationKey string) uint64 {
executor := accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
assertNewOperationKey(operationKey)
fund := GetParticipationFund(fundID)
if fund.Refunded {
panic("participation fund already refunded")
}
process := GetParticipationProcess(fund.ProcessID)
if process.Status != ParticipationProcessStatusOpen && process.Status != ParticipationProcessStatusClosed && process.Status != ParticipationProcessStatusCanceled {
panic("participation fund cannot be refunded")
}
if process.HeldBalance < fund.Amount {
panic("insufficient participation fund balance")
}
process.HeldBalance -= fund.Amount
process.RefundedTotal += fund.Amount
treeSet(participationProcesses, process.ID, process)
fund.Refunded = true
treeSet(participationFunds, fund.ID, fund)
return recordAndSendRefund(cross(cur), process.RewardPoolID, operationKey, fund.PaymentKey, fund.Owner, fund.Amount, "participation", executor)
}
func CommitParticipationProcess(cur realm, processID uint64, operationKey string) {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
assertNewOperationKey(operationKey)
process := GetParticipationProcess(processID)
if process.Status != ParticipationProcessStatusClosed {
panic("participation process must be closed before commit")
}
pool := GetRewardPool(process.RewardPoolID)
if pool.Status != RewardPoolStatusOpen {
panic("reward pool is not open")
}
amount := process.HeldBalance
if pool.Balance > maxInt64-amount || pool.ParticipationCommittedTotal > maxInt64-amount || process.CommittedTotal > maxInt64-amount {
panic("vault fund amount overflow")
}
process.HeldBalance = 0
process.CommittedTotal += amount
process.Status = ParticipationProcessStatusCommitted
treeSet(participationProcesses, processID, process)
pool.ParticipationCommittedTotal += amount
pool.Balance += amount
treeSet(rewardPools, pool.ID, pool)
processedOperationKeys.Set(operationKey, processID)
}
func GetParticipationProcessID(processKey string) uint64 {
assertKeyLength(processKey, "process key")
value, found := stringGet(participationProcessIDs, processKey)
if !found {
return 0
}
return value.(uint64)
}
func GetParticipationProcess(processID uint64) ParticipationProcess {
value, found := treeGet(participationProcesses, processID)
if !found {
panic("participation process not found: " + strconv.FormatUint(processID, 10))
}
return value.(ParticipationProcess)
}
func GetParticipationProcessByKey(processKey string) ParticipationProcessView {
processID := GetParticipationProcessID(processKey)
if processID == 0 {
panic("participation process not found: " + processKey)
}
process := GetParticipationProcess(processID)
return ParticipationProcessView{
ID: process.ID,
ProcessKey: process.ProcessKey,
GameWorldID: process.GameWorldID,
RewardPoolKey: GetRewardPool(process.RewardPoolID).PoolKey,
ParticipationFee: process.ParticipationFee,
Status: process.Status,
HeldBalance: process.HeldBalance,
CommittedTotal: process.CommittedTotal,
RefundedTotal: process.RefundedTotal,
FundCount: process.FundCount,
}
}
func ListParticipationProcessStates(processKeys ...string) []map[string]string {
if len(processKeys) > gameVaultList {
panic("count exceeds game vault list limit")
}
result := []map[string]string{}
for _, processKey := range processKeys {
processID := GetParticipationProcessID(processKey)
state := map[string]string{
"requestedProcessKey": processKey,
"processId": "0",
"processKey": "",
"gameWorldId": "0",
"rewardPoolKey": "",
"participationFee": "0",
"processStatus": "0",
"heldBalance": "0",
"committedTotal": "0",
"refundedTotal": "0",
"fundCount": "0",
}
if processID != 0 {
process := GetParticipationProcess(processID)
state["processId"] = strconv.FormatUint(process.ID, 10)
state["processKey"] = process.ProcessKey
state["gameWorldId"] = strconv.FormatUint(process.GameWorldID, 10)
state["rewardPoolKey"] = GetRewardPool(process.RewardPoolID).PoolKey
state["participationFee"] = strconv.FormatInt(process.ParticipationFee, 10)
state["processStatus"] = strconv.Itoa(int(process.Status))
state["heldBalance"] = strconv.FormatInt(process.HeldBalance, 10)
state["committedTotal"] = strconv.FormatInt(process.CommittedTotal, 10)
state["refundedTotal"] = strconv.FormatInt(process.RefundedTotal, 10)
state["fundCount"] = strconv.FormatUint(process.FundCount, 10)
}
result = append(result, state)
}
return result
}
func ListParticipationPaymentStates(processKeysCSV, ownersCSV, paymentKeysCSV string) []map[string]string {
result := []map[string]string{}
if processKeysCSV == "" && ownersCSV == "" && paymentKeysCSV == "" {
return result
}
processStart, ownerStart, paymentStart := 0, 0, 0
for {
processKey, processNext, processDone := readQueryCSVEntry(processKeysCSV, processStart)
ownerValue, ownerNext, ownerDone := readQueryCSVEntry(ownersCSV, ownerStart)
paymentKey, paymentNext, paymentDone := readQueryCSVEntry(paymentKeysCSV, paymentStart)
if processDone != ownerDone || ownerDone != paymentDone {
panic("participation payment value count mismatch")
}
if len(result) == gameVaultList {
panic("count exceeds game vault list limit")
}
processID := GetParticipationProcessID(processKey)
owner := address(ownerValue)
assertValidOwner(owner)
assertKeyLength(paymentKey, "payment key")
state := map[string]string{
"requestedProcessKey": processKey,
"owner": owner.String(),
"paymentKey": paymentKey,
"processId": "0",
"processKey": "",
"participationFee": "0",
"processStatus": "0",
"fundId": "0",
"fundProcessId": "0",
"participationKey": "",
"fundPaymentKey": "",
"fundOwner": "",
"fundAmount": "0",
"fundRefunded": "false",
"fundEffectiveStatus": "0",
}
if processID != 0 {
process := GetParticipationProcess(processID)
state["processId"] = strconv.FormatUint(process.ID, 10)
state["processKey"] = process.ProcessKey
state["participationFee"] = strconv.FormatInt(process.ParticipationFee, 10)
state["processStatus"] = strconv.Itoa(int(process.Status))
fundID, found := stringGet(participationFundIDs, keyedOwnerKey(processID, owner, paymentKey))
if found {
fund := GetParticipationFund(fundID.(uint64))
state["fundId"] = strconv.FormatUint(fund.ID, 10)
state["fundProcessId"] = strconv.FormatUint(fund.ProcessID, 10)
state["participationKey"] = fund.ParticipationKey
state["fundPaymentKey"] = fund.PaymentKey
state["fundOwner"] = fund.Owner.String()
state["fundAmount"] = strconv.FormatInt(fund.Amount, 10)
state["fundRefunded"] = strconv.FormatBool(fund.Refunded)
state["fundEffectiveStatus"] = strconv.Itoa(int(GetParticipationFundEffectiveStatus(fund.ID)))
}
}
result = append(result, state)
if processDone {
return result
}
processStart, ownerStart, paymentStart = processNext, ownerNext, paymentNext
}
}
func GetLatestParticipationProcessID() uint64 { return latestParticipationProcessID }
func GetParticipationFund(fundID uint64) ParticipationFund {
value, found := treeGet(participationFunds, fundID)
if !found {
panic("participation fund not found: " + strconv.FormatUint(fundID, 10))
}
return value.(ParticipationFund)
}
func GetLatestParticipationFundID() uint64 { return latestParticipationFundID }
func GetParticipationFundEffectiveStatus(fundID uint64) ParticipationFundStatus {
fund := GetParticipationFund(fundID)
if fund.Refunded {
return ParticipationFundStatusRefunded
}
if GetParticipationProcess(fund.ProcessID).Status == ParticipationProcessStatusCommitted {
return ParticipationFundStatusCommitted
}
return ParticipationFundStatusHeld
}
func GetParticipationFundID(processID uint64, owner address, paymentKey string) uint64 {
GetParticipationProcess(processID)
assertValidOwner(owner)
assertKeyLength(paymentKey, "payment key")
value, found := stringGet(participationFundIDs, keyedOwnerKey(processID, owner, paymentKey))
if !found {
return 0
}
return value.(uint64)
}
func ListParticipationFundStates(values ...string) []map[string]string {
if len(values)%3 != 0 {
panic("participation fund value count mismatch")
}
if len(values)/3 > gameVaultList {
panic("count exceeds game vault list limit")
}
result := []map[string]string{}
for index := 0; index < len(values); index += 3 {
processID, err := strconv.ParseUint(values[index], 10, 64)
if err != nil || processID == 0 {
panic("invalid participation process id")
}
owner := address(values[index+1])
paymentKey := values[index+2]
fundID := GetParticipationFundID(processID, owner, paymentKey)
state := map[string]string{
"processId": strconv.FormatUint(processID, 10),
"owner": owner.String(),
"paymentKey": paymentKey,
"fundId": "0",
"fundProcessId": "0",
"participationKey": "",
"fundPaymentKey": "",
"fundOwner": "",
"fundAmount": "0",
"fundRefunded": "false",
"fundEffectiveStatus": "0",
}
if fundID != 0 {
fund := GetParticipationFund(fundID)
state["fundId"] = strconv.FormatUint(fund.ID, 10)
state["fundProcessId"] = strconv.FormatUint(fund.ProcessID, 10)
state["participationKey"] = fund.ParticipationKey
state["fundPaymentKey"] = fund.PaymentKey
state["fundOwner"] = fund.Owner.String()
state["fundAmount"] = strconv.FormatInt(fund.Amount, 10)
state["fundRefunded"] = strconv.FormatBool(fund.Refunded)
state["fundEffectiveStatus"] = strconv.Itoa(int(GetParticipationFundEffectiveStatus(fundID)))
}
result = append(result, state)
}
return result
}
func GetParticipationFundCount(processID uint64, owner address, participationKey string) int {
GetParticipationProcess(processID)
assertValidOwner(owner)
assertKeyLength(participationKey, "participation key")
ids, found := getStringSet(participationGroupFundIDs, keyedOwnerKey(processID, owner, participationKey))
if !found {
return 0
}
return ids.Size()
}
func ListParticipationFundIDs(processID uint64, owner address, participationKey string, page, count int) []uint64 {
GetParticipationProcess(processID)
assertValidOwner(owner)
assertKeyLength(participationKey, "participation key")
ids, _ := getStringSet(participationGroupFundIDs, keyedOwnerKey(processID, owner, participationKey))
return listIDs(ids, page, count)
}
func GetParticipationFundCountByOwner(processID uint64, owner address) int {
GetParticipationProcess(processID)
assertValidOwner(owner)
ids, found := getStringSet(participationOwnerFundIDs, ownerKey(processID, owner))
if !found {
return 0
}
return ids.Size()
}
func ListParticipationFundIDsByOwner(processID uint64, owner address, page, count int) []uint64 {
GetParticipationProcess(processID)
assertValidOwner(owner)
ids, _ := getStringSet(participationOwnerFundIDs, ownerKey(processID, owner))
return listIDs(ids, page, count)
}
func assertValidOwner(owner address) {
if !owner.IsValid() {
panic("invalid participation owner")
}
}
func sendUgnot(cur realm, recipient address, amount int64) {
accountedUgnotTotal -= amount
banker.NewBanker(banker.BankerTypeRealmSend, cur).SendCoins(cur.Address(), recipient, chain.Coins{{"ugnot", amount}})
}
refund_query.gno
package game_vault
import "strconv"
// ListRefundScopeStates returns participation process and reward pool states for refund decisions.
func ListRefundScopeStates(scopeKeys ...string) []map[string]string {
if len(scopeKeys)%2 != 0 {
panic("refund scope key count mismatch")
}
if len(scopeKeys)/2 > gameVaultList {
panic("count exceeds game vault list limit")
}
result := []map[string]string{}
for index := 0; index < len(scopeKeys); index += 2 {
processKey := scopeKeys[index]
rewardPoolKey := scopeKeys[index+1]
assertKeyLength(processKey, "process key")
assertKeyLength(rewardPoolKey, "pool key")
state := map[string]string{
"requestedProcessKey": processKey,
"requestedRewardPoolKey": rewardPoolKey,
"processId": "0",
"processKey": "",
"processGameWorldId": "0",
"processRewardPoolKey": "",
"participationFee": "0",
"processStatus": "0",
"rewardPoolId": "0",
"rewardPoolKey": "",
"rewardPoolGameWorldId": "0",
"rewardPoolStatus": "0",
}
processID := GetParticipationProcessID(processKey)
if processID != 0 {
process := GetParticipationProcess(processID)
state["processId"] = strconv.FormatUint(process.ID, 10)
state["processKey"] = process.ProcessKey
state["processGameWorldId"] = strconv.FormatUint(process.GameWorldID, 10)
state["processRewardPoolKey"] = GetRewardPool(process.RewardPoolID).PoolKey
state["participationFee"] = strconv.FormatInt(process.ParticipationFee, 10)
state["processStatus"] = strconv.Itoa(int(process.Status))
}
rewardPoolID := GetRewardPoolID(rewardPoolKey)
if rewardPoolID != 0 {
pool := GetRewardPool(rewardPoolID)
state["rewardPoolId"] = strconv.FormatUint(pool.ID, 10)
state["rewardPoolKey"] = pool.PoolKey
state["rewardPoolGameWorldId"] = strconv.FormatUint(pool.GameWorldID, 10)
state["rewardPoolStatus"] = strconv.Itoa(int(pool.Status))
}
result = append(result, state)
}
return result
}
// ListParticipationRefundStates returns fund, processed operation, and refund evidence for each participant.
func ListParticipationRefundStates(values ...string) []map[string]string {
if len(values)%4 != 0 {
panic("participation refund value count mismatch")
}
if len(values)/4 > gameVaultList {
panic("count exceeds game vault list limit")
}
result := []map[string]string{}
for index := 0; index < len(values); index += 4 {
processID, err := strconv.ParseUint(values[index], 10, 64)
if err != nil || processID == 0 {
panic("invalid participation process id")
}
owner := address(values[index+1])
paymentKey := values[index+2]
operationKey := values[index+3]
assertValidOwner(owner)
assertKeyLength(paymentKey, "payment key")
assertKeyLength(operationKey, "operation key")
state := map[string]string{
"processId": strconv.FormatUint(processID, 10),
"owner": owner.String(),
"paymentKey": paymentKey,
"operationKey": operationKey,
"fundId": "0",
"fundProcessId": "0",
"participationKey": "",
"fundPaymentKey": "",
"fundOwner": "",
"fundAmount": "0",
"fundRefunded": "false",
"fundEffectiveStatus": "0",
"operationProcessed": strconv.FormatBool(HasProcessedOperationKey(operationKey)),
"refundId": "0",
"refundPoolId": "0",
"refundOperationKey": "",
"refundSourceKey": "",
"refundRecipient": "",
"refundAmount": "0",
"refundKind": "",
}
fundID := GetParticipationFundID(processID, owner, paymentKey)
if fundID != 0 {
fund := GetParticipationFund(fundID)
state["fundId"] = strconv.FormatUint(fund.ID, 10)
state["fundProcessId"] = strconv.FormatUint(fund.ProcessID, 10)
state["participationKey"] = fund.ParticipationKey
state["fundPaymentKey"] = fund.PaymentKey
state["fundOwner"] = fund.Owner.String()
state["fundAmount"] = strconv.FormatInt(fund.Amount, 10)
state["fundRefunded"] = strconv.FormatBool(fund.Refunded)
state["fundEffectiveStatus"] = strconv.Itoa(int(GetParticipationFundEffectiveStatus(fundID)))
}
refundIDValue, found := stringGet(vaultRefundIDs, operationKey)
if found {
refund := GetVaultRefund(refundIDValue.(uint64))
state["refundId"] = strconv.FormatUint(refund.ID, 10)
state["refundPoolId"] = strconv.FormatUint(refund.PoolID, 10)
state["refundOperationKey"] = refund.OperationKey
state["refundSourceKey"] = refund.SourceKey
state["refundRecipient"] = refund.Recipient.String()
state["refundAmount"] = strconv.FormatInt(refund.Amount, 10)
state["refundKind"] = refund.Kind
}
result = append(result, state)
}
return result
}
refund_query_test.gno
package game_vault
import (
"chain"
"strconv"
"testing"
"gno.land/p/nt/uassert/v0"
)
func TestListRefundScopeStates(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
vaultTest.CreatePool(cross(cur), "pool:refund-query")
processID := vaultTest.CreateParticipationProcess(cross(cur), "process:refund-query", "pool:refund-query", 25)
states := ListRefundScopeStates(
"process:missing", "pool:missing",
"process:refund-query", "pool:refund-query",
)
uassert.Equal(t, 2, len(states))
uassert.Equal(t, "0", states[0]["processId"])
uassert.Equal(t, "0", states[0]["rewardPoolId"])
uassert.Equal(t, strconv.FormatUint(processID, 10), states[1]["processId"])
uassert.Equal(t, strconv.Itoa(int(ParticipationProcessStatusOpen)), states[1]["processStatus"])
uassert.Equal(t, strconv.Itoa(int(RewardPoolStatusOpen)), states[1]["rewardPoolStatus"])
}
func TestListParticipationRefundStates(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
poolID := vaultTest.CreatePool(cross(cur), "pool:participation-refund-query")
processID := vaultTest.CreateParticipationProcess(cross(cur), "process:participation-refund-query", "pool:participation-refund-query", 25)
fundID := vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participation:1", "payment:1", 25)
before := ListParticipationRefundStates(
strconv.FormatUint(processID, 10), vaultTest.Player1.String(), "payment:1", "refund:1",
strconv.FormatUint(processID, 10), vaultTest.Player1.String(), "payment:missing", "refund:missing",
)
uassert.Equal(t, strconv.FormatUint(fundID, 10), before[0]["fundId"])
uassert.Equal(t, strconv.Itoa(int(ParticipationFundStatusHeld)), before[0]["fundEffectiveStatus"])
uassert.Equal(t, "false", before[0]["operationProcessed"])
uassert.Equal(t, "0", before[1]["fundId"])
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
RefundParticipationFund(cross(cur), fundID, "refund:1")
after := ListParticipationRefundStates(
strconv.FormatUint(processID, 10), vaultTest.Player1.String(), "payment:1", "refund:1",
)
uassert.Equal(t, "true", after[0]["fundRefunded"])
uassert.Equal(t, "true", after[0]["operationProcessed"])
uassert.Equal(t, strconv.FormatUint(poolID, 10), after[0]["refundPoolId"])
uassert.Equal(t, "payment:1", after[0]["refundSourceKey"])
}
func TestRefundStateQueriesRejectMismatchedValues(cur realm, t *testing.T) {
uassert.PanicsWithMessage(t, cur, "refund scope key count mismatch", func() {
ListRefundScopeStates("process:1")
})
uassert.PanicsWithMessage(t, cur, "participation refund value count mismatch", func() {
ListParticipationRefundStates("1", vaultTest.Player1.String(), "payment:1")
})
scopeKeys := []string{}
refundValues := []string{}
for index := 0; index <= gameVaultList; index++ {
scopeKeys = append(scopeKeys, "process:1", "pool:1")
refundValues = append(refundValues, "1", vaultTest.Player1.String(), "payment:1", "refund:1")
}
uassert.PanicsWithMessage(t, cur, "count exceeds game vault list limit", func() {
ListRefundScopeStates(scopeKeys...)
})
uassert.PanicsWithMessage(t, cur, "count exceeds game vault list limit", func() {
ListParticipationRefundStates(refundValues...)
})
}
security_test.gno
package game_vault
import (
"chain"
"testing"
"gno.land/p/nt/uassert/v0"
)
func TestGameVaultCallerSecurity(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
testing.SetOriginCaller(vaultTest.Player1)
testing.SetRealm(testing.NewUserRealm(vaultTest.Player1))
testing.SetOriginSend(chain.Coins{})
uassert.AbortsWithMessage(t, cur, "admin or operator access required", func() {
CreateRewardPool(cross(cur), "pool:unauthorized", vaultTest.GameWorldID)
})
processID := vaultTest.CreateEntryProcess(cross(cur), "entry:security", 10)
testing.SetOriginCaller(vaultTest.Player1)
testing.SetRealm(testing.NewCodeRealm("gno.land/r/example/vault_relay"))
testing.SetOriginSend(chain.Coins{{"ugnot", 10}})
uassert.AbortsWithMessage(t, cur, "contract calls not allowed: function must be called directly by user", func() {
DepositEntry(cross(cur), processID, "participant:1", "entry:relay")
})
}
func TestParticipationRefundExcludesCommittedAmount(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
poolID := vaultTest.CreatePool(cross(cur), "pool:refund")
processID := vaultTest.CreateParticipationProcess(cross(cur), "participation:refund", "pool:refund", 10)
refundedFundID := vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participant:1", "payment:refund", 10)
committedFundID := vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participant:1", "payment:commit", 10)
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
RefundParticipationFund(cross(cur), refundedFundID, "refund:participation")
CloseParticipationProcess(cross(cur), processID)
CommitParticipationProcess(cross(cur), processID, "commit:participation")
uassert.Equal(t, int64(10), GetRewardPool(poolID).Balance)
uassert.Equal(t, int(ParticipationFundStatusRefunded), int(GetParticipationFundEffectiveStatus(refundedFundID)))
uassert.Equal(t, int(ParticipationFundStatusCommitted), int(GetParticipationFundEffectiveStatus(committedFundID)))
uassert.Equal(t, 1, GetVaultRefundCountByPool(poolID))
uassert.AbortsWithMessage(t, cur, "participation fund cannot be refunded", func() {
RefundParticipationFund(cross(cur), committedFundID, "refund:committed")
})
}
func TestSystemFundingCancellationRefundAndReplay(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
poolID := vaultTest.CreatePool(cross(cur), "pool:system-refund")
fundingID := vaultTest.DepositSystemFunding(cross(cur), poolID, "system:refund", 20)
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
CancelRewardPool(cross(cur), "pool:system-refund")
refundID := RefundSystemFunding(cross(cur), poolID, "system:refund", "refund:system")
uassert.True(t, GetSystemFunding(fundingID).Refunded)
uassert.Equal(t, int64(0), GetRewardPool(poolID).Balance)
uassert.Equal(t, refundID, GetVaultRefundByOperationKey("refund:system").ID)
uassert.AbortsWithMessage(t, cur, "operation key already processed", func() {
RefundSystemFunding(cross(cur), poolID, "system:refund", "refund:system")
})
}
setup_test.gno
package game_vault
import (
"chain"
"testing"
"gno.land/p/nt/testutils/v0"
"gno.land/r/akkadia/beta/admin"
gameworld "gno.land/r/akkadia/beta/game_world"
)
var vaultTest = &vaultTestHelper{
Admin: testutils.TestAddress("vaultAdmin"),
Operator: testutils.TestAddress("vaultOperator"),
Owner: testutils.TestAddress("vaultOwner"),
Player1: testutils.TestAddress("vaultPlayer1"),
Player2: testutils.TestAddress("vaultPlayer2"),
}
type vaultTestHelper struct {
Admin address
Operator address
Owner address
Player1 address
Player2 address
GameWorldID uint64
setupDone bool
}
func (h *vaultTestHelper) Setup(cur realm, t *testing.T) {
t.Helper()
resetGameVaultState()
testing.SetOriginSend(chain.Coins{})
if h.setupDone {
return
}
originalAdmin := admin.GetAdmin()
testing.SetOriginCaller(originalAdmin)
testing.SetRealm(testing.NewUserRealm(originalAdmin))
admin.TransferAdmin(cross(cur), h.Admin)
testing.SetOriginCaller(h.Admin)
testing.SetRealm(testing.NewUserRealm(h.Admin))
admin.AcceptAdmin(cross(cur))
admin.SetOperator(cross(cur), h.Operator)
testing.SetOriginCaller(h.Operator)
testing.SetRealm(testing.NewUserRealm(h.Operator))
gameworld.SetGameTypePolicy(cross(cur), "vault_test", 0, gameworld.CreationModePublicCreator)
testing.SetOriginCaller(h.Owner)
testing.SetRealm(testing.NewUserRealm(h.Owner))
h.GameWorldID = gameworld.CreateGameWorld(cross(cur), "vault_test")
h.setupDone = true
}
func (h *vaultTestHelper) CreatePool(cur realm, key string) uint64 {
testing.SetOriginCaller(h.Operator)
testing.SetRealm(testing.NewUserRealm(h.Operator))
testing.SetOriginSend(chain.Coins{})
return CreateRewardPool(cross(cur), key, h.GameWorldID)
}
func (h *vaultTestHelper) CreateParticipationProcess(cur realm, key, poolKey string, fee int64) uint64 {
testing.SetOriginCaller(h.Operator)
testing.SetRealm(testing.NewUserRealm(h.Operator))
testing.SetOriginSend(chain.Coins{})
return CreateParticipationProcess(cross(cur), key, h.GameWorldID, poolKey, fee)
}
func (h *vaultTestHelper) CreateEntryProcess(cur realm, key string, fee int64) uint64 {
testing.SetOriginCaller(h.Operator)
testing.SetRealm(testing.NewUserRealm(h.Operator))
testing.SetOriginSend(chain.Coins{})
return CreateEntryProcess(cross(cur), key, h.GameWorldID, fee)
}
func (h *vaultTestHelper) DepositParticipation(cur realm, owner address, processID uint64, participationKey, paymentKey string, amount int64) uint64 {
testing.SetOriginCaller(owner)
testing.SetRealm(testing.NewUserRealm(owner))
coins := chain.Coins{{"ugnot", amount}}
testing.IssueCoins(chain.PackageAddress("gno.land/r/akkadia/beta/game_vault"), coins)
testing.SetOriginSend(coins)
return DepositParticipation(cross(cur), processID, participationKey, paymentKey)
}
func (h *vaultTestHelper) DepositEntry(cur realm, owner address, processID uint64, participationKey, entryKey string, amount int64) uint64 {
testing.SetOriginCaller(owner)
testing.SetRealm(testing.NewUserRealm(owner))
coins := chain.Coins{{"ugnot", amount}}
testing.IssueCoins(chain.PackageAddress("gno.land/r/akkadia/beta/game_vault"), coins)
testing.SetOriginSend(coins)
return DepositEntry(cross(cur), processID, participationKey, entryKey)
}
func (h *vaultTestHelper) DepositSystemFunding(cur realm, poolID uint64, key string, amount int64) uint64 {
testing.SetOriginCaller(h.Operator)
testing.SetRealm(testing.NewUserRealm(h.Operator))
coins := chain.Coins{{"ugnot", amount}}
testing.IssueCoins(chain.PackageAddress("gno.land/r/akkadia/beta/game_vault"), coins)
testing.SetOriginSend(coins)
return DepositSystemFunding(cross(cur), poolID, key)
}
store.gno
package game_vault
import (
"strconv"
"gno.land/p/nt/bptree/v0"
)
var (
rewardPools *bptree.BPTree
rewardPoolIDs *bptree.BPTree
gameWorldRewardPoolIDs *bptree.BPTree
participationProcesses *bptree.BPTree
participationProcessIDs *bptree.BPTree
gameWorldParticipationProcessIDs *bptree.BPTree
participationFunds *bptree.BPTree
participationFundIDs *bptree.BPTree
participationOwnerFundIDs *bptree.BPTree
participationGroupFundIDs *bptree.BPTree
entryProcesses *bptree.BPTree
entryProcessIDs *bptree.BPTree
gameWorldEntryProcessIDs *bptree.BPTree
entryFunds *bptree.BPTree
entryFundIDs *bptree.BPTree
entryOwnerFundIDs *bptree.BPTree
entryGroupFundIDs *bptree.BPTree
systemFundings *bptree.BPTree
systemFundingIDs *bptree.BPTree
poolSystemFundingIDs *bptree.BPTree
rewardDistributions *bptree.BPTree
rewardDistributionIDs *bptree.BPTree
poolDistributionIDs *bptree.BPTree
vaultRefunds *bptree.BPTree
vaultRefundIDs *bptree.BPTree
poolRefundIDs *bptree.BPTree
processedOperationKeys *bptree.BPTree
latestRewardPoolID uint64
latestParticipationProcessID uint64
latestParticipationFundID uint64
latestEntryProcessID uint64
latestEntryFundID uint64
latestSystemFundingID uint64
latestRewardDistributionID uint64
latestVaultRefundID uint64
accountedUgnotTotal int64
)
func init() {
resetGameVaultState()
}
func resetGameVaultState() {
rewardPools = bptree.NewBPTree32()
rewardPoolIDs = bptree.NewBPTree32()
gameWorldRewardPoolIDs = bptree.NewBPTree32()
participationProcesses = bptree.NewBPTree32()
participationProcessIDs = bptree.NewBPTree32()
gameWorldParticipationProcessIDs = bptree.NewBPTree32()
participationFunds = bptree.NewBPTree32()
participationFundIDs = bptree.NewBPTree32()
participationOwnerFundIDs = bptree.NewBPTree32()
participationGroupFundIDs = bptree.NewBPTree32()
entryProcesses = bptree.NewBPTree32()
entryProcessIDs = bptree.NewBPTree32()
gameWorldEntryProcessIDs = bptree.NewBPTree32()
entryFunds = bptree.NewBPTree32()
entryFundIDs = bptree.NewBPTree32()
entryOwnerFundIDs = bptree.NewBPTree32()
entryGroupFundIDs = bptree.NewBPTree32()
systemFundings = bptree.NewBPTree32()
systemFundingIDs = bptree.NewBPTree32()
poolSystemFundingIDs = bptree.NewBPTree32()
rewardDistributions = bptree.NewBPTree32()
rewardDistributionIDs = bptree.NewBPTree32()
poolDistributionIDs = bptree.NewBPTree32()
vaultRefunds = bptree.NewBPTree32()
vaultRefundIDs = bptree.NewBPTree32()
poolRefundIDs = bptree.NewBPTree32()
processedOperationKeys = bptree.NewBPTree32()
latestRewardPoolID = 0
latestParticipationProcessID = 0
latestParticipationFundID = 0
latestEntryProcessID = 0
latestEntryFundID = 0
latestSystemFundingID = 0
latestRewardDistributionID = 0
latestVaultRefundID = 0
accountedUgnotTotal = 0
distributionBatchMax = distributionBatchMaxDefault
}
func ownerKey(processID uint64, owner address) string {
return strconv.FormatUint(processID, 10) + ":" + owner.String()
}
func keyedOwnerKey(processID uint64, owner address, key string) string {
return ownerKey(processID, owner) + ":" + key
}
func uint64Key(id uint64) string {
// Zero-pad so BPTree key order matches numeric ID order.
s := strconv.FormatUint(id, 10)
if len(s) >= 20 {
return s
}
return "00000000000000000000"[len(s):] + s
}
func parseUint64Key(key string) uint64 {
id, err := strconv.ParseUint(key, 10, 64)
if err != nil {
panic("invalid uint64 key: " + key)
}
return id
}
func treeGet(store *bptree.BPTree, id uint64) (any, bool) {
key := uint64Key(id)
if !store.Has(key) {
return nil, false
}
return store.Get(key), true
}
func treeSet(store *bptree.BPTree, id uint64, value any) {
store.Set(uint64Key(id), value)
}
func stringGet(store *bptree.BPTree, key string) (any, bool) {
if !store.Has(key) {
return nil, false
}
return store.Get(key), true
}
func addStringSetID(store *bptree.BPTree, key string, id uint64) {
value := store.Get(key)
var ids *bptree.BPTree
if value != nil {
ids = value.(*bptree.BPTree)
} else {
ids = bptree.NewBPTree32()
store.Set(key, ids)
}
ids.Set(uint64Key(id), true)
}
func getStringSet(store *bptree.BPTree, key string) (*bptree.BPTree, bool) {
value := store.Get(key)
if value == nil {
return nil, false
}
return value.(*bptree.BPTree), true
}
func getOrCreateIDSet(store *bptree.BPTree, key uint64) *bptree.BPTree {
value := store.Get(uint64Key(key))
if value != nil {
return value.(*bptree.BPTree)
}
ids := bptree.NewBPTree32()
store.Set(uint64Key(key), ids)
return ids
}
func getIDSet(store *bptree.BPTree, key uint64) (*bptree.BPTree, bool) {
value := store.Get(uint64Key(key))
if value == nil {
return nil, false
}
return value.(*bptree.BPTree), true
}
func listIDs(ids *bptree.BPTree, page, count int) []uint64 {
assertPageCount(page, count)
result := []uint64{}
if ids == nil {
return result
}
ids.ReverseIterateByOffset((page-1)*count, count, func(key string, _ any) bool {
result = append(result, parseUint64Key(key))
return false
})
return result
}
validation.gno
package game_vault
func readQueryCSVEntry(csv string, start int) (string, int, bool) {
end := start
for end < len(csv) && csv[end] != ',' {
end++
}
return csv[start:end], end + 1, end == len(csv)
}
vault.gno
package game_vault
import (
"chain/runtime/unsafe"
"strconv"
"gno.land/p/akkadia/beta/accesscontrol"
"gno.land/r/akkadia/beta/admin"
gameworld "gno.land/r/akkadia/beta/game_world"
)
const (
maxInt64 = int64(9223372036854775807)
maxUint64 = uint64(18446744073709551615)
gameVaultList = 100
)
type RewardPoolStatus int
const (
RewardPoolStatusInvalid RewardPoolStatus = iota
RewardPoolStatusOpen
RewardPoolStatusLocked
RewardPoolStatusSettled
RewardPoolStatusCanceled
)
type RewardPool struct {
ID uint64
PoolKey string
GameWorldID uint64
Status RewardPoolStatus
ParticipationCommittedTotal int64
SystemFundedTotal int64
SystemRefundedTotal int64
DistributedTotal int64
Balance int64
DistributionCount uint64
}
type RewardPoolView struct {
PoolKey string
GameWorldID uint64
Status RewardPoolStatus
ParticipationCommittedTotal int64
DistributedTotal int64
Balance int64
DistributionCount uint64
}
func CreateRewardPool(cur realm, poolKey string, gameWorldID uint64) uint64 {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
assertKeyLength(poolKey, "pool key")
if rewardPoolIDs.Has(poolKey) {
panic("reward pool key already exists")
}
assertGameWorldExists(gameWorldID)
if latestRewardPoolID == maxUint64 {
panic("reward pool id exhausted")
}
latestRewardPoolID++
poolID := latestRewardPoolID
treeSet(rewardPools, poolID, RewardPool{
ID: poolID,
PoolKey: poolKey,
GameWorldID: gameWorldID,
Status: RewardPoolStatusOpen,
})
rewardPoolIDs.Set(poolKey, poolID)
getOrCreateIDSet(gameWorldRewardPoolIDs, gameWorldID).Set(uint64Key(poolID), true)
return poolID
}
func LockRewardPool(cur realm, poolKey string) {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
poolID, pool := mustGetRewardPoolByKey(poolKey)
if pool.Status == RewardPoolStatusLocked {
return
}
if pool.Status != RewardPoolStatusOpen {
panic("reward pool cannot be locked")
}
pool.Status = RewardPoolStatusLocked
treeSet(rewardPools, poolID, pool)
}
func CancelRewardPool(cur realm, poolKey string) {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
poolID, pool := mustGetRewardPoolByKey(poolKey)
if pool.Status == RewardPoolStatusCanceled {
return
}
if pool.Status != RewardPoolStatusOpen {
panic("reward pool cannot be canceled")
}
if pool.ParticipationCommittedTotal != 0 || pool.DistributedTotal != 0 {
panic("reward pool with committed funds cannot be canceled")
}
pool.Status = RewardPoolStatusCanceled
treeSet(rewardPools, poolID, pool)
}
func SettleRewardPool(cur realm, poolKey string) {
accesscontrol.MustGetAdminOrOperatorCaller(0, cur, admin.IsAdmin, admin.IsOperator)
assertNoAttachedCoins()
poolID, pool := mustGetRewardPoolByKey(poolKey)
if pool.Status == RewardPoolStatusSettled {
return
}
if pool.Status != RewardPoolStatusLocked {
panic("reward pool must be locked before settlement")
}
if pool.Balance != 0 {
panic("reward pool balance must be zero before settlement")
}
pool.Status = RewardPoolStatusSettled
treeSet(rewardPools, poolID, pool)
}
func GetRewardPoolID(poolKey string) uint64 {
assertKeyLength(poolKey, "pool key")
value, found := stringGet(rewardPoolIDs, poolKey)
if !found {
return 0
}
return value.(uint64)
}
func GetRewardPool(poolID uint64) RewardPool {
value, found := treeGet(rewardPools, poolID)
if !found {
panic("reward pool not found: " + strconv.FormatUint(poolID, 10))
}
return value.(RewardPool)
}
func GetRewardPoolByKey(poolKey string) RewardPoolView {
_, pool := mustGetRewardPoolByKey(poolKey)
return RewardPoolView{
PoolKey: pool.PoolKey,
GameWorldID: pool.GameWorldID,
Status: pool.Status,
ParticipationCommittedTotal: pool.ParticipationCommittedTotal,
DistributedTotal: pool.DistributedTotal,
Balance: pool.Balance,
DistributionCount: pool.DistributionCount,
}
}
func mustGetRewardPoolByKey(poolKey string) (uint64, RewardPool) {
poolID := GetRewardPoolID(poolKey)
if poolID == 0 {
panic("reward pool not found: " + poolKey)
}
return poolID, GetRewardPool(poolID)
}
func GetLatestRewardPoolID() uint64 { return latestRewardPoolID }
func GetRewardPoolCountByGameWorld(gameWorldID uint64) int {
ids, found := getIDSet(gameWorldRewardPoolIDs, gameWorldID)
if !found {
return 0
}
return ids.Size()
}
func ListRewardPoolIDsByGameWorld(gameWorldID uint64, page, count int) []uint64 {
ids, _ := getIDSet(gameWorldRewardPoolIDs, gameWorldID)
return listIDs(ids, page, count)
}
func assertGameWorldExists(gameWorldID uint64) {
if !gameworld.HasGameWorld(gameWorldID) {
panic("game world not found: " + strconv.FormatUint(gameWorldID, 10))
}
}
func assertNoAttachedCoins() {
if len(unsafe.OriginSend()) != 0 {
panic("attached coins not allowed")
}
}
func assertExactUgnotPayment(expected int64) {
coins := unsafe.OriginSend()
if len(coins) != 1 || coins[0].Denom != "ugnot" || coins[0].Amount != expected {
panic("exact payment required: expected " + strconv.FormatInt(expected, 10) + "ugnot, got " + coins.String())
}
}
func getAttachedUgnotDeposit() int64 {
coins := unsafe.OriginSend()
if len(coins) != 1 || coins[0].Denom != "ugnot" || coins[0].Amount <= 0 {
panic("positive ugnot deposit required")
}
return coins[0].Amount
}
func assertKeyLength(value, name string) {
if len(value) < 1 || len(value) > 128 {
panic(name + " length must be between 1 and 128")
}
}
func assertPageCount(page, count int) {
if page < 1 {
panic("page must be at least 1")
}
if count < 1 {
panic("count must be at least 1")
}
if count > gameVaultList {
panic("count exceeds game vault list limit")
}
}
func assertNewOperationKey(operationKey string) {
assertKeyLength(operationKey, "operation key")
if processedOperationKeys.Has(operationKey) {
panic("operation key already processed")
}
}
func HasProcessedOperationKey(operationKey string) bool {
return processedOperationKeys.Has(operationKey)
}
vault_test.gno
package game_vault
import (
"chain"
"strconv"
"strings"
"testing"
"gno.land/p/nt/uassert/v0"
)
func TestParticipationProcessFundingAndSettlement(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
poolID := vaultTest.CreatePool(cross(cur), "pool:1")
processID := vaultTest.CreateParticipationProcess(cross(cur), "participation:1", "pool:1", 25)
firstFundID := vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participant:1", "payment:1", 25)
secondFundID := vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participant:1", "payment:2", 25)
vaultTest.DepositParticipation(cross(cur), vaultTest.Player2, processID, "participant:1", "payment:1", 25)
uassert.Equal(t, firstFundID, GetParticipationFundID(processID, vaultTest.Player1, "payment:1"))
uassert.Equal(t, 2, GetParticipationFundCount(processID, vaultTest.Player1, "participant:1"))
ids := ListParticipationFundIDs(processID, vaultTest.Player1, "participant:1", 1, 10)
uassert.Equal(t, 2, len(ids))
uassert.Equal(t, secondFundID, ids[0])
uassert.Equal(t, firstFundID, ids[1])
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
CloseParticipationProcess(cross(cur), processID)
CommitParticipationProcess(cross(cur), processID, "commit:1")
uassert.Equal(t, int(ParticipationProcessStatusCommitted), int(GetParticipationProcess(processID).Status))
processView := GetParticipationProcessByKey("participation:1")
uassert.Equal(t, "pool:1", processView.RewardPoolKey)
uassert.Equal(t, int(ParticipationFundStatusCommitted), int(GetParticipationFundEffectiveStatus(firstFundID)))
uassert.Equal(t, int64(75), GetRewardPool(poolID).Balance)
vaultTest.DepositSystemFunding(cross(cur), poolID, "system:1", 25)
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
LockRewardPool(cross(cur), "pool:1")
DistributeReward(cross(cur), "pool:1", "distribution:1", vaultTest.Player2.String(), "100")
distributionView := GetRewardDistributionByOperationKey("distribution:1")
uassert.Equal(t, "pool:1", distributionView.PoolKey)
SettleRewardPool(cross(cur), "pool:1")
uassert.Equal(t, int(RewardPoolStatusSettled), int(GetRewardPoolByKey("pool:1").Status))
}
func TestListParticipationProcessStates(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
vaultTest.CreatePool(cross(cur), "pool:process-states")
processID := vaultTest.CreateParticipationProcess(cross(cur), "process:states", "pool:process-states", 25)
states := ListParticipationProcessStates("process:missing", "process:states")
uassert.Equal(t, 2, len(states))
uassert.Equal(t, "0", states[0]["processId"])
uassert.Equal(t, strconv.FormatUint(processID, 10), states[1]["processId"])
uassert.Equal(t, "pool:process-states", states[1]["rewardPoolKey"])
uassert.Equal(t, "25", states[1]["participationFee"])
}
func TestListParticipationFundStates(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
vaultTest.CreatePool(cross(cur), "pool:fund-states")
processID := vaultTest.CreateParticipationProcess(cross(cur), "process:fund-states", "pool:fund-states", 25)
fundID := vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participation:1", "payment:1", 25)
states := ListParticipationFundStates(
strconv.FormatUint(processID, 10), vaultTest.Player1.String(), "payment:missing",
strconv.FormatUint(processID, 10), vaultTest.Player1.String(), "payment:1",
)
uassert.Equal(t, 2, len(states))
uassert.Equal(t, "0", states[0]["fundId"])
uassert.Equal(t, strconv.FormatUint(fundID, 10), states[1]["fundId"])
uassert.Equal(t, strconv.Itoa(int(ParticipationFundStatusHeld)), states[1]["fundEffectiveStatus"])
}
func TestParticipationStateQueriesRejectInvalidBatch(cur realm, t *testing.T) {
uassert.PanicsWithMessage(t, cur, "participation fund value count mismatch", func() {
ListParticipationFundStates("1", vaultTest.Player1.String())
})
processKeys := []string{}
fundValues := []string{}
for index := 0; index <= gameVaultList; index++ {
processKeys = append(processKeys, "process:1")
fundValues = append(fundValues, "1", vaultTest.Player1.String(), "payment:1")
}
uassert.PanicsWithMessage(t, cur, "count exceeds game vault list limit", func() {
ListParticipationProcessStates(processKeys...)
})
uassert.PanicsWithMessage(t, cur, "count exceeds game vault list limit", func() {
ListParticipationFundStates(fundValues...)
})
}
func TestListEntryRefundStates(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
processID := vaultTest.CreateEntryProcess(cross(cur), "entry:states", 25)
fundID := vaultTest.DepositEntry(cross(cur), vaultTest.Player1, processID, "participation:1", "entry:1", 25)
states := ListEntryRefundStates(
"entry:missing,entry:states,entry:states,entry:states",
strings.Repeat(vaultTest.Player1.String()+",", 3)+vaultTest.Player1.String(),
"entry:1,entry:missing,entry:1,entry:1",
)
uassert.Equal(t, 4, len(states))
uassert.Equal(t, "entry:missing", states[0]["requestedProcessKey"])
uassert.Equal(t, "0", states[0]["processId"])
uassert.Equal(t, "0", states[0]["fundId"])
uassert.Equal(t, strconv.FormatUint(processID, 10), states[1]["processId"])
uassert.Equal(t, "0", states[1]["fundId"])
uassert.Equal(t, "25", states[2]["entryFee"])
uassert.Equal(t, strconv.FormatUint(fundID, 10), states[2]["fundId"])
uassert.Equal(t, vaultTest.Player1.String(), states[2]["fundOwner"])
uassert.Equal(t, "entry:1", states[2]["fundEntryKey"])
uassert.Equal(t, "participation:1", states[2]["participationKey"])
uassert.Equal(t, "false", states[2]["fundRefunded"])
states[2]["fundOwner"] = "changed"
uassert.Equal(t, vaultTest.Player1.String(), states[3]["fundOwner"])
uassert.Equal(t, vaultTest.Player1, GetEntryFund(fundID).Owner)
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
RefundEntryFund(cross(cur), fundID, "refund:entry-states")
states = ListEntryRefundStates("entry:states", vaultTest.Player1.String(), "entry:1")
uassert.Equal(t, "true", states[0]["fundRefunded"])
uassert.Equal(t, "25", states[0]["fundAmount"])
}
func TestPaymentStateQueriesCSV(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
queries := []struct {
query func(string, string, string) []map[string]string
mismatch string
keyName string
}{
{ListEntryRefundStates, "entry refund value count mismatch", "entry key"},
{ListParticipationPaymentStates, "participation payment value count mismatch", "payment key"},
}
for _, item := range queries {
uassert.Equal(t, 0, len(item.query("", "", "")))
uassert.PanicsWithMessage(t, cur, item.mismatch, func() {
item.query("missing,missing", vaultTest.Player1.String(), "key")
})
uassert.PanicsWithMessage(t, cur, "process key length must be between 1 and 128", func() {
item.query("", vaultTest.Player1.String(), "key")
})
uassert.PanicsWithMessage(t, cur, "invalid participation owner", func() {
item.query("missing", "invalid", "key")
})
uassert.PanicsWithMessage(t, cur, item.keyName+" length must be between 1 and 128", func() {
item.query("missing", vaultTest.Player1.String(), "")
})
uassert.PanicsWithMessage(t, cur, "process key length must be between 1 and 128", func() {
item.query("missing,", vaultTest.Player1.String()+",", "key,")
})
uassert.PanicsWithMessage(t, cur, "process key length must be between 1 and 128", func() {
item.query("missing,,missing", strings.Repeat(vaultTest.Player1.String()+",", 2)+vaultTest.Player1.String(), "key,key,key")
})
processes := strings.Repeat("missing,", gameVaultList-1) + "missing"
owners := strings.Repeat(vaultTest.Player1.String()+",", gameVaultList-1) + vaultTest.Player1.String()
keys := strings.Repeat("key,", gameVaultList-1) + "key"
uassert.Equal(t, gameVaultList, len(item.query(processes, owners, keys)))
uassert.PanicsWithMessage(t, cur, "count exceeds game vault list limit", func() {
item.query(processes+",missing", owners+","+vaultTest.Player1.String(), keys+",key")
})
}
}
func TestListParticipationPaymentStates(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
vaultTest.CreatePool(cross(cur), "pool:payment-states")
processID := vaultTest.CreateParticipationProcess(cross(cur), "process:states", "pool:payment-states", 25)
fundID := vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participation:1", "payment:1", 25)
states := ListParticipationPaymentStates(
"process:missing,process:states,process:states,process:states",
strings.Repeat(vaultTest.Player1.String()+",", 3)+vaultTest.Player1.String(),
"payment:1,payment:missing,payment:1,payment:1",
)
uassert.Equal(t, 4, len(states))
uassert.Equal(t, "process:missing", states[0]["requestedProcessKey"])
uassert.Equal(t, "0", states[0]["processId"])
uassert.Equal(t, "0", states[0]["fundId"])
uassert.Equal(t, strconv.FormatUint(processID, 10), states[1]["processId"])
uassert.Equal(t, "0", states[1]["fundId"])
uassert.Equal(t, "25", states[2]["participationFee"])
uassert.Equal(t, strconv.FormatUint(fundID, 10), states[2]["fundId"])
uassert.Equal(t, "payment:1", states[2]["fundPaymentKey"])
uassert.Equal(t, "participation:1", states[2]["participationKey"])
uassert.Equal(t, "1", states[2]["fundEffectiveStatus"])
states[2]["fundOwner"] = "changed"
uassert.Equal(t, vaultTest.Player1.String(), states[3]["fundOwner"])
uassert.Equal(t, vaultTest.Player1, GetParticipationFund(fundID).Owner)
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
RefundParticipationFund(cross(cur), fundID, "refund:payment-states")
states = ListParticipationPaymentStates("process:states", vaultTest.Player1.String(), "payment:1")
uassert.Equal(t, "true", states[0]["fundRefunded"])
uassert.Equal(t, "3", states[0]["fundEffectiveStatus"])
CloseParticipationProcess(cross(cur), processID)
CommitParticipationProcess(cross(cur), processID, "commit:payment-states")
states = ListParticipationPaymentStates("process:states", vaultTest.Player1.String(), "payment:1")
uassert.Equal(t, "3", states[0]["processStatus"])
uassert.Equal(t, "3", states[0]["fundEffectiveStatus"])
}
func TestParticipationPaymentValidation(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
vaultTest.CreatePool(cross(cur), "pool:validation")
processID := vaultTest.CreateParticipationProcess(cross(cur), "participation:validation", "pool:validation", 25)
uassert.AbortsWithMessage(t, cur, "exact payment required: expected 25ugnot, got 24ugnot", func() {
vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participant:1", "payment:under", 24)
})
uassert.AbortsWithMessage(t, cur, "exact payment required: expected 25ugnot, got 26ugnot", func() {
vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participant:1", "payment:over", 26)
})
testing.SetOriginCaller(vaultTest.Player1)
testing.SetRealm(testing.NewUserRealm(vaultTest.Player1))
wrongDenom := chain.Coins{{"utest", 25}}
testing.IssueCoins(chain.PackageAddress("gno.land/r/akkadia/beta/game_vault"), wrongDenom)
testing.SetOriginSend(wrongDenom)
uassert.AbortsWithMessage(t, cur, "exact payment required: expected 25ugnot, got 25utest", func() {
DepositParticipation(cross(cur), processID, "participant:1", "payment:wrong-denom")
})
vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participant:1", "payment:1", 25)
uassert.AbortsWithMessage(t, cur, "payment key already processed", func() {
vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participant:2", "payment:1", 25)
})
}
func TestVaultRejectsUnexpectedCoinsAndOverflow(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
coins := chain.Coins{{"ugnot", 1}}
testing.IssueCoins(chain.PackageAddress("gno.land/r/akkadia/beta/game_vault"), coins)
testing.SetOriginSend(coins)
uassert.AbortsWithMessage(t, cur, "attached coins not allowed", func() {
CreateRewardPool(cross(cur), "pool:coins", vaultTest.GameWorldID)
})
vaultTest.CreatePool(cross(cur), "pool:overflow")
processID := vaultTest.CreateParticipationProcess(cross(cur), "participation:overflow", "pool:overflow", 1)
accountedUgnotTotal = maxInt64
uassert.AbortsWithMessage(t, cur, "vault fund amount overflow", func() {
vaultTest.DepositParticipation(cross(cur), vaultTest.Player1, processID, "participant:1", "payment:overflow", 1)
})
}
func TestVaultRejectsMissingGameWorld(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
uassert.AbortsWithMessage(t, cur, "game world not found: 2", func() {
CreateRewardPool(cross(cur), "pool:missing-world", vaultTest.GameWorldID+1)
})
}
func TestParticipationProcessRequiresRewardPoolKey(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
uassert.AbortsWithMessage(t, cur, "reward pool not found: pool:missing", func() {
vaultTest.CreateParticipationProcess(cross(cur), "participation:missing", "pool:missing", 10)
})
}
func TestEntryProcessFundingAndRefund(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
processID := vaultTest.CreateEntryProcess(cross(cur), "entry:1", 10)
firstFundID := vaultTest.DepositEntry(cross(cur), vaultTest.Player1, processID, "participant:1", "entry:1", 10)
secondFundID := vaultTest.DepositEntry(cross(cur), vaultTest.Player1, processID, "participant:1", "entry:2", 10)
vaultTest.DepositEntry(cross(cur), vaultTest.Player2, processID, "participant:1", "entry:1", 10)
uassert.Equal(t, firstFundID, GetEntryFundID(processID, vaultTest.Player1, "entry:1"))
uassert.Equal(t, 2, GetEntryFundCount(processID, vaultTest.Player1, "participant:1"))
ids := ListEntryFundIDs(processID, vaultTest.Player1, "participant:1", 1, 10)
uassert.Equal(t, 2, len(ids))
uassert.Equal(t, secondFundID, ids[0])
uassert.Equal(t, firstFundID, ids[1])
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
CloseEntryProcess(cross(cur), processID)
RefundEntryFund(cross(cur), firstFundID, "entry-refund:1")
uassert.Equal(t, int(EntryFundStatusRefunded), int(GetEntryFundStatus(firstFundID)))
uassert.Equal(t, int64(20), GetEntryProcess(processID).HeldBalance)
}
func TestEntryProcessValidationAndCancel(cur realm, t *testing.T) {
vaultTest.Setup(cross(cur), t)
uassert.AbortsWithMessage(t, cur, "entry fee must be positive", func() {
vaultTest.CreateEntryProcess(cross(cur), "entry:free", 0)
})
processID := vaultTest.CreateEntryProcess(cross(cur), "entry:cancel", 10)
vaultTest.DepositEntry(cross(cur), vaultTest.Player1, processID, "participant:1", "entry:1", 10)
uassert.AbortsWithMessage(t, cur, "entry key already processed", func() {
vaultTest.DepositEntry(cross(cur), vaultTest.Player1, processID, "participant:2", "entry:1", 10)
})
testing.SetOriginCaller(vaultTest.Operator)
testing.SetRealm(testing.NewUserRealm(vaultTest.Operator))
testing.SetOriginSend(chain.Coins{})
CancelEntryProcess(cross(cur), processID)
uassert.Equal(t, int(EntryProcessStatusCanceled), int(GetEntryProcess(processID).Status))
uassert.AbortsWithMessage(t, cur, "entry process is not open", func() {
vaultTest.DepositEntry(cross(cur), vaultTest.Player2, processID, "participant:2", "entry:2", 10)
})
}