Deployments

An ABX FS chunk id commits to the storage backend address as well as the bytes, so a different backend address is not a configuration preference — it is a different content-address space. Two uploads of byte-identical content through different backends produce different CIDs and do not deduplicate against each other.

Use the canonical addresses. The SDK ships them, so the CLI and the gateway need no configuration to read.

ABX FS is deployed on all six networks below: Base, Ethereum and Arbitrum One since 2026-11-03, and their testnets since 2026-10-31. Each was read back from the chain and rehearsed before the registry gained its addresses.

Networks

Every tool defaults to Base when no chain is named. Name a testnet (--chain base-sepolia, sepolia or arbitrum-sepolia) to try ABX FS without real funds.

One address on every chain

Every ABX FS contract is deployed with CREATE2 through the keyless deployer (0x4e59b44847b379578588920cA78FbF26c0B4956C) with a fixed salt, and with no constructor argument that depends on who sends the transaction. So each contract has one address on every chain, determined by its code (its bytecode commits to the exact source through solc's metadata hash):

• Content layer: ChunkStore, Sstore2Backend, FastLzSstore2Backend, FileStore, DirectoryStore. Because the backend addresses are part of every chunk id, identical bytes uploaded to any chain produce identical CIDs.
• IPFS: IpfsCidResolver.
• Org layer: OrgMeta (which deploys ProjectLinks), OrgFactory and Lens, each with its own salt. The factory's five components (ProjectHook, ProjectEnumeration, OrgMinter, ProjectCard, ProjectTraits) are not deployed by the factory: it computes where the keyless deployer will place each under one shared salt, anyone may deploy each to that address, and createOrg reverts with ComponentsNotDeployed until all five exist. The factory's address also depends on its constructor arguments (the chain's ABX contracts, the two stores and OrgMeta), and those are identical on every network listed here, so it too lands at one address.

Addresses

The build tagged abx-fs-freeze-3, at these addresses on every chain above:

The factory's three renderers have fixed addresses too: read them from the factory (card(), traits(), links()). Read every address from the SDK rather than copying it from here:

import { requireCanonicalDeployment, isCanonicallyDeployed } from "@abxfs/sdk";

isCanonicallyDeployed(8453);                        // true
isCanonicallyDeployed(137);                         // false: not a network ABX FS supports
const { name, addresses, publicRpc } = requireCanonicalDeployment(8453);

requireCanonicalAddresses(chainId) throws for a chain with no addresses on record, naming the chains that have them.

Verified source

Every contract above, the three renderers included, is source-verified on Sourcify on all six networks, as an exact match: the bytecode commits to the source text through solc's metadata hash, comments included, so the source Sourcify shows is exactly the source that was compiled. For example, the factory on Base: repo.sourcify.dev/8453/0xC5aB…2798.

Other networks

Sepolia (11155111) is the first chain with the Glamsterdam gas schedule (EIP-8037), which reprices state creation: there, deploying ProjectHook took 20.3M gas, against 2.9M on Base Sepolia. ABX FS is deployed there so that it is proven before Ethereum mainnet upgrades to the same schedule. A chain gains its addresses in the registry only once a deployment exists there, so isCanonicallyDeployed(chainId) is the honest answer at any moment.

A local chain needs no registry entry: abxfs dev deploys the content layer to Anvil through the same keyless deployer, so at the same addresses, and writes a config for it.

Picking an RPC endpoint

Every ABX FS read is an eth_call, and reading a large file or deriving its IPFS CID on chain costs gas in proportion to its size. Public endpoints differ by more than an order of magnitude in what they will execute, so the choice is load-bearing rather than cosmetic.

These are unkeyed and rate-limited. Use a keyed provider for anything sustained, and measure what a public endpoint will execute on your chain before relying on it.

The write-side ceiling is not the block gas limit

eth_estimateGas caps at exactly 2²⁴ (16,777,216) on every Base Sepolia endpoint tried, including keyed ones. That is the per-transaction execution cap of EIP-7825, not the block gas limit: Base Sepolia's block gas limit is 1.2 billion. A bundle whose estimate exceeds the cap fails to estimate at all, so the SDK clamps its bundle budget below it regardless of which RPC you point at.

Whether a given endpoint applies the same cap, or a lower one, is not something to assume. Measure it before assuming either way.