Join drep endpoint

[paweljakubas]

• Swagger updated
• Api scaffolding, Api types, Api errors
• Adding Http.Shelley.Server joinDRep
• Adding IO Deleg functions
• Adding Delegation's guard
• Checking that error is emitted when used in Babbage
• Checking we can vote, re-vote and emit error when voting the same in the absence of pool delegation in Conway
• Checking we can vote, re-vote and emit error when voting the same in the presence of pool delegation in Conway

Comments

Issue Number

adp-3383

[HeinrichApfelmus]

Thank you! 😊

The functionality seems to work, but I request a different separation of concerns for the modules Cardano.Wallet.Delegation and Cardano.Wallet.IO.Delegation.

[HeinrichApfelmus]

This function is okay, but harder to understand than necessary — in particular, it's not clear what exactly toDrepEnrichted is supposed to be doing. Could you remove this function (handleVoteRequest) and structure the function joinDRep similar to the function quitStakePool instead?

In other words, I would like you to structure the code in the following way:

joinDRep — IO, collects relevant parameter values, calls

    joinDRepVotingAction — IO, provides additional parameter values (if necessary), calls

        WD.joinDRepVotingAction — *pure*, computes a result based on all parameter values.

The idea is that the functions joinDRep and joinDRepVotingAction are responsible for providing sufficient parameter values to compute the result, but the actual computation of the result (= the Either ErrCannotJoin Tx.VotingAction is contained within the pure function. In other words, the concern of figuring out what the vote action should be — if any — should be entirely confined to the definition of the pure function WD.joinDRepVotingAction.

In contrast, at the moment, this function uses toDRepEnriched to package some intermediate computation and hands it off to the function WD.guardOnlyVoting in a different module, but the meaning of the intermediate data format Maybe (Bool, DRep) is not apparent from the type signatures and function names. The logic becomes much clear if:

• Use pure functions to compute the result.
• Keep the computation of the result to a single module

Could you change this?

[paweljakubas]

sounds reasonable! done

[HeinrichApfelmus]

Thank you! 😊

With the improved separation of concerns for joinDRep, we can now perform a further simplification in Cardano.Wallet.Delegation — good to merge after that.

(In principle, the same considerations apply to the Cardano.Wallet.IO.Delegation.joinStakePool function, but let's leave this for a future pull request when we need to touch this area of the code again.)

[HeinrichApfelmus]

Suggested change

	guardOnlyVoting
	:: Write.IsRecentEra era
	=> Write.RecentEra era
	-> (Bool,DRep)
	-> Either ErrCannotVote ()
	guardOnlyVoting era votingSameAgain = do
	when (fst votingSameAgain) $
	Left $ ErrAlreadyVoted $ snd votingSameAgain
	case era of
	Write.RecentEraBabbage ->
	Left ErrWrongEra
	Write.RecentEraConway ->
	Right ()
	joinDRepVotingAction
	:: Write.IsRecentEra era
	=> Write.RecentEra era
	-> DRep
	-> W.WalletDelegation
	-> Bool
	-> Either ErrCannotVote Tx.VotingAction
	joinDRepVotingAction era action dlg stakeKeyIsRegistered =
	second (const vAction) $ guardOnlyVoting era votingRequest
	where
	isDRepSame (W.Voting drep) = drep == action
	isDRepSame (W.DelegatingVoting _ drep) = drep == action
	isDRepSame _ = False
	isSameNext (W.WalletDelegationNext _ deleg) = isDRepSame deleg
	sameWalletDelegation (W.WalletDelegation current coming) =
	isDRepSame current || any isSameNext coming
	(vAction, votingRequest) =
	if stakeKeyIsRegistered
	then (Tx.Vote action, (sameWalletDelegation dlg, action))
	else (Tx.VoteRegisteringKey action, (sameWalletDelegation dlg,action))
	joinDRepVotingAction
	:: Write.IsRecentEra era
	=> Write.RecentEra era
	-> DRep
	-> W.WalletDelegation
	-> Bool
	-> Either ErrCannotVote Tx.VotingAction
	joinDRepVotingAction era targetDRep dlg stakeKeyIsRegistered = do
	guardEraIsConway era
	when (sameWalletDelegation dlg) $
	Left $ ErrAlreadyVoted $ targetDRep
	pure votingAction
	where
	isDRepSame (W.Voting drep) = drep == targetDRep
	isDRepSame (W.DelegatingVoting _ drep) = drep == targetDRep
	isDRepSame _ = False
	isSameNext (W.WalletDelegationNext _ deleg) = isDRepSame deleg
	sameWalletDelegation (W.WalletDelegation current coming) =
	isDRepSame current || any isSameNext coming
	guardEraIsConway Write.RecentEraBabbage = Left WrongEra
	guardEraIsConway Write.RecentEraConway = Right ()
	votingAction =
	if stakeKeyIsRegistered
	then Tx.Vote targetDRep
	else Tx.VoteRegisteringKey targetDRep

… and after separating the concerns into a single, we can now merge the definitions of the two functions and get rid of the (Bool,DRep) intermediate type while also making the logic more clear. 🤓

[paweljakubas]

good hint. Done!