union
The trust-minimized, zero-knowledge bridging protocol, designed for censorship resistance, extremely high security, and usage in decentralized finance.
- 74k
- Rust
- Apache-2.0
- 4 mo ago
FxFiles Flutter app integrated with S3 API
Repo functionland/FxFiles, read from GitHub 1 min ago. functionland has not joined Take My Repo.
functionland/FxFiles is a public repo on GitHub by functionland. FxFiles Flutter app integrated with S3 API. It declares no license on GitHub. Public does not mean open source: without a license, nobody is granted the right to reuse it. It is written mainly in Dart, has 4 stars and last changed on 2026-10-14. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-21.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
A minimalistic file manager totally compatible with any S3 compatible and IPFS pinning providers, such as Fula Network. Built with Flutter for cross-platform compatibility.
lib/
├── app/
│ ├── app.dart # Root widget
│ ├── router.dart # GoRouter navigation
│ └── theme/ # Theme configuration
├── core/
│ ├── models/ # Data models (LocalFile, FulaObject, SyncState, NftToken)
│ └── services/ # Core services
│ ├── auth_service.dart # Google/Apple authentication
│ ├── encryption_service.dart # AES-256-GCM encryption
│ ├── file_service.dart # Local file operations
│ ├── fula_api_service.dart # S3-compatible API, such as Fula network
│ ├── local_storage_service.dart # Hive local storage
│ ├── nft_service.dart # NFT mint/claim/burn/transfer orchestration
│ ├── nft_contract_service.dart # ABI encoding + RPC calls for NFT contract
│ ├── nft_wallet_service.dart # Deterministic wallet derivation + signing
│ ├── text_recognition_service.dart # On-device OCR text extraction (ML Kit)
│ ├── secure_storage_service.dart # Secure key storage
│ └── sync_service.dart # File synchronization
├── features/
│ ├── browser/ # Local file browser
│ ├── fula/ # Cloud browser
│ ├── home/ # Home screen with categories
│ ├── nft/ # NFT minting & claiming
│ │ ├── providers/ # NftNotifier, nftTagsProvider, nftMintsProvider
│ │ ├── screens/ # Collection browser, detail, claim
│ │ └── widgets/ # NftCard, MintConfigDialog, ClaimShareSheet
│ ├── search/ # File search
│ ├── settings/ # App settings
│ ├── shared/ # Shared files
│ ├── sync/ # Sync providers
│ ├── trash/ # Trash management
│ └── viewer/ # File viewers (image, video, text)
├── shared/
│ └── widgets/ # Reusable widgets
└── main.dart # App entry point
git clone https://github.com/user/FxFiles.git
cd FxFilesflutter pub get
flutter run
flutter_rust_bridge_codegen: cargo install flutter_rust_bridge_codegen# 1. Get dependencies flutter pub get # 2. Generate Dart/Rust bindings (from repo root of fula-api) flutter_rust_bridge_codegen generate # 3. Build the native DLL (from repo root of fula-api) cargo build -p fula-flutter --release # 4. Copy DLL to the FxFiles windows directory copy path\to\fula-api\target\release\fula_flutter.dll windows\fula_flutter.dll # 5. Run the app flutter run -d windows
The CMakeLists.txt automatically copies fula_flutter.dll from windows/ to the build output directory.
# 1. Ensure fula_flutter.dll is in windows/ (see steps above) # 2. Add msix dev dependency (if not already added) dart pub add --dev msix # 3. Build Windows release flutter build windows --release # 4. Create MSIX installer dart run msix:create
The MSIX installer will be at build/windows/x64/runner/Release/fula_files.msix. Double-click to install.
https://gateway.fula.network)Sign in with Google or Apple to enable:
Local File → Encrypt (AES-256-GCM) → Upload to S3 (like Fula → IPFS Storage)
↑
User's Encryption Key
| Package | Purpose |
|---|---|
flutter_riverpod |
State management |
go_router |
Navigation |
minio_new |
S3-compatible API client |
cryptography |
Encryption primitives |
hive_flutter |
Local storage |
flutter_secure_storage |
Secure key storage |
google_sign_in |
Google authentication |
sign_in_with_apple |
Apple authentication |
workmanager |
Background sync tasks |
connectivity_plus |
Network monitoring |
google_mlkit_text_recognition |
On-device OCR text extraction from images |
reown_appkit |
WalletConnect wallet connection (external wallet for NFTs) |
web3dart |
EVM wallet derivation + transaction signing (internal wallet) |
await SyncService.instance.syncFolder( localPath: '/storage/emulated/0/Documents', remoteBucket: 'my-bucket', remotePrefix: 'documents', direction: SyncDirection.bidirectional, );
// Queue file upload await SyncService.instance.queueUpload( localPath: '/path/to/file.txt', remoteBucket: 'my-bucket', remoteKey: 'file.txt', encrypt: true, ); // Queue file download await SyncService.instance.queueDownload( remoteBucket: 'my-bucket', remoteKey: 'file.txt', localPath: '/path/to/file.txt', decrypt: true, ); // Retry failed syncs await SyncService.instance.retryFailed();
// List objects in bucket final objects = await FulaApiService.instance.listObjects( 'my-bucket', prefix: 'folder/', ); // Upload with encryption await FulaApiService.instance.encryptAndUpload( 'my-bucket', 'file.txt', fileBytes, encryptionKey, ); // Download and decrypt final bytes = await FulaApiService.instance.downloadAndDecrypt( 'my-bucket', 'file.txt', encryptionKey, );
For files larger than 5MB, multipart upload is used automatically with progress tracking:
// Upload large file with progress (>5MB uses multipart automatically) await FulaApiService.instance.uploadLargeFile( 'my-bucket', 'large-video.mp4', fileBytes, onProgress: (progress) { print('Upload: ${progress.percentage.toStringAsFixed(1)}%'); }, ); // Encrypted large file upload await FulaApiService.instance.encryptAndUploadLargeFile( 'my-bucket', 'large-video.mp4', fileBytes, encryptionKey, originalFilename: 'vacation.mp4', onProgress: (progress) { print('Encrypted upload: ${progress.percentage.toStringAsFixed(1)}%'); }, );
Background sync runs automatically when the app is closed:
// Initialize background sync (called in main.dart) await BackgroundSyncService.instance.initialize(); // Schedule periodic sync (every 15 minutes on WiFi) await BackgroundSyncService.instance.schedulePeriodicSync( frequency: Duration(minutes: 15), requiresWifi: true, ); // Schedule one-time upload await BackgroundSyncService.instance.scheduleUpload( localPath: '/path/to/file.txt', bucket: 'my-bucket', key: 'file.txt', encrypt: true, useMultipart: true, ); // Schedule one-time download await BackgroundSyncService.instance.scheduleDownload( bucket: 'my-bucket', key: 'file.txt', localPath: '/path/to/file.txt', decrypt: true, ); // Retry failed operations await BackgroundSyncService.instance.scheduleRetryFailed(); // Cancel all background tasks await BackgroundSyncService.instance.cancelAll();
Share encrypted files with others without exposing your master key. Three sharing modes are available:
| Type | Use Case | Security |
|---|---|---|
| Create Link For... | Share with specific recipient | Highest - uses recipient's public key |
| Create Link | Anyone with link can access | Medium - disposable keypair in URL fragment |
| Create Link with Password | Password-protected access | High - password + link required |
All share links use the gateway at https://cloud.fx.land/view:
https://cloud.fx.land/view/{shareId}#{payload}
URL Structure:
{shareId} - Unique share identifier (UUID)#{payload} - Base64url-encoded payload in URL fragment (never sent to server)Payload Contents (for public/password links):
{
"v": 1, // Version
"t": "<token>", // Encoded share token
"k": "<secretKey>", // Link secret key (base64)
"b": "bucket-name", // Storage bucket
"p": "/path/to/file", // Path scope
"pwd": false // Is password-protected
}// Get your public key to share with others final myPublicKey = await AuthService.instance.getPublicKeyString(); // 1. Create a share for a specific recipient final token = await SharingService.instance.shareWithUser( pathScope: '/photos/vacation/', bucket: 'my-bucket', recipientPublicKey: recipientPublicKeyBytes, recipientName: 'John', dek: folderEncryptionKey, permissions: SharePermissions.readOnly, expiryDays: 30, label: 'Vacation photos', ); // 2. Create a public link (anyone with link can access) final publicLink = await SharingService.instance.createPublicLink( pathScope: '/photos/vacation/', bucket: 'my-bucket', dek: folderEncryptionKey, expiryDays: 7, label: 'Vacation photos', ); // Result: https://cloud.fx.land/view/abc123#eyJ2IjoxLC... // 3. Create a password-protected link final passwordLink = await SharingService.instance.createPasswordProtectedLink( pathScope: '/documents/report.pdf', bucket: 'my-bucket', dek: folderEncryptionKey, expiryDays: 30, password: 'secretPassword123', label: 'Monthly report', ); // Recipients need both the link AND password to access // Generate share link from OutgoingShare final link = SharingService.instance.generateShareLinkFromOutgoing(outgoingShare); // Accept a share from link final accepted = await SharingService.instance.acceptShareFromString(encodedToken); print('Access to: ${accepted.pathScope}'); print('Can write: ${accepted.canWrite}'); // Revoke a share await SharingService.instance.revokeShare(shareId);
| Option | Duration |
|---|---|
| 1 Day | 24 hours |
| 1 Week | 7 days |
| 1 Month | 30 days |
| 1 Year | 365 days |
| 5 Years | 1825 days (max) |
Sharing Model:
Security Details:
#...) is never sent to server (HTTP standard)How it works:
The gateway can retrieve an owner's share list from cloud storage. Shares are stored encrypted with the owner's encryption key:
Storage Location:
Bucket: fula-metadata
Key: .fula/shares/{userId}.json.enc
User ID Derivation:
// userId is first 16 chars of SHA-256(publicKey), URL-safe final hash = sha256(publicKeyBytes); final userId = hash.substring(0, 16).replaceAll('/', '_').replaceAll('+', '-');
Decrypted JSON Structure:
{
"version": 1,
"updatedAt": "2024-01-15T10:30:00.000Z",
"shares": [
{
"id": "share-uuid",
"token": {
"id": "token-uuid",
"pathScope": "/photos/vacation/",
"permissions": "readOnly",
"wrappedDek": "base64...",
"recipientPublicKey": "base64...",
"issuedAt": "2024-01-15T10:30:00.000Z",
"expiresAt": "2024-02-15T10:30:00.000Z",
"shareType": "publicLink",
"shareMode": "temporal"
},
"bucket": "photos",
"recipientName": "Public Link",
"label": "Vacation photos",
"sharedAt": "2024-01-15T10:30:00.000Z",
"isRevoked": false,
"linkSecretKey": "base64...",
"passwordSalt": null
}
]
}OutgoingShare Fields:
| Field | Type | Description |
|---|---|---|
id |
string | Unique share identifier |
token |
ShareToken | The share token with encryption details |
bucket |
string | S3 bucket containing shared content |
recipientName |
string | Display name (or "Public Link"/"Password Link") |
label |
string? | Optional user-defined label |
sharedAt |
datetime | When share was created |
isRevoked |
bool | Whether share has been revoked |
linkSecretKey |
string? | Base64 secret key for public links |
passwordSalt |
string? | Base64 salt for password-protected links |
Playlists are stored encrypted for recovery across devices:
Storage Location:
Bucket: playlists
Key: user-playlists/{playlistId}.json
Decrypted JSON Structure:
{
"id": "playlist-uuid",
"name": "My Favorites",
"tracks": [
{
"id": "track-uuid",
"path": "/storage/emulated/0/Music/song.mp3",
"name": "Song Title",
"artist": "Artist Name",
"album": "Album Name",
"duration": 180000,
"artworkPath": "/path/to/artwork.jpg"
}
],
"createdAt": "2024-01-15T10:30:00.000Z",
"updatedAt": "2024-01-20T15:45:00.000Z",
"cloudKey": "user-playlists/playlist-uuid.json",
"isSyncedToCloud": true
}Playlist Fields:
| Field | Type | Description |
|---|---|---|
id |
string | Unique playlist identifier |
name |
string | Playlist name |
tracks |
AudioTrack[] | List of tracks in order |
createdAt |
datetime | When playlist was created |
updatedAt |
datetime | Last modification time |
cloudKey |
string? | S3 key if synced to cloud |
isSyncedToCloud |
bool | Whether synced to cloud |
AudioTrack Fields:
| Field | Type | Description |
|---|---|---|
id |
string | Unique track identifier |
path |
string | Local file path |
name |
string | Track/file name |
artist |
string? | Artist name from metadata |
album |
string? | Album name from metadata |
duration |
int | Duration in milliseconds |
artworkPath |
string? | Path to album artwork |
For the gateway at https://cloud.fx.land/view:
Parsing Share Links:
URL: https://cloud.fx.land/view/{shareId}#{payload}
1. Extract shareId from path
2. Extract payload from URL fragment (client-side only)
3. Base64url-decode payload
4. If password-protected: prompt for password, derive key with PBKDF2
5. Decrypt payload to get token, bucket, path, and secretKey
6. Use secretKey to decrypt wrappedDek in token
7. Use decrypted DEK to access files in bucket/path
Fetching Owner's Share List:
1. Authenticate owner (get their encryption key)
2. Compute userId from owner's public key
3. Fetch: fula-metadata/.fula/shares/{userId}.json.enc
4. Decrypt with owner's encryption key
5. Parse JSON to get list of OutgoingShare objects
Fetching User's Playlists:
1. Authenticate user (get their encryption key)
2. List objects: playlists/user-playlists/*.json
3. For each object: download and decrypt with user's key
4. Parse JSON to get Playlist objects
Generate NFTs from your photos and let your friends and family claim them with zero gas. No smart contracts, no fees — just import your asset, generate an NFT, and share it with your friends or put it on OpenSea. Recipients claim with no wallet top-ups and no confusing transaction popups. Just sign, claim, and it's theirs. NFTs show up on OpenSea automatically — ready to view, share, or show off. Perfect for non-crypto people who don't even have a wallet.
Built on ERC1155 tokens. tokens are permanently locked inside NFTs and can only be released by burning the NFT. Claims are gasless via a server-side meta-transaction relay that sponsors gas on behalf of the claimer.
Create Collection → Import Images → Generate NFTs → Share Link → Friends Claim (Zero Gas) → View on OpenSea
Users can:
Every NFT operation shows a wallet picker before proceeding:
| Wallet | Source | Use Case |
|---|---|---|
| Internal Wallet | Auto-derived from sign-in credentials via HMAC-SHA256 + secp256k1 (web3dart) | Non-crypto users — no setup required |
| Connected Wallet | External wallet via Reown AppKit (WalletConnect) | Crypto users who want to use MetaMask, etc. |
If only one wallet is available, it auto-selects. If neither is available, the user is prompted to sign in or connect.
Internal wallet derivation:
encryptionKey = Argon2id("{provider}:{userId}:{email}", "fula-files-v1") → 32 bytes (existing)
nftPrivateKey = HMAC-SHA256("nft-wallet", encryptionKey) → 32 bytes
nftAddress = EthPrivateKey(nftPrivateKey).address → "0x..."
The internal wallet uses web3dart's EthPrivateKey for proper secp256k1 address derivation and Web3Client.sendTransaction() for on-chain signing.
User flow: Create Collection → Import Photos → Choose Wallet → Configure (count, Backend, chain) → Generate
Pipeline (5 checkpointed steps):
Upload to IPFS → Approve token spend → mintWithFula() → Poll Receipt → Parse Token ID
approve() so the NFT contract can pull tokensEach step is persisted to Hive. If the app crashes or the transaction fails, "Retry" resumes from the last successful step (skips upload if CID exists, skips approval if tx exists).
For internal wallets, approval uses NftWalletService.sendApproveTransaction() (ABI-encodes ERC20 approve and signs locally). For external wallets, it goes through WalletService.sendContractTransaction() via WalletConnect.
Creator side: On a minted NFT card → "Share Claim" → Configure → Share link
The claim dialog offers:
claimer = address(0) on-chain. First person to open the link claims it.The contract escrows 1 NFT via createClaimOffer() and returns a linkHash. A deep link is generated:
fxfiles://nft-claim?chain={chainId}&contract={address}&token={tokenId}&hash={linkHash}
Claimer side: Open link → App shows NFT details (image, creator, NFT, supply) → Choose Wallet → Claim (zero gas)
The claim screen fetches token info from the contract via eth_call, displays the NFT image from the IPFS gateway. Claims are submitted to the server-side relay (/api/v1/nft/relay) which broadcasts the transaction and pays gas on behalf of the claimer. The claimer only signs an EIP-712 message — no gas tokens needed. Pre-claim checks detect already-claimed or expired links.
Sponsored gas (meta-transaction relay):
claimNFTMeta() using a funded relay walletAfter claiming, the screen shows Transfer and Burn buttons.
Standard ERC1155 safeTransferFrom(). tokens remain locked inside the NFT — transfers do NOT release tokens. The UI shows: "Transfer keeps tokens locked. Only burning releases tokens."
Flow: Choose Wallet → Enter recipient 0x... address → Confirm → safeTransferFrom() → Poll Receipt
NFTs can be transferred any number of times between any wallets. The tokens only comes out when someone burns.
The only way to release locked tokens from an NFT is to burn it. Burning permanently destroys the NFT and sends the proportional tokens to the burner.
Flow: Choose Wallet → Confirmation dialog ("This will permanently destroy the NFT and release X tokens to your wallet. This action cannot be undone.") → burn(account, tokenId, amount) → Poll Receipt
The contract's burn() override:
super.burn() — standard ERC1155 burn (checks caller is owner or approved, zeros balance)fulaToRelease = tokenInfo[id].fulaPerNft * amounttotalLockedFulastorageToken.safeTransfer()NftBurned(tokenId, burner, amount, fulaReleased)burnBatch() works similarly for multiple token types in one transaction.
FulaFileNFT.solERC1155 upgradeable contract using OpenZeppelin v5.3.0 + GovernanceModule (UUPS proxy).
Deployed identically on Base (chain 8453) and Skale Europa (chain 2046399126).
// Mint — caller must approve() tokens spend first mintWithFula(string ipfsCid, uint256 fulaPerNft, uint256 count) → uint256 firstTokenId // Claim — sender creates offer (escrows NFT), recipient claims createClaimOffer(uint256 tokenId, address claimer, uint256 expiresAt) → bytes32 linkHash claimNFT(bytes32 linkHash) // direct claim (claimer pays gas) claimNFTMeta(bytes32 secret, address signer, uint256 deadline, uint256 nonce, bytes signature) // sponsored claim (relay pays gas) // claimer = address(0) → open claim (anyone can claim) // claimer = 0x1234... → only that address can claim // Burn — permanently destroys NFT, releases locked tokens to burner burn(address account, uint256 id, uint256 value) // single token type burnBatch(address account, uint256[] ids, uint256[] values) // multiple types burnMeta(bytes32 claimKey, uint256 tokenId, uint256 amount, address signer, uint256 deadline, uint256 nonce, bytes signature) // sponsored burn // Transfer — standard ERC1155, tokens stays locked safeTransferFrom(from, to, id, amount, data) // inherited from ERC1155 // Cancel — sender (after expiry) or admin can cancel stuck offers cancelClaimOffer(bytes32 linkHash) // Read getTokenInfo(uint256 tokenId) → (creator, ipfsCid, fulaAmount, totalSupply) getClaimOffer(bytes32 linkHash) → (tokenId, sender, claimer, expiresAt, claimed) getCreatorTokens(address) → uint256[]
Security features:
totalLockedFula tracking prevents admin recoverERC20 from draining locked fundsipfsCid length validation (1-256 bytes)nonReentrant + whenNotPaused on all write functions| Component | Role |
|---|---|
NftService |
Orchestrates mint/claim/burn/transfer flows, Hive persistence, cloud sync |
NftContractService |
ABI encoding, RPC calls, receipt polling |
NftWalletService |
Deterministic wallet derivation (web3dart), transaction signing |
WalletService |
External wallet via Reown AppKit (WalletConnect) |
NftNotifier (Riverpod) |
UI state: isMinting, isClaiming, isBurning, isTransferring, error |
nftMintsProvider |
StreamProvider.family — real-time mint status updates per collection |
nftTagsProvider |
Filters tags with nft- prefix to list NFT collections |
Wallet dispatch: All transaction methods accept a WalletSource enum (internal or external). Internal uses NftWalletService.sendSignedTransaction() (web3dart Web3Client). External uses WalletService.sendContractTransaction() (Reown AppKit).
| Type ID | Model | Description |
|---|---|---|
| 30 | NftCollection |
Collection with tagId, name, list of mints |
| 31 | NftMintRecord |
Mint state: CID, txHash, tokenId, status, claims |
| 32 | NftClaimRecord |
Claim state: linkHash, claimer, status, tx hashes |
| 33 | NftMintStatus |
Enum: approving, minting, confirming, completed, error |
| 34 | NftClaimStatus |
Enum: pending, claimed, burned, expired |
NFT metadata is encrypted and synced to the nft-metadata S3 bucket:
Bucket: nft-metadata
Key: .fula/nfts/{userId}.json
On login, restoreFromCloud() merges cloud data with local state, preserving any in-progress mints. Sync is debounced (5s) and triggered after mints, claims, and burns.
fxfiles://nft-claim?chain=8453&contract=0x...&token=123&hash=0xabc...
Replace the zero-address placeholders in SupportedChain.nftContractAddress with the real proxy addresses for each chain.
FxFiles ships a cloud-only web app at https://files.fx.land/app/ (the same encrypted vaults as mobile/desktop; sign in with a Mode C recovery phrase). The local-file-manager features are native-only by design — the web compile graph never imports them.
lib/main_web.dart (web shell under lib/web/); build
with flutter build web --release -t lib/main_web.dart.web/pkg/ (committed) and MUST match the fula_client version in
pubspec.lock — after bumping fula_client run
tools\sync-wasm-pkg.ps1 and commit web/pkg/. The Pages deploy
fails fast on a mismatch.main touching lib/, web/, site/ or
pubspec redeploys GitHub Pages (.github/workflows/deploy-pages.yml).
The artifact keeps site/ byte-identical at the domain root (the
/nft-claim and /autopin-complete forwarders and .well-known
app-link files are load-bearing for native deep links) and serves
the app under /app/.docs/AUTOPIN-HANDOFF.md),
which returns to files.fx.land/autopin-complete#secret=… →
"Continue in web app". Known limitation: the web app cannot use the
Blox LAN gateway (http://<lan-ip> is mixed content and browsers
have no mDNS), so web downloads always come from the cloud; pairing
still makes the Blox auto-pin your files. The stored credentials are
local to that browser — pair native/desktop FxFiles separately
(desktop's manual dialog accepts the pairing secret).--dart-define=E2E=true, then drive
headless Chrome with ?e2e=create|signin|restore|signout|upload|
download|list|delete|share (results print with an [e2e] prefix).
Production builds compile the hooks out.This project is licensed under the MIT License - see the LICENSE file for details.
functionland/FxFiles is a public repo on GitHub by functionland. FxFiles Flutter app integrated with S3 API.
It declares no license on GitHub. Public does not mean open source: without a license, nobody is granted the right to reuse it.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-10-14. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
The trust-minimized, zero-knowledge bridging protocol, designed for censorship resistance, extremely high security, and usage in decentralized finance.

30 Days of Solidity step-by-step guide to learn Smart Contract Development.
A curated list of peer-to-peer, federated, and local-first protocols, applications, and developer tools. Excludes cryptocurrency, tokens, and AI agents.
An open-source remote desktop application designed for self-hosting, as an alternative to TeamViewer.
Github repo for the code of Ethereum Dapps In Motion (Manning): https://www.manning.com/livevideo/ethereum-dapps-in-motion

"Fx Fotos" is an opensource gallery app in react native with the same smoothness and features of Google Photos and Apple Photos. It is backend gnostic and connects to decentralized backends like "box", "Dfinity", "Filecoin" and "Crust".
You want to literally own your files? This is something won't happen on traditional cloud services in a lifetime. And this is something is going to happen in a glance with "Fx Files" app from now on. It is a file manager which stores everything on Fula blockchain network of Bloxes.
Client-server stack for Web3! Turn your Raspberry Pi to a BAS server in minutes and enjoy the freedom of decentralized Web with a superior user experience!
This repository contains the fula dockers that runs on Linux and is responsible for managing the over the air update, blockchain and protocol services
Custom script to build the OS image for fulatower plus (RK1-Armbian)
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/functionland/FxFilesTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.