Secure Wallets that follow Rules,
not just signatures.
Fiber is the policy layer between custody and execution. We built Programmable Wallets that prevent unwanted risks through Security Guardrails for what wallets can and cannot do.
- transfer()→ aliceexecuted
When Keys leak, impacts are Uncontrolled
Every wallet on-chain today shares the same failure model: hold the key, hold the funds. The largest losses in crypto don't trace back to broken contracts — they trace back to a single signature that should never have been allowed to land.
One key. Total loss.
A leaked .env file. A phished signer. A compromised dev machine. An AI agent with a hot key in memory. Today there is no second check, no fallback, no on-chain ceiling — whoever holds the key holds everything.
A signature is a blank check.
The wallet never inspects what's inside the transaction: the amount, the recipient, the protocol. It just signs and forwards. If a key approves the call, the funds move — no questions asked.
Wallets need their own rules.
The wallet should be the line of defense, not the human signing for it. It should know its own limits, refuse what's not allowed, and stay safe even when the people holding its keys aren't.
Move the rules into the wallet itself.
Fiber turns wallets into programmable accounts that enforces policy on-chain — before any action lands. Even with a stolen key, the wallet refuses to do what the rules don't allow.
- Limit actions to specific programs or instructions
- Transfer to only whitelisted addresses
- Prevent interacting with unknown actions
- Add Spending Caps for certain actions
- One Rule for Multiple Wallet Managements
- Secure Control & Guardrails
The wallet stays safe — even when the keys don't.
Secure treasury and delegation.
Run secure treasury with defined rules and role-based controls. Wallets have clear guardrails on its allowed actions and fund transfers.
- Role-based delegation across teams
- Spending caps per program, per call
- Policy handled & updated by Multisig or DAO
- Emergency pause without disabling delegations
Agents that can't go rogue.
Stop trusting agents to sign blindly. Restrict actions to specific protocols, tokens, and amount bands. Every bad attempts gets blocked and can be audited.
- Whitelisted programs and instructions
- Hard parameter bounds to limit spendings
- Deterministic, does not go out of control
- Every reject is auditable on-chain
Vaults & Funds Guardrails.
Protect user funds & activities with predefined policies. Let accounts execute strategies, but within the guardrails you set. Update rules as market changes — no redeploys, no migrations.
- Gatekeep transactions within your protocol actions
- Configurable Rules for vaults and strategies
- Rules & Policy updateable via governance
- Customizable Logic based on your use cases
In-app wallets that know their place.
Ship embedded wallets that are restricted to exactly what your app does. Users can't be tricked into signing outside your app's context — and neither can a compromised SDK.
- Restrict wallet to your app's programs only
- Block transfers outside approved recipients
- Prevent asset drain from compromised sessions
- One policy - secure all your user wallets
Write policy like you write code — without shipping any.
The TypeScript SDK turns rule authoring into a builder API. Every call resolves to a deterministic on-chain RuleConfig.
// COMING SOON: Wait for the Future SDK release.
import { Fiber, allow, when } from "@fiber-ag/sdk";
// 1. Define a policy as data.
const policy = Fiber.policy({
authority: treasury,
rules: [
allow("jupiter.swap").where(
when.amount.lte("10_000_USDC"),
when.outputMint.in([USDC, SOL, JUP]),
),
allow("kamino.deposit").where(
when.amount.lte("50_000_USDC"),
when.market.eq(MAIN_MARKET),
),
allow("spl.transfer").where(
when.recipient.in([alice, bob, payroll]),
),
],
});
// 2. Bind it to an escrow. Owner keeps custody.
await fiber.bindEscrow({ owner, delegatee: agent, policy });
// 3. Agent can now execute — but only what the rules allow.
await fiber.execute(agent, jupiterSwap({ amount: 5_000n }));- ▾policy
- ●allow jupiter.swap
- └─amount ≤ 10,000 USDC
- └─outputMint ∈ {USDC, SOL, JUP}
- ●allow kamino.deposit
- └─amount ≤ 50,000 USDC
- └─market = MAIN_MARKET
- ●allow spl.transfer
- └─recipient ∈ {alice, bob, payroll}
Ready to secure your wallet execution?
Fiber open discussions to design partners now. Join the waitlist for SDK access, integration support, and a direct line to the team building the architecture for Secure Wallet Management.