mintd - consume events from redis

[vnprc]

mintd should consume two types of events from a redis queue:

• create quote
  • generated when the miner submits a new mining share
  • fields
    • block header hash
    • blinded secret
    • locking pubkey
    • status: UNPAID
  • quote generation example
• update quote
  • generated when the share and block template are fully validated
  • fields
    • block header hash: index for quote lookup
    • status
  • if the share is valid status == PAID
  • if invalid status == cancelled or error or something

[vnprc]

Do we need to stand up a separate redis service? I think cdk has redis support, find an example to copy.

[wilfredallyn]

I reviewed the redis code in cdk and hashpool mint/pool roles

Is this the correct logic flow?

• miner submits share to pool
• pool creates quote
• pool writes quote to redis
• mint reads quote from redis

Where in the code should the pool write the quote to redis? in the pool message handler?

Where in the code should the mint read the quote from redis? here?

[vnprc]

Yes exactly! I'm not sure how the mint will read from redis yet. Maybe it's already built in mintd? If not, we will have to write a polling task.

Note: I am currently building on a cdk fork: https://github.com/vnprc/cdk/tree/hashpool2

I forked this code off cdk a long time ago. My SRI code is also dated and needs a rebase. With new developers jumping in I should prioritize this work. I want you to be building, not fighting the build system.

I have already coded up to where the pool creates the quote. So the next steps are:

• stand up a redis service (new service example here)
• instead of logging the quote, publish it to redis
  • first need to define the create_quote message payload
  • what kind of redis data structure?
    • probably just a list implementing a FIFO queue using lpush and rpop events
    • how to key events? probably just the block header hash
• configure mintd to poll for events
  • when a create quote event is pulled from redis we want to call this function

[vnprc]

Here is some example cdk redis code to check out. https://github.com/cashubtc/cdk/blob/main/crates/cdk-axum/src/cache/backend/redis.rs

If you have questions about this code @crodas is the guy to ask.

[vnprc]

Note: we DO NOT want to lose any events. Events are money. But let's get the basic structure working and then circle back and make it bulletproof later.

[crodas]

What is the main goal? Should we use Redis to store events and communicate between processes?

To achieve that, I would suggest sorted sets. In these, you add unique events sorted by time, and the reader of events can decide to continue from where they left off.

[crodas]

After the event is stored in the sorted set, a pubsub event can be emitted for real time listeners. But offline clients can check past events stored in the sorted set. Does this make sense?

[vnprc]

Okay, so I realize now that I only created half of the quote request structs we need. The one in the code now does not include blinded secrets. I just copied the bolt 11 quote request event and created a clone to represent mining shares instead of lightning payments but the flow is still the same. Reference this diagram for the overall protocol flow.

We need to create another quote request object copying this one but called MintMiningShareRequest. The purpose of this object is to capture the blinded message (aka blinded secret) and an Option for the signatures. Populate the secrets on this struct in the translator proxy process and send it upstream to the pool by writing it to redis. The mint can then query redis and populate the quote in it's data store.

Later on, when the pool completes share and block template validation We set the quote status to PAID initially (skip block template validation for now). When the mint polls the quote it needs to sign the messages and save them on the MintMiningShareRequest object, which contains a MintQuoteMiningShareRequest. The pool then drops this object into the redis queue for the mint to pick up.

We will need a polling process to query redis and call process_mint_request with each quote it pulls in. The polling process needs to ensure at least once delivery of this record so it should only remove the item from redis after that function returns successfully.

When the user wallet next polls for paid quotes it can sweep the blinded sigs off the quote and save them to wallet db. Now the user has some ehash tokens in their wallet. I haven't fully scoped this work yet but we can look harder once the above steps are more complete.

edit: Simplify the model to set quote status to PAID right away.

[vnprc]

I think we can just set the quote to PAID and actually skip the quote update. I was talking to some devs this past week and apparently block template validation is just a TODO item in SRI. I need to go back and confirm but we can start with a more simplified model that doesn't involve block validation.

[vnprc]

I also forgot pass the keyset from the mint to the pool upon startup. This is working now but the quotes are still rejected. There is a little bit more work to do to delete the in-built mint from the pool role, it's still using the keyset from this mint. I just gotta wire up the plumbing to pass the mintd keyset to where blinded secrets are generated. Then I can delete the mint from the pool rule completely and users should be able to sweep their ehash from mintd.