Wallets
Embedded wallets, three lines in.
Non-custodial. iOS and TypeScript SDKs. Created inside your app — no redirects, no seed phrases.
The onchain stack. One SDK.
Don't pick five vendors. Pick the stack. Wallets, payments, NFTs, identity, agents — one API surface. Non-custodial. EVM-native. Same stack for human SDKs and AI agents via MCP.
PREBUILT 5 FUNCTIONS
Same call on every EVM chain.
non-custodial · scoped keys
wallets.create --chain ethereum --gasless
- wallet ready 0x2fd8…41ce · smart account · Ethereum
- state balance 1.284 ETH · nonce 0 · gasless
- keys passkey + policy signer · recovery armed
1 call · gasless · EVM
Quickstart
Two ways in. The same core.
Hand the platform to an agent as tools, or call it from your own code.
For your agent
Point an agent at it.
The MCP server hands any agent-aware runtime the whole platform as callable tools.
- Add the server One entry in mcp.json, backed by a local key the model never sees.
- Tools appear Wallets, smart accounts, transactions, and 2FA arrive as tools.
- Ask in plain English “Create a wallet and cover the gas on its first transaction.”
For your app
Wire the SDK in.
A typed SDK, or the HTTP API directly. Either surface, the same core.
- Install npm i @fabricbloc/sdk, or call the HTTP API with no dependency at all.
- Get a project key One key connects all five primitives.
- First gasless call Create a wallet, cover the gas, sign — three lines.
Primitives
The layer between your app and the chain.
Wallets, tokens, NFTs, vaults, and agents resolve to built-in primitives — each primitive is one SDK call with consistent error shapes and webhooks.
Tokens
Mint and move at scale.
Issue ERC-20s, cover gas, enforce transfer policies. One API for deploy, mint, and move.
Vaults
Custody with rules attached.
Programmable vaults with deposit, withdraw, and sweep rules. Funds move when your policy says so.
Networks
One schema for every chain.
Ethereum, Base, Polygon — same SDK shape, same request format. Switch chains with a string.
Architecture
One hop, and your keys never move.
- STEP 01 YOUR CODE
Your application
- One SDK, one key
- Chain as a string, not a rewrite
- Types shared across primitives
- STEP 02 FABRICBLOC
The gateway
- Routing, signing, gas sponsorship
- Policy checks before broadcast
- Idempotent writes and retries
- STEP 03 NETWORKS
The chains
- Ethereum, Base, Polygon today
- New networks behind the same call
- Indexed reads, normalised events
Agents · MCP
The same stack, exposed to agents via MCP.
Not a second product — the same primitives, reached over MCP. Keys stay scoped and non-custodial, every tool call runs inside a spend cap you set, and nothing signs outside policy.
- scoped MCP tools
- non-custodial keys
- spend caps
- full audit trail
mcp fabricbloc / agent session
session.open agent ops-1
- wallet:sign granted - project keys, never exported
- token:transfer granted - allowlisted contracts only
- vault:read granted - balances, no withdraw
- spend cap 25 USDC per day, enforced at the gateway
- audit every call recorded with its agent and scope
Claude · Cursor · any MCP client
- The client connects once One entry in the client config, backed by a local key the model never sees.
- The proxy holds the policy Scope, spend cap, and allowed tools resolve at the gateway - never in the prompt.
- The same primitives answer Wallets, tokens, and vaults respond exactly as they do to your own SDK calls.
claude mcp add fabricbloc -- bunx fabricbloc-mcp
# Cursor, Windsurf, Zed and the rest read the same config:
bunx fabricbloc-mcp install Then ask Claude Code · Cursor · any MCP client
Using the FabricBloc tools, create a smart account on Base, fund its gas from the project sponsor, and send me the address.
Non-custodial
Keys stay on your side.
The agent receives tool results. A private key never enters the context window, the client config, or the log.
Spend caps
A ceiling the gateway enforces.
Per-key daily and per-call limits. A call over the cap fails before it reaches a chain, not after it settles.
Signed trail
Every call, attributable.
Agent, scope, arguments, and outcome recorded per tool call, and replayable through the same webhooks your app uses.
Infrastructure
The parts you only notice when they are missing.
Gas sponsorship, webhook replay, scoped keys, and real-time telemetry — built into the platform so you do not bolt them on later.
Gas sponsorship
Invisible gas, visible balance.
Sponsor transactions so users never think about gas. Budgets and policies set server-side.
Webhooks
Delivery with replay.
72-hour event replay. Filter by type, chain, or wallet. No polling, no missed state.
Scoped keys
Least privilege by default.
Every key carries its own policy. Read-only, sign-only, spend-capped — enforced at the gateway.
Observability
Onchain telemetry, real time.
Balances, transfers, throughput — streamed to your dashboard. Debug without a block explorer.
Pricing
Start free. Scale on the same stack.
Planned tiers while we onboard in waves — Free at $0, Pro at $60/mo USDC, Scale at $200/mo USDC. Request access today; self-serve billing opens when we go live.
Coming soon Planned tiers below — request access while we onboard in waves. Self-serve billing is not live yet.
Free
$0 / mo
Proof-of-concept caps — build and demo the whole stack.
- All five primitives
- Testnets included
- Proof-of-concept call caps
- Community support
Most teams
Pro
$60 / mo USDC
For scaling projects moving real volume.
- Unlimited gateways
- Sponsored gas included
- MCP agent rails
- Webhooks with 72h replay
- Email + Slack support
Scale
$200 / mo USDC
Higher throughput and hands-on support for production teams.
- Elevated API and webhook quotas
- Extended webhook replay window
- Priority support queue
- Dedicated onboarding session
- Multi-workspace admin
The onchain stack. One SDK.
Start with the onchain stack.