Copy-trading infrastructure · B2B
Add copy trading to your wallet.
Custody stays with your users.
One API and a typed TypeScript SDK. Your users mirror proven traders on spot and Hyperliquid perps — through credentials they approve and can revoke, never by handing over funds. These are the same rails our own products run in production.
See it in action — live today, on this infrastructure
Our consumer copy-trading surface — leader grading, activation and the execution feed, running on this API.
Our smart-account wallet integrates through the same public SDK partners use — and its ERC-7579 stack is what the spot custody model is built on.
The quickstart, venue reference and custody model — the same five calls both products are built on.
First-party products — we run our own consumer copy trading on exactly what you integrate.
Why non-custodial actually holds
The backend can submit trades.
It can never withdraw.
Spot — smart sessions
An ERC-7579 session scoped to swap routers only, with an explicit USD spend cap and a hard expiry. It cannot transfer tokens out, and it dies on its own at validUntil.
Perps — revocable agent keys
Hyperliquid copying runs through an agent key the user approves in their own wallet and can revoke at any time. Works from any EOA — no smart-account stack required.
Two credentials, always
Your partner key says who is billed. The user's wallet signature says whose funds move — EIP-191 over a canonical method+path message, replay-proof, 5-minute expiry. Neither alone is sufficient.
The integration
Five calls. One activation handshake, every venue.
No venue-specific branches in your code: the server says what needs signing, activate() signs it. The SDK is typed end-to-end and the quickstart below is compiled in CI.
import { CopyTradingClient, createWalletAuthHeaders }
from '@zifrovoy-wallet/copy-trading';
const client = new CopyTradingClient({
baseUrl: API_URL,
apiKey: PARTNER_KEY,
getAuthHeaders: createWalletAuthHeaders({
address: userAddress,
signer: personalSigner,
}),
});
const venues = await client.listVenues();
const leaders = await client.listLeaders({ venue, mirrorableOnly: true });
const { agentId } = await client.createAgent({
venue,
smartAccountAddress: userAddress,
leaderWalletAddress: leaders[0].address,
riskConfig: { maxUsd: '500', copyPercent: 10 },
});
await client.activate(agentId, signer); // one call, every venue
const { executions } = await client.listExecutions(agentId);Venues
One adapter interface, per-venue custody done right.
| Venue | Custody model | Activation | Status |
|---|---|---|---|
| Spot (EVM)spot | ERC-7579 smart session — explicit spend cap, hard expiry | One on-chain tx | Live |
| Perps (Hyperliquid)hyperliquid-perps | Agent key the user approves and can revoke — works from any EOA | 1–2 signatures, no gas | Live |
| Perps (Polymarket)polymarket-perps | Delegated proxy signer, expires ~1 week, renewable | 1 signature | In validation |
| Predictions (Polymarket)polymarket-predictions | Scoped proxy delegation — you set the expiry | 1 signature | In validation |
Polymarket venues are implemented behind the same activation handshake and are in final end-to-end validation — we list them as live only when they are.
What you get beyond execution
Leaders graded for copyability
Not the venue leaderboard. Each leader passes mirrorability gates first — on one live Polymarket screen, 2 of the top 12 by PnL survived; the rest were market makers a follower can't reproduce. Every verdict ships with plain-language reasons and its evidence.
Skips are first-class
A mirror that would be worse than not trading is recorded as skipped with a machine-readable reason (slippage exceeded, edge exhausted, too close to resolution) — so your feed explains itself instead of showing silent gaps.
A real gateway in front
Per-partner keys with venue entitlements, rate limiting, metering for billing, and a circuit breaker. Keys are hashed at rest and shown exactly once.
Lifecycle you can build UI on
Execution feed with one shape across venues, agent status transitions (paused vs expired are distinct), and a session.expiring signal so you can prompt re-authorisation before credentials lapse.
Onboarding
Scope the integration
A call with the team that built it. We map your wallet stack to the custody model — EOA-only apps start with perps, no smart-account infra needed.
Build in paper mode
You get a scoped API key and build against the sandbox: real leader data and the full activation flow, no funds at risk.
Go live
Flip to live execution when your flows are proven. Metering and entitlements are already on your key.
Ship copy trading without building the hard parts.
Leader grading, venue handshakes, custody, execution and the gateway are done. What's left is your UI.