Earn and invest across chains. We’re building Sleeve for USDC earning on Arbitrum, USDG and stock tokens on Robinhood, and cash exits through one user-controlled app.
Put digital dollars to work. Invest only the amount you choose. Know what comes back.
We’re building Sleeve, a cross-chain capital and liquidity protocol that connects earning positions, stock-token investing and cash movement through one user-controlled application.
Our first intended customer already holds stablecoins and occasionally wants stock-token exposure. Their goal is a financial outcome, not a sequence of vault withdrawals, token conversions, transfers and trades. Sleeve is designed to coordinate those steps while keeping the customer’s ownership, costs and spending limits clear.
Add money: supported funds become an approved earning position. The user receives the exact approved vault shares through a primary deposit or a qualified purchase of those same existing shares.
Buy / sell stock tokens: a purchase uses only the authorized budget. Untouched earning shares remain separate. A sale returns net proceeds to the approved earning position, and any required remainder from a purchase is accounted for and redeposited. Stock-token holdings are a separate investment; they do not earn cash yield in Sleeve v0.
Cash out: compare qualified native redemption and funded share-sale routes, show the expected and protected result, and deliver the approved stablecoin outcome. Any discount from the position’s reference value is visible before authorization.
Arbitrum is the initial destination for USDC earning and funded share liquidity. Robinhood Chain is the intended destination for USDG earning and stock-token execution. LI.FI is our selected cross-chain integration; exact asset pairs and destination actions must qualify before a route is offered. Local actions stay local when that is the appropriate path.
We are also developing Uniswap v4 hook and DualPool integrations for selected local execution and productive operator trading inventory. These are capabilities inside Sleeve, not separate products or compulsory steps in every transaction.
Sleeve’s share market is designed to exchange approved earning shares and cash using separately contributed operator capital. The maker bears the inventory risk of shares it buys. Customer positions, liquid exit reserves and productive trading inventory remain separately attributed.
The market does not receive preferred routing because Sleeve operates it. A better qualified native route should win. Capacity is finite, and no instant withdrawal at full value is promised.
The application brings owned shares, available valuation, underlying exposure, data freshness, performance and activity into a clean Web3 interface. Deposits, stock-sale proceeds and secondary-market discounts are kept distinct from interest. Execution records connect the reviewed terms to the resulting assets and any permitted recovery.
The current implementation includes locally exercised accounts, cash and stock-test execution, share-market logic, position views, accounting, recovery and a shared transaction composer. A public non-financial application shell and documentation are recorded in the repository. The newly merged history implementation uses recorded position marks and chain time rather than invented performance data.
At the inspected 4 October source snapshot, completed financial evidence remains local. Real onboarding, the hosted financial runtime, public-testnet customer journeys and external-provider integrations remain the next qualification milestones. This is a prototype, not an audited mainnet service.
Our next goal is to complete the native journeys on both public testnets, qualify connected execution paths, and test repeat usage with independent users. The longer-term ambition is to make those capabilities reusable by other applications.
Your dollars don’t sit.
During the buildathon, we developed Sleeve into an integrated local prototype of a cross-chain capital and liquidity protocol, bringing earning positions, stock-token investing, liquidity and cash movement into one user-controlled application.
We consolidated the product around three actions: Add money, Buy/sell stock tokens, and Cash out. The architecture gives each destination a native role: USDC earning and initial share liquidity on Arbitrum, and USDG earning with stock-token execution on Robinhood Chain. The user authorizes a specific allocation; untouched positions remain separate, and net stock-sale proceeds return to the approved earning position.
We also completed the integration specifications for LI.FI routing, Uniswap v4 hooks, DualPool, modular earning-position adapters and segregated operator liquidity. These capabilities form one Sleeve protocol rather than separate applications.
We implemented and locally exercised user-controlled account flows, bounded deposits and redemptions, stock-test buying and selling, and resweeping proceeds into earning shares. The execution system includes immutable quotes and transaction preparation, explicit spending limits, protected outputs, recipient constraints, approval/reset tracking and authorization checks.
The local application connects the reviewed operation to its resulting assets and account state. Submission, confirmation and successful financial execution remain distinct states rather than being represented by one generic success notification.
We built the local funded share-market implementation and native-versus-secondary route comparison. The market exchanges approved earning shares and cash using separately attributed operator inventory. It incorporates bounded quotes, finite capacity and explicit execution terms.
The routing principle is that a better qualified native route should win. Customer positions are not the maker’s reserve, and a secondary exit must disclose its actual price and any difference from reference value. The broader design also separates liquid exit reserves from productive trading inventory intended for DualPool integration.
We implemented local ERC-4626 position assessments, ownership-scoped position APIs, valuation and exposure views, and customer accounting that distinguishes principal movements from changes in position value. Deposits, stock-sale proceeds and secondary-market discounts are not automatically classified as interest.
We added position-value history based on recorded observations and actual block timestamps. Historical marks are associated with the account and canonical chain state; the application does not manufacture earlier performance or backfill an unobserved growth curve.
We built a dark-first Web3 interface with portfolio and position views, a shared transaction composer, readable operation phases, approval activity, pending-operation explanations and recovery history. The interface brings reviewed terms, owner authorization, resulting holdings and receipts into a consistent experience.
Recorded local browser journeys connect the frontend to the application backend, PostgreSQL and Anvil. They exercise stock-test purchases, sales, resweeping, reload continuity and isolation between customer accounts. We also published the non-financial application shell and thirteen documentation guides.
We implemented the backend foundations for authenticated access, durable operations, reservations, transaction tracking, canonical observation and financial reconciliation. Recovery is tied to the actual authorization and execution evidence rather than assuming that a timeout means a transaction failed.
The implementation records enough state to resume observation after a reload or interruption and distinguishes completed operations, failed execution and unresolved states requiring further evidence.
We added a deployment and journey harness restricted to Arbitrum Sepolia and Robinhood Chain Testnet. Its local validation covers bounded deposits and redemptions, rejection of impossible minimum outputs, wrong-signer rejection and nonce-proven cancellation.
The recorded harness tests use local chains emulating the target network IDs. Actual public-network deployments and hosted customer journeys are separate completion milestones.
The remaining release work connects this foundation to real customer onboarding, account provisioning, owner-controlled signing and recovery; qualified Arbitrum and Robinhood earning vaults; executable stock-token venues; and supported LI.FI funding and exit routes, including the dedicated Solana path where available.
It also includes the operating maker quote service and sponsorship controls, actual v4 hook and DualPool settlement, the hosted financial API and workers, and full customer journeys on both public testnets. The operational release requirements cover monitoring, backups, restore/replay exercises, mobile and accessibility verification, and an integrated security review.
The buildathon established the protocol architecture and a substantial working local implementation. The next release milestone is the complete connected testnet product, followed by an audit-ready code freeze and preparation for a capped mainnet pilot.
Sleeve is an early-stage, bootstrapped product. We have not received external investment or grant funding for Sleeve.
Our current focus is testnet development and validation, including the native customer journeys on Arbitrum Sepolia and Robinhood Chain Testnet, integration reliability, user experience and security.
We are planning a capped mainnet pilot after completing the relevant integration checks, security review and operational readiness requirements. The pilot will use limited participation, supported assets and capital exposure. Any operator liquidity will be funded and accounted for separately from customer positions.
As we approach mainnet readiness and reach a stable, audit-ready code freeze, we are preparing to apply to the Arbitrum Security Program for support toward an independent smart-contract audit. Our priority is to define the audit scope, complete pre-audit preparation, address review findings and validate recovery procedures before enabling the pilot.
We are open to milestone-based ecosystem support, security collaborators and early testing relationships that help Sleeve progress from testnet development to a carefully controlled mainnet release.