For developers and teams

Build on Fitochain.

Fitochain is an open protocol, published under the Apache 2.0 license. Build a wallet, a swap, an explorer, a market app or a game that works with any Fitochain network. You don't need anyone's permission, and every independent app makes the network more decentralized.

Get started Rules of the road
Ed25519 + SHA-256WebSocket meshNode.js 20+Apache 2.0
What you can build

The protocol already does the hard parts.

Signatures, balances, fees, swaps and one-of-a-kind items are built into the rules every node checks. Your app is the part people touch.

Wallets

Desktop, phone or hardware-style. A wallet holds one private key, signs entries locally and re-checks every chain it receives. The official phone wallet is a light node: it keeps its chain and key on the device and connects to one Cloud server.

Uses: FitoNode · send · feesFor · @names · fito:pay links · offline vouchers

Swaps & exchanges

Non-custodial trading between currencies. Both sides lock their part behind the same hash; claiming one side reveals the secret that unlocks the other, and a network notary stamps each claim or refund. Either both trades go through or neither does.

Uses: lock · claim · refund · SwapDesk

Explorers & analytics

Every entry is signed and every balance is computed from the chain, so anyone can re-check everything. Read hosted networks through the open JSON Explorer API, or run your own node and index the chains yourself.

Uses: /api/overview · /api/wallet · /api/entry · /api/search

Market apps

Build on the Fitochain Market's signed offers: Originals, currency trades and the Data Market, where files are stored encrypted and a buyer's payment unlocks a copy only they can open. The board never holds money, items or keys.

Uses: MarketClient · SwapDesk · DataDesk · /market/api/offers

Checkout & point-of-sale

"Pay with Fito" for shops and websites. Your server creates an invoice with an order reference, the customer scans its QR code, and the invoice turns paid once payments carrying that reference are accepted into the shop's chain.

Uses: Checkout · invoices API · pay links with ref

Games & apps with Originals

Tickets, memberships, in-game items, collectibles and art. An Original's ID is the hash of its mint record, so it can't be copied. Only the holder can give or lock it, and creators can set a royalty that the Market pays on every resale.

Uses: mint · give · originals · ownerOf

The protocol in 60 seconds

A chain for every user, checked by everyone.

  1. Personal chains

    Each agent (fito_ + its Ed25519 public key) signs its own numbered entries, each linked to the one before by its SHA-256 hash. Balances are computed from the chain; no other state exists.

  2. Networks with signed rules

    A network's ID (fnet_…) is a hash of its rules, signed by the issuer: name, unit, max supply, fees, money rules. Every entry names its network, and entries for any other network are invalid.

  3. Mesh gossip

    Nodes prove who they are, then talk JSON over WebSockets: new entries, full chains, peer lists and fork proofs. There is no central server in the protocol.

  4. Payments carry proof

    A payment is a signed spend in the payer's chain. The receiver records a receive that includes it, after checking the sender's history and waiting for witnesses.

  5. Fork proofs

    Two different signed entries at the same position is portable proof of a double-spend attempt. It spreads, and the cheater's later payments are refused.

  6. Locks for swaps

    A lock holds money or an Original behind a hash until a deadline. It is claimed with the secret or refunded after the deadline, each with a notary's stamp.

  7. Originals

    mint creates a one-of-a-kind item; give hands it on, received just like a payment. Giving the same Original twice is a fork.

  8. Light nodes on phones

    A phone wallet keeps its own key and chain, signs locally, and re-validates everything with the same rules. It trusts its one Cloud server's copy as confirmation, where a full node asks independent peers.

No general smart contracts: Fitochain has built-in rules (fees, limits, swaps, Originals, royalties), which keeps it light enough for phones. The full specification and security model is in docs/PROTOCOL.md.

Rules of the road

Build it so people can trust it.

Guidance for anyone building on Fitochain, drawn from how the official apps work.

Guidance, not legal advice.Laws differ by place and by what your app does. You are responsible for your own app and its compliance. When in doubt, talk to a lawyer.

Keep keys on the user's device

A user's secret key should never leave their device, and no server should ever see it.

Non-custodial is the simplest path

Users sign their own entries and your app never holds their Fito. Every protocol feature, from payments to swaps to the Market, works this way.

Custodial means licensing duties

If you hold customers' coins, or exchange them for dollars on customers' behalf, you're running a custodial business with its own licensing duties. In the US, for example, that can mean money-transmitter rules, and in California the Digital Financial Assets Law. Those duties are yours as the builder.

Never promise profits

Don't promise profits, returns or price gains. Fitochain is for useful money: rewards, credit, tickets and community currencies.

Say you're independent

Don't present your app as made or endorsed by Fito Technology, LLC. "Works with Fitochain" is accurate; "the official Fitochain wallet" isn't.

Show the fee before every payment

Every payment on Fitochain networks includes the 0.25% network fee written into the signed rules, plus any owner fee. Show who, how much and the fee before the user confirms, as the official wallet does. node.feesFor(amount) gives you the number.

Treat network text as untrusted

Names and memos are written by users. Render them as text, never HTML, and check the network ID on every pay link and network file.

Get started today

Run it locally, then build against the live demo.

Run it on your computer

Download the Fitochain Launcher and source (.zip), unzip it, and you'll need Node.js 20 or newer. Then, from the unzipped folder:

npm install
npm run playground     # a local devnet with 3 wallets in your browser
npm run example:hello  # two nodes, one payment
npm run example:shop   # a "Pay with Fito" checkout
npm run example:swap   # a swap between two networks
npm test               # the attack-and-safety test suite

The docs come in the download, under docs/: PROTOCOL.md is the specification and security model, and DEVELOPERS.md is the builder's guide with the full FitoNode API, checkout, swaps, Originals and the Market.

import { newKeypair, createNetwork, FitoNode } from 'fitochain';

const owner = newKeypair(), friend = newKeypair();
const net = createNetwork({ name: 'Hello Net', unit: 'Coins',
  maxSupply: 1_000_000, issuerSecret: owner.secretHex, testnet: true });

const a = await new FitoNode({ net, secretHex: owner.secretHex, port: 7701 }).start();
const b = await new FitoNode({ net, secretHex: friend.secretHex, port: 7702,
  peers: [a.publicUrl] }).start();

b.on('received', ({ amount, memo }) => console.log('got', amount, memo));
b.setName('friend');
a.issue('@friend', 42, 'hello from Fitochain');

From examples/hello.js in the download.

The Fitochain Demo network

A live network running around the clock on Fitochain Cloud. Its Fito are test credits with no cash value, so build and break things freely.

Get builder updates

Hear when the protocol changes.

Leave your email for protocol changes, new APIs and devnet news. No spam.

Status

Devnet software, built in the open.

Test credits only

Fito on any network running this code are test credits with no cash value. Don't present them as having any.

Not yet audited

No outside security firm has reviewed the code yet. That comes before any real value.

May change before 1.0

The protocol can change before 1.0. Every entry and network carries a version, and any rule change will be a new, explicit version.

Fitochain was created by Don E. Holmes III and Jarmine Rivers.