story: web3proxy and sal for it in crystallib

[despiegk]

web3proxy

purpose

• we need proper SAL's in crystallib, a SAL is a System Abstratcion layer on top of an external system e.g. stellar, tfgrid, ...
• we need to create a golang daemon we call web3proxy
• this web3proxy is link between web3 world (which also includes tfgrid) and any other development environment (e.g. crystallib as example)

web3proxy functionality

• btc & btc lightening client
• stellar client (for items which cannot be done in v http client) e.g. for doing transactions, payments, ...
• tfchain client (is that part of tfgrid client?)
• tfgrid client (deployments, ...)
• rmb for zos, maybe part of tfgrid client (make sure all relevant functionality of what can be done to ZOS'es over rmb is exposed here through the proxy)
• nostr (if not done directly in vlang)
• activitypub (next version)
• matrixchat (next version)

web3proxy multi session

• communication to web3proxy happens over redis (super simple rpc mechanism see cyrstallib.../redisclient/rpc_test.v
  • the processor side in golang is super simple see v example, do not re-use rmb or something like that overkill here
  • the rpc is 3 lines of meta + data, data is a simple json, return happens over a return queue
• there is a main queue called web3proxy-sessions (name for the rpc session)
  • on here we implement methods to start a new session (say is for e.g. btc, stellar, tfgrid)
  • for tfgrid: selection of endpoints, or just select testnet, qanet, ..., send mneomics
  • for btc: mnemonic, ...
  • for stellar: mnemonic
  • each session is a co-routing and has full client functionality available for that started session
  • a session has a specific queue for incoming requests

e.g. in pseudocode

redis.rpc -> ask for session for btc, specify queue is mybtc3, will receive the incoming requets for this session now on that queue
now I can start. new redis.rpc but for queue mybtc3
on this one I can send commands to the btc client I just opened
the return queues are done per rpc request  (embedded in the rpc client of redis)

deployment mechanism

• for development use docker
  • create a builder using the new V docker scripts for the web3proxy (should be super easy there is golang base) + rust rmb-peer (needed behind web3proxy)
  • start the docker expose port to local machine (ports of redis on that machine)
• create web3proxy sal
  • which has as purpose to check if docker is there, then start the agent and connect to it (redis client to port exposed by docker)

SAL layer on crystallib

• nicely define structs and client lib using those structs to call the web3proxy
• do separate for tfgrid, btc, stellar, nostr (if not as client in vlang) ...

important ask Kristof to review specs before implementing