The (non-)existing problem with interactive transactions & UX - Rant

Wasn’t grinbox exactly that? If those solutions seem perfectly good, then why was that project abandoned and (seemingly) not supported by the community?

Even better, take one of the open source Matrix clients and add this functionality into it. Although, I have no idea what a slatepack is. If I understand correctly, a slatepack is literally a way to have offline transactions. If that is true, then grin already has offline transactions, right?

This is an oxymoron xD mobile apps are never “always online”. I’ve had horrible issues with Beam for this reason :slight_smile:

I do love the idea of a grin node being an installable app in things like Umbrel! Awesome idea :+1:

Yes, it surprised me that it was removed as option, maybe it was to much work. Maybe some community members found it to 'centralized. In a way exchange could facilitate this function now.

This exactly something that could be a project to be funded by the community council. Preferably plugins for matrix, signal, telegram - other suggestions welcome, as well as programmers willing to build these plugins :wink:

Basically a package in the form of a blob of text containing all transaction information. Hence it is handy since you can copy paste it or send it via email/signal/telegram/anything that supports text without worrying it gets meddled with or gets corrupted (some build in checksum).

Mobile phones should be always reachable, maybe something like push notifications are needed, but you are right it might be hard to build an APP that is low on battery yet always online. Even more reason we need support for other channels like Matrix, Signal, Telegram that can be used to route transactions.

Many potential projects guys, take your pick and apply for (community) funding

One problem I foresee is that there is no SDK for application integrations. The docs only show how to build or use existing wallets. There’s no documentation guide on how to programmatically create a slatepack, send it, unpack it, etc.

I think an SDK with methods for each step would be ideal.

Indeed, we need this. We need to build cross platform cross APP standards. Slatepacks help in that sense since that means you just need to load a blob of text/the slate-pack, it is the same for all wallet software. I have not delved to deeply in the API’s from grin-wallet (rust) and from Grin++, but I think both should have an API call to load a slate-pack in the wallet software.
So basically what is needed is a script or program that scans incomming text for labels like BEGINSLATEPACK.

ENDSLATEPACK, and simply makes an API call to the wallet with that blob of text.
Sounds easy enough, but I guess it is not trivial to get access to messages from for example Signal, since it wold provide a security risk to these Apps.

So you’d basically include the entire wallet in your application?

If there is an API, that would hint that there is a library version of the wallet that doesn’t include all the extra code that you don’t need, right?

I agree that slatepacks seem like an easy format. But how do we build and unpack them exactly? xD

That is the nice thing, you do not need to worry about it at all. What we need for development is just a program that scan incomming messages (from a Matrix server, website, email, telegram, Signal, anything that handles text) and then calls the API of an existing wallet.
So in programming terms what we need is a bridge or listener that links these messaging platforms to the wallet. The wallet does all the interpretation of incoming slate-packs - which is nothing more than a blob of text looks like:

BEGINSLATEPACK. some unreadable encrypted giberisch that contains the transaction info ENDSLATEPACK.

Oh simple!! So all Ironbelly needs is something like this Apple Developer Documentation

Each wallet should have a custom URI scheme that includes the slatepack. Then the messaging app doesn’t need to be aware of grin at all.

That would be one way. For example, open/scan URL/QR code on a website, to make donation. In it is some json that tells {slatepack address:grin…,if_not_online_default_to:some_action. E.g. if the tor address is not online, send to a certain matrix server. Preferably, your own wallet would also send with it some backup action in case your wallet is offline when you receive the response.

To be even more simple, just have a message like “to donate, please send a slatepack to this username on this app”. If we start using grin:// URIs then this would be even simpler for people to click and use.

That kind of flow with slatepacks is so much easier than even networks like monero.

Now how does someone generate an invoice to request a certain amount of money from someone?

Unfortunately such invoice transactions flows (RSR) with payment proofs, (needed to avoid settlement conflicts between the receiver and sender) are still in the RFC phase. Hopefully they will be implemented soon.

=> But on the plus side, grinnode life made this publicly available payment proof generator (still in beta phase)!

1 Like