laconicd/x/auction/keeper/msg_server.go

package keeper

import (
	"context"

	errorsmod "cosmossdk.io/errors"
	"git.vdb.to/cerc-io/laconicd/utils"
	auctiontypes "git.vdb.to/cerc-io/laconicd/x/auction"
	sdk "github.com/cosmos/cosmos-sdk/types"
	govtypes "github.com/cosmos/cosmos-sdk/x/gov/types"
)

var _ auctiontypes.MsgServer = msgServer{}

type msgServer struct {
	k *Keeper
}

// NewMsgServerImpl returns an implementation of the module MsgServer interface.
func NewMsgServerImpl(keeper *Keeper) auctiontypes.MsgServer {
	return &msgServer{k: keeper}
}

func (ms msgServer) CreateAuction(c context.Context, msg *auctiontypes.MsgCreateAuction) (*auctiontypes.MsgCreateAuctionResponse, error) {
	ctx := sdk.UnwrapSDKContext(c)
	ctx = *utils.CtxWithCustomKVGasConfig(&ctx)

	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
	if err != nil {
		return nil, err
	}

	resp, err := ms.k.CreateAuction(ctx, *msg)
	if err != nil {
		return nil, err
	}

	ctx.EventManager().EmitEvents(sdk.Events{
		sdk.NewEvent(
			auctiontypes.EventTypeCreateAuction,
			sdk.NewAttribute(auctiontypes.AttributeKeyCommitsDuration, msg.CommitsDuration.String()),
			sdk.NewAttribute(auctiontypes.AttributeKeyCommitFee, msg.CommitFee.String()),
			sdk.NewAttribute(auctiontypes.AttributeKeyRevealFee, msg.RevealFee.String()),
			sdk.NewAttribute(auctiontypes.AttributeKeyMinimumBid, msg.MinimumBid.String()),
		),
		sdk.NewEvent(
			sdk.EventTypeMessage,
			sdk.NewAttribute(sdk.AttributeKeyModule, auctiontypes.AttributeValueCategory),
			sdk.NewAttribute(auctiontypes.AttributeKeySigner, signerAddress.String()),
		),
	})

	utils.LogTxGasConsumed(ctx, ms.k.Logger(ctx), "CreateAuction")

	return &auctiontypes.MsgCreateAuctionResponse{Auction: resp}, nil
}

// CommitBid is the command for committing a bid
func (ms msgServer) CommitBid(c context.Context, msg *auctiontypes.MsgCommitBid) (*auctiontypes.MsgCommitBidResponse, error) {
	if err := msg.ValidateBasic(); err != nil {
		return nil, err
	}

	ctx := sdk.UnwrapSDKContext(c)
	ctx = *utils.CtxWithCustomKVGasConfig(&ctx)

	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
	if err != nil {
		return nil, err
	}

	resp, err := ms.k.CommitBid(ctx, *msg)
	if err != nil {
		return nil, err
	}

	ctx.EventManager().EmitEvents(sdk.Events{
		sdk.NewEvent(
			auctiontypes.EventTypeCommitBid,
			sdk.NewAttribute(auctiontypes.AttributeKeyAuctionId, msg.AuctionId),
			sdk.NewAttribute(auctiontypes.AttributeKeyCommitHash, msg.CommitHash),
		),
		sdk.NewEvent(
			sdk.EventTypeMessage,
			sdk.NewAttribute(sdk.AttributeKeyModule, auctiontypes.AttributeValueCategory),
			sdk.NewAttribute(auctiontypes.AttributeKeySigner, signerAddress.String()),
		),
	})

	utils.LogTxGasConsumed(ctx, ms.k.Logger(ctx), "CommitBid")

	return &auctiontypes.MsgCommitBidResponse{Bid: resp}, nil
}

// RevealBid is the command for revealing a bid
func (ms msgServer) RevealBid(c context.Context, msg *auctiontypes.MsgRevealBid) (*auctiontypes.MsgRevealBidResponse, error) {
	if err := msg.ValidateBasic(); err != nil {
		return nil, err
	}

	ctx := sdk.UnwrapSDKContext(c)
	ctx = *utils.CtxWithCustomKVGasConfig(&ctx)

	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
	if err != nil {
		return nil, err
	}

	resp, err := ms.k.RevealBid(ctx, *msg)
	if err != nil {
		return nil, err
	}

	ctx.EventManager().EmitEvents(sdk.Events{
		sdk.NewEvent(
			auctiontypes.EventTypeRevealBid,
			sdk.NewAttribute(auctiontypes.AttributeKeyAuctionId, msg.AuctionId),
			sdk.NewAttribute(auctiontypes.AttributeKeyReveal, msg.Reveal),
		),
		sdk.NewEvent(
			sdk.EventTypeMessage,
			sdk.NewAttribute(sdk.AttributeKeyModule, auctiontypes.AttributeValueCategory),
			sdk.NewAttribute(auctiontypes.AttributeKeySigner, signerAddress.String()),
		),
	})

	utils.LogTxGasConsumed(ctx, ms.k.Logger(ctx), "RevealBid")

	return &auctiontypes.MsgRevealBidResponse{Auction: resp}, nil
}

// UpdateParams defines a method to perform updation of module params.
func (ms msgServer) UpdateParams(c context.Context, msg *auctiontypes.MsgUpdateParams) (*auctiontypes.MsgUpdateParamsResponse, error) {
	if ms.k.authority != msg.Authority {
		return nil, errorsmod.Wrapf(govtypes.ErrInvalidSigner, "invalid authority; expected %s, got %s", ms.k.authority, msg.Authority)
	}

	if err := msg.Params.Validate(); err != nil {
		return nil, err
	}

	ctx := sdk.UnwrapSDKContext(c)

	if err := ms.k.SetParams(ctx, msg.Params); err != nil {
		return nil, err
	}

	return &auctiontypes.MsgUpdateParamsResponse{}, nil
}

// ReleaseFunds is the command to pay the winning amounts to provider auction winners
func (ms msgServer) ReleaseFunds(c context.Context, msg *auctiontypes.MsgReleaseFunds) (*auctiontypes.MsgReleaseFundsResponse, error) {
	if err := msg.ValidateBasic(); err != nil {
		return nil, err
	}

	ctx := sdk.UnwrapSDKContext(c)
	ctx = *utils.CtxWithCustomKVGasConfig(&ctx)

	signerAddress, err := sdk.AccAddressFromBech32(msg.Signer)
	if err != nil {
		return nil, err
	}

	resp, err := ms.k.ReleaseFunds(ctx, *msg)
	if err != nil {
		return nil, err
	}

	ctx.EventManager().EmitEvents(sdk.Events{
		sdk.NewEvent(
			auctiontypes.EventTypeReleaseFunds,
			sdk.NewAttribute(auctiontypes.AttributeKeyAuctionId, msg.AuctionId),
		),
		sdk.NewEvent(
			sdk.EventTypeMessage,
			sdk.NewAttribute(sdk.AttributeKeyModule, auctiontypes.AttributeValueCategory),
			sdk.NewAttribute(auctiontypes.AttributeKeySigner, signerAddress.String()),
		),
	})

	utils.LogTxGasConsumed(ctx, ms.k.Logger(ctx), "ReleaseFunds")

	return &auctiontypes.MsgReleaseFundsResponse{Auction: resp}, nil
}