La blockchain Experience è stata progettata per offrire una piattaforma sicura e decentralizzata per la gestione delle transazioni e dei servizi terapeutici. Un elemento chiave di questa piattaforma è il processo di iscrizione degli utenti e la creazione simultanea di un wallet digitale. Questo post descrive dettagliatamente come avviene l’iscrizione dei pazienti e la creazione del wallet sulla blockchain Experience utilizzando Cosmos SDK.
Cos’è la Blockchain Experience?
Experience è una blockchain personalizzata sviluppata utilizzando Cosmos SDK, progettata per gestire transazioni e servizi terapeutici. È dotata di moduli specifici per la registrazione degli utenti, la gestione dei token $EXP, e le sessioni di terapia. Uno degli aspetti fondamentali di Experience è la capacità di creare automaticamente un wallet per ogni paziente che si iscrive alla piattaforma, garantendo un accesso sicuro e decentralizzato ai servizi.
Processo di Iscrizione e Creazione del Wallet
Il processo di iscrizione alla piattaforma Experience è stato progettato per essere intuitivo e sicuro. Ogni volta che un paziente si iscrive alla piattaforma, viene creato automaticamente un wallet digitale associato al suo account. Ecco come funziona il processo:
1. Creazione del Modulo di Registrazione dei Pazienti
Il modulo di registrazione (registration) è responsabile della gestione dell’iscrizione dei pazienti e della creazione dei loro wallet. Questo modulo è stato sviluppato utilizzando Cosmos SDK e include tutte le funzioni necessarie per registrare nuovi utenti sulla blockchain.
- Scaffold del Modulo di Registrazione: Per iniziare, è stato creato un modulo di registrazione utilizzando Starport:
starport scaffold module registrationQuesto comando crea la struttura di base per il modulo registration all’interno del progetto blockchain Experience.
2. Definizione del Messaggio di Registrazione
All’interno del modulo registration, è stato definito un messaggio (Msg) per gestire l’azione di registrazione di un nuovo paziente. Questo messaggio contiene i dati necessari per creare un nuovo account utente e il suo wallet.
- Definizione del Messaggio
MsgRegisterPatient: Il filex/registration/types/msgs.goinclude il seguente codice per definire il messaggio di registrazione:
package types
import (
sdk "github.com/cosmos/cosmos-sdk/types"
)
const (
TypeMsgRegisterPatient = "register_patient"
)
// MsgRegisterPatient definisce un messaggio per registrare un nuovo paziente
type MsgRegisterPatient struct {
Creator sdk.AccAddress `json:"creator" yaml:"creator"`
Name string `json:"name" yaml:"name"`
Email string `json:"email" yaml:"email"`
}
// NewMsgRegisterPatient crea una nuova istanza di MsgRegisterPatient
func NewMsgRegisterPatient(creator sdk.AccAddress, name string, email string) *MsgRegisterPatient {
return &MsgRegisterPatient{
Creator: creator,
Name: name,
Email: email,
}
}
// Implementazioni delle funzioni di Msg necessarie per Cosmos SDK
func (msg *MsgRegisterPatient) Route() string { return RouterKey }
func (msg *MsgRegisterPatient) Type() string { return TypeMsgRegisterPatient }
func (msg *MsgRegisterPatient) GetSigners() []sdk.AccAddress {
return []sdk.AccAddress{msg.Creator}
}
func (msg *MsgRegisterPatient) GetSignBytes() []byte {
bz := ModuleCdc.MustMarshalJSON(msg)
return sdk.MustSortJSON(bz)
}
func (msg *MsgRegisterPatient) ValidateBasic() error {
if msg.Creator.Empty() {
return sdkerrors.Wrap(sdkerrors.ErrInvalidAddress, "creator can't be empty")
}
if len(msg.Name) == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "name can't be empty")
}
if len(msg.Email) == 0 {
return sdkerrors.Wrap(sdkerrors.ErrInvalidRequest, "email can't be empty")
}
return nil
}Questo messaggio (MsgRegisterPatient) include campi come il nome del paziente, l’email, e l’indirizzo creatore (creator).
3. Implementazione dell’Handler di Registrazione
L’handler è la funzione che gestisce il messaggio di registrazione, creando un nuovo account utente e un wallet associato.
- Creazione dell’Handler
handleMsgRegisterPatient: Nel filex/registration/handler.go, è stato aggiunto il seguente codice per l’handler:
package registration
import (
"github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/sdkerrors"
"github.com/your_username/experience/x/registration/types"
)
// NewHandler crea un nuovo handler per il modulo di registrazione dei pazienti
func NewHandler(k Keeper) types.Handler {
return func(ctx types.Context, msg types.Msg) (*types.Result, error) {
switch msg := msg.(type) {
case *types.MsgRegisterPatient:
return handleMsgRegisterPatient(ctx, k, msg)
default:
return nil, sdkerrors.Wrap(sdkerrors.ErrUnknownRequest, "unrecognized registration message type")
}
}
}
// handleMsgRegisterPatient gestisce il messaggio di registrazione del paziente
func handleMsgRegisterPatient(ctx types.Context, k Keeper, msg *types.MsgRegisterPatient) (*types.Result, error) {
// Creazione del nuovo paziente e wallet associato
if err := k.RegisterPatient(ctx, msg.Creator, msg.Name, msg.Email); err != nil {
return nil, err
}
return &types.Result{Events: ctx.EventManager().Events()}, nil
}4. Logica del Keeper per la Registrazione e Creazione del Wallet
Il Keeper è responsabile della logica di business all’interno del modulo. La funzione RegisterPatient crea un nuovo account utente e un wallet associato.
- Implementazione della Funzione
RegisterPatientnel Keeper: Nel filex/registration/keeper/keeper.go, è stata aggiunta la funzioneRegisterPatient:
package keeper
import (
"github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth/types"
"github.com/your_username/experience/x/registration/types"
)
// RegisterPatient registra un nuovo paziente e crea un wallet
func (k Keeper) RegisterPatient(ctx types.Context, creator types.AccAddress, name string, email string) error {
// Creazione di un nuovo account paziente
acc := k.accountKeeper.NewAccountWithAddress(ctx, creator)
// Aggiunta dell'account al keeper degli account
k.accountKeeper.SetAccount(ctx, acc)
// Generazione di eventi per il log
ctx.EventManager().EmitEvents(types.Events{
types.NewEvent(
types.EventTypeMessage,
types.NewAttribute(types.AttributeKeyModule, types.AttributeValueCategory),
types.NewAttribute(types.AttributeKeySender, creator.String()),
),
})
return nil
}Questa funzione crea un nuovo account per il paziente utilizzando il accountKeeper e lo aggiunge al contesto della blockchain.
5. Integrazione del Modulo nel File app.go
Infine, il file app.go è stato aggiornato per includere il modulo di registrazione e gestire le transazioni di iscrizione e creazione del wallet.
- Modifica del File
app.go: Nel fileapp/app.go, il moduloregistrationè stato aggiunto e inizializzato:
package app
import (
// Import dei moduli standard e personalizzati
"github.com/cosmos/cosmos-sdk/baseapp"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/types/module"
"github.com/cosmos/cosmos-sdk/x/auth"
authkeeper "github.com/cosmos/cosmos-sdk/x/auth/keeper"
authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
bank "github.com/cosmos/cosmos-sdk/x/bank"
bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
registrationmodule "github.com/your_username/experience/x/registration"
registrationkeeper "github.com/your_username/experience/x/registration/keeper"
registrationtypes "github.com/your_username/experience/x/registration/types"
// Import necessari per il logger e database
"github.com/tendermint/tendermint/libs/log"
dbm "github.com/tendermint/tm-db"
)
const AppName = "ExperienceApp"
var DefaultNodeHome = os.ExpandEnv("$HOME/.experienceapp")
type App struct {
*baseapp.BaseApp
cdc *codec.LegacyAmino
appCodec codec.Codec
interfaceRegistry types.InterfaceRegistry
// Keeper dei moduli standard
AccountKeeper authkeeper.Account
Keeper
BankKeeper bankkeeper.Keeper
// Keeper dei moduli personalizzati
RegistrationKeeper registrationkeeper.Keeper
// Moduli
mm *module.Manager
}
func NewApp(
logger log.Logger,
db dbm.DB,
traceStore io.Writer,
loadLatest bool,
skipUpgradeHeights map[int64]bool,
homePath string,
invCheckPeriod uint,
encodingConfig codec.EncodingConfig,
appOpts sdk.AppOptions,
baseAppOptions ...func(*baseapp.BaseApp),
) *App {
appCodec := encodingConfig.Marshaler
cdc := encodingConfig.Amino
interfaceRegistry := encodingConfig.InterfaceRegistry
bApp := baseapp.NewBaseApp(AppName, logger, db, encodingConfig.TxConfig.TxDecoder(), baseAppOptions...)
bApp.SetCommitMultiStoreTracer(traceStore)
bApp.SetVersion(version.Version)
bApp.SetInterfaceRegistry(interfaceRegistry)
keys := sdk.NewKVStoreKeys(
authtypes.StoreKey, banktypes.StoreKey, registrationtypes.StoreKey,
)
app := &App{
BaseApp: bApp,
cdc: cdc,
appCodec: appCodec,
interfaceRegistry: interfaceRegistry,
AccountKeeper: authkeeper.NewAccountKeeper(appCodec, keys[authtypes.StoreKey], authtypes.ProtoBaseAccount),
BankKeeper: bankkeeper.NewBaseKeeper(appCodec, keys[banktypes.StoreKey], app.AccountKeeper),
RegistrationKeeper: registrationkeeper.NewKeeper(
appCodec, keys[registrationtypes.StoreKey], app.AccountKeeper,
),
}
// Configurazione del Module Manager
app.mm = module.NewManager(
auth.NewAppModule(appCodec, app.AccountKeeper, nil),
bank.NewAppModule(appCodec, app.BankKeeper, app.AccountKeeper),
registrationmodule.NewAppModule(appCodec, app.RegistrationKeeper),
)
// Configurazione del router per i moduli
app.Router().AddRoute(banktypes.ModuleName, bank.NewHandler(app.BankKeeper)).
AddRoute(registrationtypes.ModuleName, registrationmodule.NewHandler(app.RegistrationKeeper))
return app
}Conclusione
L’integrazione di un modulo di registrazione sulla blockchain Experience consente la creazione automatica di wallet per ogni paziente che si iscrive alla piattaforma. Questa funzionalità garantisce che i pazienti abbiano accesso immediato e sicuro ai servizi e alle transazioni disponibili sulla blockchain. Utilizzando Cosmos SDK, è possibile personalizzare facilmente i moduli e le funzionalità per soddisfare le esigenze specifiche di qualsiasi applicazione blockchain.
Foto da pexels.com
