forked from cerc-io/laconicd
Prathamesh Musale
df43322ef3
Part of [Create a public laconicd testnet](https://www.notion.so/Create-a-public-laconicd-testnet-896a11bdd8094eff8f1b49c0be0ca3b8) Handles cerc-io/laconic-console#59 Co-authored-by: IshaVenikar <ishavenikar7@gmail.com> Reviewed-on: cerc-io/laconicd#58 Co-authored-by: Prathamesh Musale <prathamesh.musale0@gmail.com> Co-committed-by: Prathamesh Musale <prathamesh.musale0@gmail.com>
172 lines
4.9 KiB
Go
172 lines
4.9 KiB
Go
package keeper
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"cosmossdk.io/collections"
|
|
"cosmossdk.io/core/address"
|
|
storetypes "cosmossdk.io/core/store"
|
|
errorsmod "cosmossdk.io/errors"
|
|
"cosmossdk.io/log"
|
|
|
|
"github.com/cosmos/cosmos-sdk/codec"
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
|
|
|
|
"git.vdb.to/cerc-io/laconicd/utils"
|
|
onboardingTypes "git.vdb.to/cerc-io/laconicd/x/onboarding"
|
|
)
|
|
|
|
type Keeper struct {
|
|
cdc codec.BinaryCodec
|
|
addressCodec address.Codec
|
|
|
|
// authority is the address capable of executing a MsgUpdateParams and other authority-gated message.
|
|
// typically, this should be the x/gov module account.
|
|
authority string
|
|
|
|
// state management
|
|
Schema collections.Schema
|
|
Params collections.Item[onboardingTypes.Params]
|
|
Participants collections.Map[string, onboardingTypes.Participant]
|
|
}
|
|
|
|
// NewKeeper creates a new Keeper instance
|
|
func NewKeeper(cdc codec.BinaryCodec, addressCodec address.Codec, storeService storetypes.KVStoreService, authority string) *Keeper {
|
|
if _, err := addressCodec.StringToBytes(authority); err != nil {
|
|
panic(fmt.Errorf("invalid authority address: %w", err))
|
|
}
|
|
|
|
sb := collections.NewSchemaBuilder(storeService)
|
|
k := Keeper{
|
|
cdc: cdc,
|
|
addressCodec: addressCodec,
|
|
authority: authority,
|
|
Params: collections.NewItem(sb, onboardingTypes.ParamsPrefix, "params", codec.CollValue[onboardingTypes.Params](cdc)),
|
|
Participants: collections.NewMap(
|
|
sb, onboardingTypes.ParticipantsPrefix, "participants", collections.StringKey, codec.CollValue[onboardingTypes.Participant](cdc),
|
|
),
|
|
}
|
|
|
|
schema, err := sb.Build()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
k.Schema = schema
|
|
|
|
return &k
|
|
}
|
|
|
|
// GetAuthority returns the module's authority.
|
|
func (k Keeper) GetAuthority() string {
|
|
return k.authority
|
|
}
|
|
|
|
func (k Keeper) Logger(ctx sdk.Context) log.Logger {
|
|
return ctx.Logger().With("module", onboardingTypes.ModuleName)
|
|
}
|
|
|
|
func (k Keeper) OnboardParticipant(
|
|
ctx sdk.Context,
|
|
msg *onboardingTypes.MsgOnboardParticipant,
|
|
signerAddress sdk.AccAddress,
|
|
) (*onboardingTypes.MsgOnboardParticipantResponse, error) {
|
|
params, err := k.Params.Get(ctx)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if !params.OnboardingEnabled {
|
|
return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "Onboarding is disabled")
|
|
}
|
|
|
|
message, err := json.Marshal(msg.EthPayload)
|
|
if err != nil {
|
|
return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "Invalid format for payload")
|
|
}
|
|
|
|
// Decode eth address from signature which should be the nitro address of the participant
|
|
nitroAddress, err := utils.DecodeEthereumAddress(message, msg.EthSignature)
|
|
if err != nil {
|
|
return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "Failed to decode Ethereum address")
|
|
}
|
|
|
|
if nitroAddress != msg.EthPayload.Address {
|
|
return nil, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "Recovered ethereum address does not match the address set in payload")
|
|
}
|
|
|
|
participant := &onboardingTypes.Participant{
|
|
CosmosAddress: signerAddress.String(),
|
|
NitroAddress: nitroAddress,
|
|
Role: msg.Role,
|
|
KycId: msg.KycId,
|
|
}
|
|
|
|
if err := k.StoreParticipant(ctx, participant); err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &onboardingTypes.MsgOnboardParticipantResponse{}, nil
|
|
}
|
|
|
|
func (k Keeper) StoreParticipant(ctx sdk.Context, participant *onboardingTypes.Participant) error {
|
|
key := participant.CosmosAddress
|
|
return k.Participants.Set(ctx, key, *participant)
|
|
}
|
|
|
|
// ListParticipants - get all participants.
|
|
func (k Keeper) ListParticipants(ctx sdk.Context) ([]*onboardingTypes.Participant, error) {
|
|
var participants []*onboardingTypes.Participant
|
|
|
|
iter, err := k.Participants.Iterate(ctx, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
for ; iter.Valid(); iter.Next() {
|
|
participant, err := iter.Value()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
participants = append(participants, &participant)
|
|
}
|
|
|
|
return participants, nil
|
|
}
|
|
|
|
// GetParticipantByAddress - get participant by cosmos (laconic) address.
|
|
func (k Keeper) GetParticipantByAddress(ctx sdk.Context, address string) (onboardingTypes.Participant, error) {
|
|
participant, err := k.Participants.Get(ctx, address)
|
|
if err != nil {
|
|
if errors.Is(err, collections.ErrNotFound) {
|
|
return onboardingTypes.Participant{}, errorsmod.Wrap(sdkerrors.ErrInvalidRequest, "participant with given address not found.")
|
|
}
|
|
return onboardingTypes.Participant{}, err
|
|
}
|
|
|
|
return participant, nil
|
|
}
|
|
|
|
// GetParticipantByNitroAddress - get participant by nitro address.
|
|
func (k Keeper) GetParticipantByNitroAddress(ctx sdk.Context, nitroAddress string) (onboardingTypes.Participant, error) {
|
|
var participant onboardingTypes.Participant
|
|
|
|
err := k.Participants.Walk(ctx, nil, func(key string, value onboardingTypes.Participant) (bool, error) {
|
|
if value.NitroAddress == nitroAddress {
|
|
participant = value
|
|
return true, nil
|
|
}
|
|
|
|
return false, nil
|
|
})
|
|
if err != nil {
|
|
return onboardingTypes.Participant{}, err
|
|
}
|
|
|
|
return participant, nil
|
|
}
|