-
Notifications
You must be signed in to change notification settings - Fork 119
/
msg_server.go
120 lines (104 loc) · 4.35 KB
/
msg_server.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
package keeper
import (
"context"
"fmt"
"strconv"
dispensationUtils "github.com/Sifchain/sifnode/x/dispensation/utils"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/pkg/errors"
"github.com/Sifchain/sifnode/x/dispensation/types"
)
type msgServer struct {
Keeper
}
// NewMsgServerImpl returns an implementation of the clp MsgServer interface
// for the provided Keeper.
func NewMsgServerImpl(keeper Keeper) types.MsgServer {
return &msgServer{Keeper: keeper}
}
var _ types.MsgServer = msgServer{}
func (srv msgServer) CreateDistribution(ctx context.Context,
msg *types.MsgCreateDistribution) (*types.MsgCreateDistributionResponse, error) {
sdkCtx := sdk.UnwrapSDKContext(ctx)
distributionName := fmt.Sprintf("%d_%s", sdkCtx.BlockHeight(), msg.Distributor)
// Verify if distribution already exists
err := srv.Keeper.VerifyAndSetDistribution(sdkCtx, distributionName, msg.DistributionType, msg.AuthorizedRunner)
if err != nil {
return nil, err
}
totalOutput, err := dispensationUtils.TotalOutput(msg.Output)
if err != nil {
return nil, errors.Wrap(err, "Error calculating required amount from outputs")
}
//Accumulate all Drops into the ModuleAccount
err = srv.Keeper.AccumulateDrops(sdkCtx, msg.Distributor, totalOutput)
if err != nil {
return nil, err
}
//Create drops and Store Historical Data
err = srv.Keeper.CreateDrops(sdkCtx, msg.Output, distributionName, msg.DistributionType, msg.AuthorizedRunner)
if err != nil {
return nil, err
}
sdkCtx.EventManager().EmitEvents(sdk.Events{
sdk.NewEvent(
types.EventTypeDistributionStarted,
sdk.NewAttribute(types.AttributeKeyFromModuleAccount, types.GetDistributionModuleAddress().String()),
sdk.NewAttribute(types.AttributeKeyDistributionName, distributionName),
sdk.NewAttribute(types.AttributeKeyDistributionType, msg.DistributionType.String()),
),
})
return &types.MsgCreateDistributionResponse{}, nil
}
func (srv msgServer) CreateUserClaim(ctx context.Context,
claim *types.MsgCreateUserClaim) (*types.MsgCreateClaimResponse, error) {
sdkCtx := sdk.UnwrapSDKContext(ctx)
if srv.Keeper.ExistsClaim(sdkCtx, claim.UserClaimAddress, claim.UserClaimType) {
sdkCtx.Logger().Info("Claim already exists for user :", claim.UserClaimAddress)
return nil, errors.Wrap(types.ErrInvalid, "Claim already exists for user")
}
newClaim, err := types.NewUserClaim(claim.UserClaimAddress, claim.UserClaimType, sdkCtx.BlockTime())
if err != nil {
return nil, err
}
err = srv.Keeper.SetClaim(sdkCtx, newClaim)
if err != nil {
return nil, err
}
sdkCtx.EventManager().EmitEvents(sdk.Events{
sdk.NewEvent(
types.EventTypeClaimCreated,
sdk.NewAttribute(types.AttributeKeyClaimUser, newClaim.UserAddress),
sdk.NewAttribute(types.AttributeKeyClaimType, newClaim.UserClaimType.String()),
sdk.NewAttribute(types.AttributeKeyClaimTime, newClaim.UserClaimTime.String()),
),
})
return &types.MsgCreateClaimResponse{}, nil
}
func (srv msgServer) RunDistribution(ctx context.Context, distribution *types.MsgRunDistribution) (*types.MsgRunDistributionResponse, error) {
// Not checking whether the distribution exists or not .
// We only need to run and execute distribution records
// Distribute limited drops for msg.DistributionName authorized to msg.DistributionRunner
sdkCtx := sdk.UnwrapSDKContext(ctx)
records, err := srv.Keeper.DistributeDrops(sdkCtx, sdkCtx.BlockHeight(), distribution.DistributionName, distribution.AuthorizedRunner, distribution.DistributionType, distribution.DistributionCount)
if err != nil {
return nil, err
}
recordEvents := make([]sdk.Event, len(records.DistributionRecords)+1)
for i, record := range records.DistributionRecords {
ev := sdk.NewEvent(
types.EventTypeDistributionRecordsList+strconv.Itoa(i),
sdk.NewAttribute(types.AttributeKeyDistributionRecordAddress, record.RecipientAddress),
sdk.NewAttribute(types.AttributeKeyDistributionRecordType, record.DistributionType.String()),
sdk.NewAttribute(types.AttributeKeyDistributionRecordAmount, record.Coins.String()),
)
recordEvents[i] = ev
}
recordEvents[len(recordEvents)-1] = sdk.NewEvent(
types.EventTypeDistributionRun,
sdk.NewAttribute(types.AttributeKeyDistributionName, distribution.DistributionName),
sdk.NewAttribute(types.AttributeKeyDistributionRunner, distribution.AuthorizedRunner),
)
sdkCtx.EventManager().EmitEvents(recordEvents)
return &types.MsgRunDistributionResponse{}, nil
}