/
abci.go
140 lines (125 loc) · 4.08 KB
/
abci.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
package likenft
import (
"fmt"
"time"
"github.com/cosmos/cosmos-sdk/telemetry"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/likecoin/likecoin-chain/v4/x/likenft/keeper"
"github.com/likecoin/likecoin-chain/v4/x/likenft/types"
)
func tryRevealClassCatchPanic(ctx sdk.Context, keeper keeper.Keeper, classId string) (err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%s", r)
}
}()
err = keeper.RevealBlindBoxContents(ctx, classId)
return
}
func processClassRevealQueue(ctx sdk.Context, keeper keeper.Keeper) {
// Reveal classes with reveal time < current block header time
keeper.IterateClassRevealQueueByTime(ctx, ctx.BlockHeader().Time, func(entry types.ClassRevealQueueEntry) (stop bool) {
err := tryRevealClassCatchPanic(ctx, keeper, entry.ClassId)
if err != nil {
ctx.EventManager().EmitTypedEvent(&types.EventRevealClass{
ClassId: entry.ClassId,
Success: false,
Error: err.Error(),
})
} else {
ctx.EventManager().EmitTypedEvent(&types.EventRevealClass{
ClassId: entry.ClassId,
Success: true,
})
}
keeper.RemoveClassRevealQueueEntry(ctx, entry.RevealTime, entry.ClassId)
return false
})
}
func tryExpireOfferCatchPanic(ctx sdk.Context, keeper keeper.Keeper, offer types.OfferStoreRecord) (err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%s", r)
}
}()
err = keeper.ExpireOffer(ctx, offer)
return
}
func processOfferExpireQueue(ctx sdk.Context, keeper keeper.Keeper) {
// Expire offers with expiration time < current block header time
keeper.IterateOfferExpireQueueByTime(ctx, ctx.BlockHeader().Time, func(val types.OfferExpireQueueEntry) (stop bool) {
// Get offer
offer, found := keeper.GetOfferByKeyBytes(ctx, val.OfferKey)
if !found {
// offer not found, dequeue and continue
keeper.RemoveOfferExpireQueueEntry(ctx, val.ExpireTime, val.OfferKey)
return false
}
err := tryExpireOfferCatchPanic(ctx, keeper, offer)
if err != nil {
ctx.EventManager().EmitTypedEvent(&types.EventExpireOffer{
ClassId: offer.ClassId,
NftId: offer.NftId,
Buyer: offer.Buyer.String(),
Success: false,
Error: err.Error(),
})
} else {
ctx.EventManager().EmitTypedEvent(&types.EventExpireOffer{
ClassId: offer.ClassId,
NftId: offer.NftId,
Buyer: offer.Buyer.String(),
Success: true,
})
}
keeper.RemoveOfferExpireQueueEntry(ctx, val.ExpireTime, val.OfferKey)
return false
})
}
func tryExpireListingCatchPanic(ctx sdk.Context, keeper keeper.Keeper, listing types.ListingStoreRecord) (err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("%s", r)
}
}()
err = keeper.ExpireListing(ctx, listing)
return
}
func processListingExpireQueue(ctx sdk.Context, keeper keeper.Keeper) {
// Expire listings with expiration time < current block header time
keeper.IterateListingExpireQueueByTime(ctx, ctx.BlockHeader().Time, func(val types.ListingExpireQueueEntry) (stop bool) {
// Get listing
listing, found := keeper.GetListingByKeyBytes(ctx, val.ListingKey)
if !found {
// listing not found, dequeue and continue
keeper.RemoveListingExpireQueueEntry(ctx, val.ExpireTime, val.ListingKey)
return false
}
err := tryExpireListingCatchPanic(ctx, keeper, listing)
if err != nil {
ctx.EventManager().EmitTypedEvent(&types.EventExpireListing{
ClassId: listing.ClassId,
NftId: listing.NftId,
Seller: listing.Seller.String(),
Success: false,
Error: err.Error(),
})
} else {
ctx.EventManager().EmitTypedEvent(&types.EventExpireListing{
ClassId: listing.ClassId,
NftId: listing.NftId,
Seller: listing.Seller.String(),
Success: true,
})
}
keeper.RemoveListingExpireQueueEntry(ctx, val.ExpireTime, val.ListingKey)
return false
})
}
// EndBlocker called every block, process class reveal queue.
func EndBlocker(ctx sdk.Context, keeper keeper.Keeper) {
defer telemetry.ModuleMeasureSince(types.ModuleName, time.Now(), telemetry.MetricKeyEndBlocker)
processClassRevealQueue(ctx, keeper)
processOfferExpireQueue(ctx, keeper)
processListingExpireQueue(ctx, keeper)
}