box

Client-server stack for Web3

Intro blog

Flagship App: Photos

client-server resemblance

box server demo

Motivation

There are currently two ways to interact with Web3 storage solutions:

Through a pinning service and a gateway: the advantage is that files are served through URLs, an app can then access the files with conventional methods, e.g. simply putting a picture in <img src="https://github.com/functionland/fula-archived/raw/main/gateway.example.com/Qm...">. The disadvantage is that there is a subscription payment associated with pinning services. Also this is not really decentralized!
Turn the device to a full IPFS node: this model works beautifully in Brave desktop browser as an example, and makes sense for laptop and PC since they normally have large HDDs. It's much harder on mobile devices, however, biggest hurdle is to have Apple on board with the idea of relaxing file system access in iOS! Even if all goes well, a mobile device is NOT a good candidate for hosting the future Web! They get lost easily and are resource constrained (battery, memory).

box aims to address these issues by creating a third alternative: Personal Server

A personal server is a commodity hardware (PC, Raspberry Pi, etc.) that's kept at home vs. in pocket. It helps with actual decentralization, also saves money since people pay once for HDDs and own them forever, no monthly charge! From privacy perspective, it guarantees that data doesn't leave the premise unless user specifically wants to (e.g. sharing).

To achieve this, we are developing protocols to accommodate client-server programming with minimal effort on developer's side:

File Protocol: Send and receive files in a browser or an app (stage: prototype)
Data Protocol: Database interface over at client-side; facilitates describing linked JSON documents and having them saved/retrieved (stage: design draft)
AI Protocol: Map-Reduce stack for distributed processing (stage: ideation)

Architecture

box architecture

An app talks with the server(s) by invoking APIs from @functionland/fula library. The Fula library abstracts away the protocols and libp2p connection, instead exposes APIs similar to MongoDB for data persistence and S3 for file storage.

On the server side, data or file will be saved on a private IPFS instance. There is also a public IPFS instance which comes to play in sharing: when the end user requests to share some data, an encrypted copy will be saved on the public IPFS network, anyone with whom the key has been shared can access the data.

The box stack can provide backup guarantees by having the data pinned on multiple servers owned by the user. However, in cases that the user needs absolute assurance on data longevity, e.g. password records in a password manager app or scans of sensitive documents, the encrypted data can be sent over at Filecoin blockchain.

Packages

Name	Description
protocols	Libp2p protocols for the box stack
server	Reference server implementation in Node.js
fula	Client library for using the protocols from browser
rn-fula	Client library ported for react native

Examples

Name	Description
react	Example of using fula client and box server
react-native	Example of using fula client in react-native and box server

Development

To get started in development with this monorepo use the following steps.

Prerequisites

nodejs version 16.13.2
rush monorepo tool

Local development on host OS

Install & Build deps

  $ rush update && rush build

Run box app.

  $ cd apps/box && rushx start

Run demo apps

  $ cd examples/react-cra && rushx start
  $ cd examples/react-do-app && rushx start

Local development in docker container

  $ docker-compose -f docker-compose.dev.yaml up

Run the demo apps

Open a browser and navigate to http://localhost:3000 and http://localhost:3001

License

MIT

functionland / fula-archived

readme

box