Basebricks

An open-source operating system for shared property ownership.

Code is not law.

The blockchain is a transparent, tamper-proof record. It is not the source of truth. The legal documents are.

Every consequential action — a forced sale, a transfer, a capital call enforcement — must be backed by a signed legal document uploaded and anchored on-chain. No document, no action.

If an owner loses their wallet, gets hacked, or dies, they do not lose their property. Their ownership is recorded in real-world legal instruments (deed, LLC operating agreement, tenancy-in-common contract). Basebricks can reissue tokens to a new wallet on the strength of those documents.

Tokens are pure utility tokens — fully visible on any block explorer, fully auditable, but non-transferable outside the platform. They live in platform-managed vaults that nothing and no one can move them out of. There is no market, no price, no speculation. They are accounting entries with cryptographic guarantees, nothing more.

Property funds live in per-property smart-contract vaults, not in operator-controlled wallets. A platform breach can never reach property assets. The operator's exposure is bounded to their own management fees.

You don't buy the token; you buy a share of the property through ordinary legal channels. The token tracks it.

This is the principle Basebricks is built on. Everything below follows from it.

Basebricks is an open-source operating system for shared property ownership.

Buying property with other people — four friends and a ski cabin, a family inheriting a house, a small syndicate pooling capital for a rental — usually means a tangle of spreadsheets, group chats, awkward Venmo requests, and a lawyer on speed-dial. Basebricks replaces that with a single platform that handles ownership, money, and decisions cleanly from day one.

The platform is open-source and self-hostable. Anyone can run their own instance, audit the code, or fork it. There is no platform fee and no gatekeeper.

Core Features

1. Ownership & Cap Table Issues utility tokens representing each co-owner's stake, held in platform-managed vaults. The cap table is fully on-chain and publicly auditable, but the tokens themselves never leave the vault. Every change traces back to an underlying legal document.
2. Income & Expense Ledger Logs rental income, deducts agreed-upon costs, and splits the remainder pro-rata among owners. Owners can claim their share to a wallet or request a fiat transfer. Expenses work in reverse: anyone can log a repair, a tax bill, or a maintenance cost, and the platform tracks who paid and who still owes.
3. Capital Calls & Reserve Fund When the property needs money rental income can't cover, admins issue a capital call — a proportional request to every owner. If someone doesn't pay, the system pauses their future distributions and credits the shortfall against what they owe, until they're back in good standing.
4. Decisions & Document Trail Every meaningful decision — approving a renovation, accepting a tenant, agreeing to sell — can be put to a stake-weighted vote. The result and the underlying document are hashed and anchored on-chain, creating a record of what the group actually agreed to and when. Years later, when memories disagree, the record is there.
5. Exits & Secondary Transfers Owners can transfer to other owners, sell to outside buyers (with optional right-of-first-refusal for the group), or be exited through a structured legal process if they go persistently delinquent. Every such action requires a corresponding legal document — a sale agreement, a court order, a signed buyout — uploaded and anchored. The chain reflects what the law has already authorized; it doesn't authorize anything itself.

Admin architecture: today and tomorrow

A note on the threat model first. Property funds — rent collected, reserve balances, capital call contributions — live in per-property vaults controlled by smart contracts. The platform operator's hot wallet has no privileged path to those funds. A hot wallet breach exposes only the operator's own working capital (accumulated management fees, gas float), never the properties or the owners.

• Today (development phase). Basebricks operates a backend hot wallet with the private key stored as an environment variable, paired with a cold wallet for sweep-down. In settings, each instance configures a target hot wallet balance and a cold wallet address; anything above the threshold is automatically swept to cold storage the operator controls. So a hot wallet breach exposes only the working float of the operator's own funds — properties and owners are insulated by the vault architecture.
• Production phase. Admin actions migrate to a Gnosis Safe multisig. Super Admins connect via MetaMask. When a high-stakes action occurs (minting, deploying a property, withdrawing reserves):
  • The backend prepares the raw transaction.
  • The dashboard prompts the Super Admin's wallet to sign.
  • The Super Admin pays gas and broadcasts.
  • The backend listens for on-chain confirmation before updating the database.

This means a 2-of-3 (or 3-of-5, etc.) signature requirement on any movement of assets — and removes even the operator's working float from single-key risk. The platform becomes genuinely trustless at the admin layer, in keeping with “code is not law”: the humans with legal authority are the ones authorizing actions, and the chain records them.

Open-source by default, managed by choice

Basebricks is open-source and self-hostable. A group comfortable running their own instance can do so, forever, for free.

For everyone else — and realistically, that's most groups — there will eventually be a hosted Basebricks service that handles the infrastructure, plus optional full-service property management for groups who'd rather not deal with tenants, repairs, or paperwork themselves. Think of it like the Android model: the platform is open and anyone can run it, but most people use the managed version because it's easier. The protocol is the product; the managed service is a convenience on top.

On forks

Basebricks is opinionated. Code is not law, tokens are accounting entries, legal documents are the source of truth. Some people will disagree — they'll want a fully trustless system where the smart contract really does have final say, with no admin keys, no document uploads, and no human override. That's a legitimate design philosophy; it just isn't this one.

If someone forks Basebricks into that version, good. They'll learn what we already think we know — that real-world property doesn't fit cleanly into pure on-chain logic, and that the “trustless” version eventually has to deal with stolen keys, dead owners, and court orders, just like the rest of us. Basebricks will tick tock next block.