# Overview The first DeFi super dapp. Swap and LP anything across major DeFi protocols from one intuitive interface.
Visit beautiful Shell Protocol, the best place on the EVM

The best place on the EVM

{% hint style="info" %} Want to contribute to this wiki? Please open a ticket on the [Shell Discord](/getting-started/overview/community#discord). {% endhint %} ## Overview * [Intro to Shell](/getting-started/overview/intro-to-shell) * [White Papers](/getting-started/overview/white-papers) * [GitHub Repositories](/getting-started/overview/github-repositories) * [Contract Addresses](/getting-started/overview/contract-addresses) * [Roadmap](/getting-started/overview/roadmap) * [Community](/getting-started/overview/community) * [Ecosystem](/getting-started/overview/ecosystem) # Intro to Shell The first DeFi super dapp. Swap and LP anything across major DeFi protocols from one intuitive interface. ## **What is Shell Protocol?** Shell Protocol is the first DeFi super dapp. Access as many DeFi protocols as you want, without connecting to a hundred different dapps. Instead, use just one dapp for every protocol (like Beefy, Aave, Uniswap, Curve, Balancer, Pendle, and Aerodrome). Wrong chain? Zap into any protocol from other chains in one click. Best of all, Shell is open source and permissionless—any developer can connect their protocol or build their dapp on the platform. (Already itching to try it? [Skip to the app!](https://app.shellprotocol.io/trade)) ## Imagine a DeFi super dapp... In five years, no one will build dapps for their protocols. Instead, they'll just plug into platforms like Shell and instantly connect to users. Shell minimizes the first mover advantage, ensuring new protocols can immediately access a strong user base, while users gain the latest tools without navigating a tangled web of browser tabs. It's DeFi, unified. Swap and LP anything across major DeFi protocols from one intuitive interface. Trade tokens and NFTs, stake, optimize your holdings, and track market data in the DeFi super dapp. ## **Why Shell Protocol?** * Reduce development and marketing costs by plugging your dapp into Shell and **instantly connecting** with other major DeFi protocols. * Shell Protocol lets you **atomically combine** any set of transactions, like [LPing, lending/borrowing, or making multi-token and NFT swaps](/getting-started/integrations/shell-native-primitives)—all while **significantly reducing gas fees.** * Shell is the home for clean, **modular** DeFi contracts: Its design **reduces code complexity** for builders and **improves user experience**. ## **Architecture Overview** Shell Protocol is a set of EVM-based smart contracts. Unlike other DeFi protocols that rely on monolithic, single-purpose smart contracts, Shell is a hub for a modular ecosystem of services. Its design makes it much simpler to bundle several smart contracts or build new ones, and for users to batch many services in one transaction. Shell's main smart contract is [the Ocean](/how-shell-works/the-ocean-accounting-hub), a shared accounting system for easily composing DeFi primitives. ## **Love AMMs?** The first primitive built on Shell was the [Proteus](/how-shell-works/proteus-amm-engine) AMM engine. Proteus lets you use or [create custom pools](https://docs.shellprotocol.io/tutorials/build-an-amm-with-proteus) with **concentrated liquidity** and **fungible LP tokens**. Proteus pools can also be designed to **evolve over time**, from one bonding curve to another. Proteus can precisely replicate any shape bonding curve with dramatically increased precision. Well-designed curves capture significantly more trade volume than the competition. ## History of Shell v1 (Retired) In October of 2020, Shell Protocol launched its first-ever AMM pools on Ethereum mainnet, known as [Shell v1](/how-shell-works/shell-v1-retired). They were a novel approach to a particular set of problems, offering deep liquidity and (presciently) broken peg protection for like-value tokens (such as stablecoin-stablecoin or wrapped BTC-wrapped BTC). Unfortunately Shell v1 was unique in offering broken peg protection, otherwise more protocols may have been able to mitigate damage caused by the great stablecoin crash of 2021. A visionary product in many ways, Shell v1 also contained the seeds of an ambition for a composable liquidity network — an ambition now borne out by its v2 and v3 successors. As such, after nearly two years of active life, Shell v1 transitioned into a graceful retirement. # White Papers A list of published white papers and related content ## The Ocean {% hint style="info" %} There is an upcoming addendum to the Ocean white paper, to detail modifications in Shell v3 (launched January 2024). {% endhint %} Shell v2 [Ocean White Paper](https://shellprotocol.io/static/Ocean_-_Shell_v2_Part_2.pdf) (February 2022), [blog post](https://shellprotocol.io/posts/the-ocean/) ## Proteus AMM Engine [Evolving Proteus blog post](https://shellprotocol.io/posts/introducing-evolving-proteus/) [Paper 3 (November 2022)](https://shell-protocol.notion.site/Proteus-AMM-Engine-Update-3-7f33b7e1561347b696874a8ba02b9782), [blog post](https://shellprotocol.io/posts/shell-launches-proteus-amm-engine/) [Paper 2 (September 2022)](https://github.com/cowri/Proteus/blob/main/Proteus_white_paper_UPDATED.pdf) \[past iteration] [Paper 1 (October 2021)](https://shellprotocol.io/static/Proteus_AMM_Engine_-_Shell_v2_Part_1.pdf) \[past iteration], [blog post](https://shellprotocol.io/posts/proteus-amm-engine/) ## **Legacy Resources (Shell v1)** [Shell v1 White Paper](https://github.com/cowri/shell-solidity-v1/blob/master/Shell_White_Paper_v1.0.pdf) (October 2020) # GitHub Repositories A list of important GitHub repositories ## Shell Protocol GitHub Ocean + Proteus Repo: [Ocean Reference Implementation](https://github.com/Shell-Protocol/Shell-Protocol/tree/main/src/ocean) [Example of sending a swap through the Ocean](https://github.com/Shell-Protocol/Shell-Protocol/blob/bfbba01472200a4a34ace4cb131f775018cf47c2/test/Interaction.js#L346) [Proteus Reference Implementation](https://github.com/Shell-Protocol/Shell-Protocol/tree/main/src/proteus) ## Legacy Resources (Shell v1) # Contract Addresses A list of major Shell Protocol contracts ## **Tokens** For information on governance tokens, see [Shell DAO](/shell-dao/overview). `SHELL (Arbitrum):` [`0xe47ba52f326806559c1deC7ddd997F6957d0317D`](https://arbiscan.io/address/0xe47ba52f326806559c1deC7ddd997F6957d0317D) `SHELL (Ethereum Mainnet):` [`0x8dcaec45365e5ada5676073a07b418c2f538145a`](https://etherscan.io/address/0x8dcaec45365e5ada5676073a07b418c2f538145a) `CRAB:` [`0xcf17664006851A27d5Bd93d497f30853AC558792`](https://arbiscan.io/address/0xcf17664006851A27d5Bd93d497f30853AC558792) ## **NFTs** For more information on the NFT collections, see [All About Toucans](/user-guide/all-about-toucans) or [Bro Kwon's Booty](/user-guide/earn-rewards/bro-kwons-booty). `Toucans:` [`0x642FfAb2752Df3BCE97083709F36080fb1482c80`](https://arbiscan.io/address/0x642FfAb2752Df3BCE97083709F36080fb1482c80) `Bro Kwon's Booty:` [`0x619F1f68a9a3cF939327801012E12f95B0312bB9`](https://arbiscan.io/address/0x619F1f68a9a3cF939327801012E12f95B0312bB9) ## Shell Contracts ### The Ocean `Ocean:` [`0x96B4f4E401cCD70Ec850C1CF8b405Ad58FD5fB7a`](https://arbiscan.io/address/0x96B4f4E401cCD70Ec850C1CF8b405Ad58FD5fB7a) ### External Protocols and Adapters `2CRV Adapter:` [`0x02b4ab3B517371D0BD71D325dbE7dFc0320742e4`](https://arbiscan.io/address/0x02b4ab3B517371D0BD71D325dbE7dFc0320742e4) [`2CRV Pool`](https://arbitrum.curve.fi/2pool)`:` [`0x7f90122bf0700f9e7e1f688fe926940e8839f353`](https://arbiscan.io/address/0x7f90122bf0700f9e7e1f688fe926940e8839f353) `wstETH-WETH-BPT Adapter:` [`0xA8Cb454449143912159e066760c1cf3b92415B4A`](https://arbiscan.io/address/0xa8cb454449143912159e066760c1cf3b92415b4a) [`wstETH-WETH-BPT Pool`](https://app.balancer.fi/#/arbitrum/pool/0x9791d590788598535278552eecd4b211bfc790cb000000000000000000000498)`:` [`0x9791d590788598535278552EEcD4b211bFc790CB`](https://arbiscan.io/address/0x9791d590788598535278552eecd4b211bfc790cb) ### Proteus Pools For information on pool parameters and LP token IDs, see [Shell Primitives](/getting-started/integrations/shell-native-primitives). `SHELL+ETH:` [`0xC32A9fC5665aFFCe85CF043472F718029577F7E0`](https://arbiscan.io/address/0xC32A9fC5665aFFCe85CF043472F718029577F7E0) `DAI+USDC:` [`0x96C7dC9d473e621a1e3968Cb862803EAEDe21888`](https://arbiscan.io/address/0x96c7dc9d473e621a1e3968cb862803eaede21888) `USDT+USDC:` [`0x0cb736ea2AD425221c368407CAAFDD323b7bDc83`](https://arbiscan.io/address/0x0cb736ea2AD425221c368407CAAFDD323b7bDc83) `Stablepool:` [`0x4f9d367636d5d2056f848803C11872Fdbc2afc47`](https://arbiscan.io/address/0x4f9d367636d5d2056f848803C11872Fdbc2afc47) `ETH+USD:` [`0xa2dB39e781A5Eee0EAA625dace6F097c17dfF7Ea`](https://arbiscan.io/address/0xa2dB39e781A5Eee0EAA625dace6F097c17dfF7Ea) `WBTC+USD:` [`0x3402D87DF0817b2A96b210b8873d33dD979C8D19`](https://arbiscan.io/address/0x3402D87DF0817b2A96b210b8873d33dD979C8D19) `wstETH+ETH:` [`0x2EaB95A938d1fAbb1b62132bDB0C5A2405a57887`](https://arbiscan.io/address/0x3402D87DF0817b2A96b210b8873d33dD979C8D19) `ARB+ETH:` [`0xA16F40437213020A167c230E4667ff8f13640f75`](https://arbiscan.io/address/0xA16F40437213020A167c230E4667ff8f13640f75) `TOUCOIN+ETH:` [`0x81F6F6664E8Ece1E81bc9097084373c1dDDb8Daa`](https://arbiscan.io/address/0x81F6F6664E8Ece1E81bc9097084373c1dDDb8Daa) `MAGIC+ETH:` [`0x0699645f2fd448398272ae07f82eee8d0388de1c`](https://arbiscan.io/address/0x0699645f2fd448398272ae07f82eee8d0388de1c) `Smolpool:` [`0x6896177ee52659f22a87b180e8fcb2c850a7427e`](https://arbiscan.io/address/0x6896177ee52659f22a87b180e8fcb2c850a7427e) `REUNI+ETH:` [`0x3917c74FDeC42071E29461c849bceB81cBC3059c`](https://arbiscan.io/address/0x3917c74FDeC42071E29461c849bceB81cBC3059c) `STG+ETH:` [`0xe043EB17Cc12C3fD4f5EaC765D0f1b965975F470`](https://arbiscan.io/address/0xe043EB17Cc12C3fD4f5EaC765D0f1b965975F470) ### Other `Fractionalizer Factory:` [`0x4093ee6cc764e11ce95451f47ddee9d6cc89eed4`](https://arbiscan.io/address/0x4093ee6cc764e11ce95451f47ddee9d6cc89eed4) ## **Wallets** For more on the Shell DAO Multisig, see [DAO Multisig](/shell-dao/dao-multisig). `Shell DAO Multisig:` [`0x808038B1B6C21c0C6F98cA640f8a19C19B405fba`](https://arbiscan.io/address/0x808038B1B6C21c0C6F98cA640f8a19C19B405fba) ## **Legacy Wallets** For more information on ShellDrop, see [ShellDrop DAO](/how-shell-works/shelldrop-dao-retired). `ShellDrop MultiSig:` [`0xe29fE11Fa4a6f04A6c582D75A71B0B795A3b9A87`](https://arbiscan.io/address/0xe29fE11Fa4a6f04A6c582D75A71B0B795A3b9A87) {% hint style="info" %} The [ShellMultiSig](/getting-started/security-and-bounties#proteus-pool-safeguards) is a legacy wallet that was used for Shell v2 Proteus pools. Not to be confused with the Shell DAO Multisig. {% endhint %} `ShellMultiSig:` [`0x07F076e66782918c0110e34Ee7610B0d4eE02794`](https://arbiscan.io/address/0x07f076e66782918c0110e34ee7610b0d4ee02794#code) ## **Legacy Contracts (Shell v2)** `Old Ocean:`[`0xC32eB36f886F638fffD836DF44C124074cFe3584`](https://arbiscan.io/address/0xc32eb36f886f638fffd836df44c124074cfe3584) ## **Legacy Contracts (Shell v1)** `Stablecoin pool:` [`0x8f26D7bAB7a73309141A291525C965EcdEa7Bf42`](https://etherscan.io/address/0x8f26D7bAB7a73309141A291525C965EcdEa7Bf42) `BTC pool:` [`0xc2d019b901f8d4fdb2b9a65b5d226ad88c66ee8d`](https://etherscan.io/address/0xc2d019b901f8d4fdb2b9a65b5d226ad88c66ee8d) # Roadmap A look into Shell's past, present, and future *This page was last updated on: January 23, 2023* ### 2021 * Sep 22: [First Proteus white paper released](https://shellprotocol.io/posts/proteus-amm-engine/). ### 2022 * Feb 9: [Ocean white paper released](https://shellprotocol.io/posts/the-ocean/). * Apr 1: [Government Toucans event](https://shellprotocol.io/posts/launching-our-government-toucan/), a 24-hour free NFT mint for the community. * Jun 3: [Testnet release on Arbitrum Rinkeby](https://shellprotocol.io/posts/shell-v2-testnet-release/). * Aug 16: [Shell Points announcement and testnet launch](https://shellprotocol.io/posts/introducing-shell-points/). * Aug 19: [Art of Shell auction begins](/user-guide/art-of-shell-nfts), marking the final updates to testnet deployment. * Sep 9: Date of the [Shell v1 snapshot](https://twitter.com/ShellProtocol/status/1589874535134023680). * Sep 12: [Guarded launch begins on Arbitrum One mainnet](https://shellprotocol.io/posts/launch/)! Ocean contracts are deployed. * Sep 27: [Trail of Bits Audit report finalized](/getting-started/security-and-bounties#audits). * Nov 3: [First Proteus AMM contract is deployed](https://shellprotocol.io/posts/shell-launches-proteus-amm-engine/). Maiden pool is DAI+USDC. * Nov 9: [Toucan vote determines that Shell Points will be considered for future SHELL airdrop](https://snapshot.org/#/shellprotocol.eth/proposal/0x4a8f0fa77abd1180353ff55fd36368b7c2f294105b7620491959d8dd80892485). * Nov 14: [Quota Expander Event begins, aka Bro Kwon’s Booty](https://shellprotocol.io/posts/the-tale-of-bro-kwon's-booty/). Also, the DAI+USDC pool [passes $1m TVL](https://twitter.com/ShellProtocol/status/1592333296171503616). * Nov 22: [USDT+USDC pool is deployed](https://twitter.com/ShellProtocol/status/1595146827631710209). * Dec 6: [Shellscan, the Shell-native block explorer, is released](https://shellprotocol.io/posts/introducing-shellscan/). * Dec 13: [USD Stablepool deployed](https://twitter.com/ShellProtocol/status/1602804640097050625), the first fractal pool. ### 2023 * Jan 11: [ETH+USD and wBTC+USD fractal pools are deployed](https://twitter.com/ShellProtocol/status/1613266925689397248). * Jan 23: [First Shell community challenge](https://shellprotocol.io/posts/lunar-new-year-crafting-challenge/), the Lunar New Year Crafting event. * Feb 10: [Mobile support for Shell app goes live](https://twitter.com/ShellProtocol/status/1624189022137647106). * Feb 24: [wstETH+ETH pool is deployed](https://twitter.com/ShellProtocol/status/1629212091256291328). * Mar 17: [Second Shell community challenge](https://twitter.com/ShellProtocol/status/1636803774462451713), the St. Patrick's Day Crafting event. * Mar 22: [ShellDrop DAO is launched](https://twitter.com/ShellProtocol/status/1638620397821370369). * Mar 27: [Toucan wraps go live](https://twitter.com/ShellProtocol/status/1640460791345446912). Discord role for Toucan holders is frozen, [as determined by Snapshot vote](https://snapshot.org/#/shellprotocol.eth/proposal/0x5703f4165baa8fedd3fbf17cd7145099b2cbb043e9b7c9fe2ca9b40801bad097). * Mar 31: [ARB+ETH pool is deployed](https://twitter.com/ShellProtocol/status/1641974360423428098). * Apr 1: [Part 1 of Shell Tokenomics is announced](https://shellprotocol.io/posts/shell-governance-and-tokenomics-part-1/). * Apr 7: The Mindmeld Live community call, formerly only on Discord audio, has its [first video episode](https://twitter.com/ShellProtocol/status/1644373761733570560). * Apr 15: [First NFT AMM is deployed](https://shellprotocol.io/posts/next-generation-nft-swaps-on-shell/), for Government Toucan NFTs. * May 5: [Part 2 of Shell Tokenomics is announced](https://shellprotocol.io/posts/shell-governance-and-tokenomics-part-2/). * May 16: [COLLAB airdrop claims go live](https://twitter.com/ShellProtocol/status/1658598184011304960) in the Shell app. * May 22: [Conclusion of guarded launch](https://twitter.com/ShellProtocol/status/1660749534094557185): CRAB claims go live and Season Two begins. * Sep 28: [Part 3 of Shell Tokenomics is announced](https://shellprotocol.io/posts/shell-governance-and-tokenomics-part-3/). * Oct 12: [The first Evolving Proteus pool goes live](https://twitter.com/ShellProtocol/status/1712598025405976956) with LBP (liquidity bootstrapping pool) for COLLAB. * Oct 19: [Season Three begins](https://twitter.com/ShellProtocol/status/1715117935935603009). * Nov 3: [CRAB vote decides on a 0% unlock](https://snapshot.org/#/shellprotocol.eth/proposal/0xf552a1adc91b29e2fb9831d81e9eb347bb820d2ffef4a9f952cb94deacd4421d) for the SHELL token launch. * Dec 11: First LBP for NFTs goes live for Countdown Crates, during [The Final Countdown event](https://shellprotocol.io/posts/the-final-countdown/). ### 2024 * Jan 22: [Launch of SHELL token and DAO](https://shellprotocol.io/posts/shell-token-launch-explained/), [launch of Shell v3](https://shellprotocol.io/posts/shell-v3-is-defi-unified/), SHELL+ETH pool goes live, Curve 2pool integration goes live. * Q1: Integrations with Curve, Balancer, Uniswap, and Aave. * May 2: [Cross chain DeFi zaps go live](https://shellprotocol.io/posts/shell-launches-cross-chain-defi-zaps/). Deposit directly into Arbitrum DeFi protocols from Ethereum mainnet, Base, or Optimism. * Q2: Integrations with Pendle, Beefy, and more. * Q2-3: Borrowing from Shell app. Full support for cross chain DeFi-to-DeFi transactions. * Q4: Intents system (MEV harnessing) # Community Discussion and governance in the Shell community ## Contents * [Web3 Governance](#web3-governance) * [Commonwealth](#commonwealth) * [Snapshot](#snapshot) * [Social Platforms](#social-platforms) * [Discord](#discord) * [Youtube](#youtube) * [Telegram](#telegram) * [Twitter](#twitter) ## Web3 Governance The Shell community uses Web3 platforms for [governance](/getting-started/governance). ### Commonwealth Commonwealth is a crypto-native discussion forum built on IPFS and Alchemy. It is the official forum for the [Shell DAO](/shell-dao/overview). **Forum:** [**https://commonwealth.im/shell-protocol/**](https://commonwealth.im/shell-protocol/) ### Snapshot Snapshot is an off-chain, gasless voting platform used by the [Shell DAO](/shell-dao/overview). It has also been used for [Toucan votes](/shell-dao/toucan-votes) and CRAB votes. Shell's Toucan community is one of the largest and most active Arbitrum communities on Snapshot. **Snapshot:** [**https://snapshot.org/#/shellprotocol.eth**](https://snapshot.org/#/shellprotocol.eth) ## Social Platforms The Shell community uses web2 social platforms for discussion. ### Discord {% hint style="info" %} Looking for alpha? [Join the Shell Protocol Discord!](https://discord.gg/shell-protocol) {% endhint %} Shell's Discord is the main hub for the community and the fastest way to reach the core team. It is a hotbed of lively discussions on everything from the protocol to toucan NFTs, as well as DeFi at large. For builders, it's a great place to let the community know what you're working on. **Discord:** [**https://discord.gg/shell-protocol**](https://discord.gg/shell-protocol) #### Roles Discord roles serve many functions. When you have a question, always check whether the person answering you has a trustworthy role. Different roles let you show off the flair you might have earned while in the Shell community, and some will even give you access to secret Discord channels. * Quartermasters (QMs): Shell's community moderators. They help safeguard the community against spam, scams, and negative conduct. QMs keep the whole server not only safe but kind and supportive, too. * Skindivers: Members of the development team working on Shell Protocol. * Primordials: Original LPs in [Shell v1](/how-shell-works/shell-v1-retired). (This role is now closed.) * Toucan \[Role]: Holders of the [Government Toucan NFT](/user-guide/all-about-toucans). Levels are as follows. (This role is now closed.) * Toucan Wrangler - Owns 1 Toucan * Toucan Hustler - Owns 3 Toucans * Toucan Magnate - Owns 10 Toucans * Toucan King - Owns 30 Toucans * Toucan God - Owns 100 Toucans * Collector: Holders of limited edition [Art of Shell NFTs](https://opensea.io/collection/art-of-shell-arbitrum). * Seekers: A mysterious role for seekers of [hidden fortune](/shell-lore/hidden-fortune). #### Events Sometimes the Cowri Labs team hosts special community events, such as a [Shell art competition](https://twitter.com/ShellProtocol/status/1578198455544971264), [DeFi trivia](https://shellprotocol.io/posts/play-trivia-games-and-win-toucans!/), or [in-person meetups](https://shellprotocol.io/posts/shell-social-at-ethdenver-2022/). Occasionally there are prizes or other fun incentives to participate. Events are open to everyone in the Discord. ### Youtube The Cowri Labs team hosts regular community calls on YouTube called the [Mindmeld Live](https://www.youtube.com/@shellprotocol). It's a chance for the team to share updates, anecdotes, and to answer questions from the community. Calls are usually every two weeks but the schedule varies, so make sure you're tuned into the [Discord](#discord) Announcements channel to get notified of the next one. **YouTube:** [**https://www.youtube.com/@shellprotocol**](https://www.youtube.com/@shellprotocol) ### **Telegram** Not a fan of Discord? There's also an official Shell Protocol telegram channel. Note that it is **100% community-run** without moderation from the Cowri Labs team. **Telegram:** [**https://t.me/shellprotocol**](https://t.me/shellprotocol) ### **Twitter** Follow the [Shell Protocol Twitter account](https://twitter.com/ShellProtocol) for announcements, Spaces, giveaways, witticisms, and the occasional back-and-forth with other DeFi protocols. In case of emergency, there is also a [backup Shell Protocol Twitter account](https://twitter.com/0xShellProtocol). Always cross-reference in case you suspect a security breach. **Twitter:** [**https://twitter.com/ShellProtocol**](https://twitter.com/ShellProtocol) # Ecosystem A list of major entities working on Shell Protocol ## Shell DAO The [Shell DAO](/shell-dao/overview) is the decentralized entity governing Shell Protocol. It is controlled by the community of [veSHELL](/shell-dao/veshell-staking) holders, who govern its on-chain activities through votes and the [DAO Multisig](/shell-dao/dao-multisig). For a deep dive, [continue here](/shell-dao/overview). ## Shell Foundation The Shell Foundation is a Cayman Islands entity whose objective is to promote the growth and adoption of Shell Protocol. Not only is Cayman a leading home for web3 foundations, it also echoes Shell’s island roots in Hawaii. Just as the Shell DAO represents the interests of Shell Protocol in the on-chain world, the Shell Foundation works to promote the protocol in the off-chain world. Among other things, the Foundation was tasked with handling the creation of the [SHELL token](/shell-dao/shell-token). ## Cowri Labs [Cowri Labs](https://cowri.io/) is the development team behind Shell Protocol. It is distinct and separate from the Shell DAO, the Foundation and the Protocol. Cowri Labs is a for-profit, US-based company that has raised capital from outside investors. Note that as an independent company, Cowri does not (nor could it) own or control Shell (a decentralized, non-custodial protocol). The Cowri team built Shell Protocol from the ground up, starting back in October 2020 with Shell v1. The company is based in Honolulu, the hometown of its founder. Although team members work remotely from different parts of the world, you can occasionally find them co-working by the beach at Shell [Hale](https://www.youtube.com/watch?v=WiOISo2cqmY) (pronounced HAH-leh), Cowri's solar-powered Hawaii hacker house. You can [follow the Cowri Labs Twitter here](https://twitter.com/CowriLabs). # Governance An overview of Shell Protocol governance ## **Forum Portal** {% embed url="" %} ## Shell Protocol DAO The Shell DAO is the entity governing Shell Protocol. The Shell DAO is controlled by SHELL token holders via veSHELL. [SHELL](/shell-dao/shell-token) is the protocol's governance token. In order to vote or delegate votes in the DAO, users must hold [veSHELL](/shell-dao/veshell-staking), which is vote-escrowed SHELL (aka staked SHELL). At this time, [all votes occur off-chain on Snapshot](https://snapshot.org/#/shellprotocol.eth). Successful votes that require on-chain actions are executed by the [DAO Multisig](/shell-dao/dao-multisig). For a deep dive, [continue here](/shell-dao/overview). ## Governance Minimization By design, the Shell DAO has limited control over the core protocol, namely the Ocean smart contract. Here are some things it cannot do: * It cannot manipulate or confiscate user assets (Shell is 100% non-custodial) * It cannot freeze the protocol (users can always withdraw their assets at any time) * It cannot block new primitives or adapters from connecting (anyone can build and deploy on Shell) ## Miscellaneous * [Toucan Votes](/shell-dao/toucan-votes): Community polls are conducted on Snapshot using the Government Toucan NFT, a "proto-governance" token. * [ShellDrop DAO (Retired)](/how-shell-works/shelldrop-dao-retired): The sole purpose of this DAO was to administer airdrops from other projects to the Shell community. # Integrations Integrate any DeFi project with Shell {% hint style="info" %} In the future, no one will build dapps. Instead, they'll just plug each protocol into platforms like Shell and instantly connect to users. {% endhint %} ## External vs Shell-native primitives There are two ways to integrate Shell Protocol. 1. For protocols that are **already deployed**, you can [deploy an adapter contract](/getting-started/integrations/protocol-adapters) to connect it with Shell. 2. If the smart contracts are still **in development**, you can [build natively on Shell Protocol](/getting-started/integrations/shell-native-primitives). This will reduce the complexity of your code and save gas when bundling transactions with other primitives on Shell. ## Why integrate? * With one integration, instantly connect your project to other major DeFi protocols — receive integrations with Curve, Balancer, Uniswap and many other projects out of the box. * Accelerate growth with built-in access to a suite of DeFi protocols and their communities. * Elevate your dapp into a DeFi lego for the Shell [developer community](/getting-started/developers) to plug-and-play. # Protocol Adapters An overview of Shell adapters for different DeFi protocols Deploying an adapter to Shell is permissionless. You'll only need to do it once, and from then on users and builders on Shell will be able to include your protocol in an atomic transaction. ## Adapters This section covers some of the first adapters connected to Shell. {% hint style="warning" %} This section is under construction. {% endhint %} # Shell-Native Primitives About building natively on Shell ## **Why build natively on Shell?** Shell Protocol simplifies and cuts down on the code you have to write, making it an excellent place to start new projects. In addition, its novel and [hyper-efficient architecture](/how-shell-works/architecture-overview) opens up several app possibilities that were previously very difficult or[ infeasible](/how-shell-works/intents-mev-harnessing-system). [Building on Shell](/getting-started/developers/what-to-build-on-shell) means you can compose complex atomic transactions or create precise AMMs without writing a single line of Solidity code. It means your financial primitives will require no accounting logic, making them simpler and easier to understand. It means your users will pay up to 4x less gas and gain access to more capital-efficient liquidity pools with fungible LP tokens. There is no downside to being an early Shell-native primitive. Even at its highest, gas costs for Shell primitives are no higher than those of existing DeFi protocols. But as the ecosystem grows, there will be more and more opportunities to compose primitives on the Ocean — enabling complex, low-gas transactions — and drawing in increasingly more users, builders, and assets. ## Primitives This section covers some of the first primitives to launch natively on Shell and ideas for new primitives. * [Stable Token AMMs](/getting-started/integrations/shell-native-primitives/stable-token-amms) * [Volatile Token AMMs](/getting-started/integrations/shell-native-primitives/volatile-token-amms) * [NFT Fractionalizer](/getting-started/integrations/shell-native-primitives/nft-fractionalizer) * [NFT AMMs](/getting-started/integrations/shell-native-primitives/nft-amms) * [LBPs (Liquidity Bootstrapping Pools)](/getting-started/integrations/shell-native-primitives/lbps-liquidity-bootstrapping-pools) * [Managed Pools](/getting-started/integrations/shell-native-primitives/managed-pools) * [Pools for Large Swaps](/getting-started/integrations/shell-native-primitives/pools-for-large-swaps) * Lending/Borrowing (coming soon) * IL-protected AMMs * Derivatives AMMs {% hint style="info" %} Due to Shell's unusual architecture, some information about Shell primitives such as TVL are difficult to interpret on Arbiscan ([the motivation for Shellscan](/user-guide/shellscan)). Instead, this information can be found directly on the [Shell App](https://app.shellprotocol.io/points). {% endhint %} ## # Stable Token AMMs List of stable token AMMs on Shell ## Overview One of the most important categories of AMMs are those designed for trading pairs with stable exchange rates ("stablecoins"), such as DAI, USDC, or USDT. Because the value of such a token is pegged to a stable unit like the US dollar, stablecoins are common tokens that many people trust for everyday transactions on blockchains. However, like any currency, stablecoins still fluctuate in value on a very small scale, usually on the order of hundredths of a basis point. Shell's initial stablecoin-to-stablecoin pools are designed with these fluctuations in mind. We concentrate the liquidity of the pool over the range of common price fluctuations. Many of the pools, like the DAI+USDC pool, were designed such that when the pool's liquidity is split 50-50 across both tokens, the swap rate is the median rate over the last year. Interested to read more about how these pools were designed? [Learn how to construct an AMM using Proteus.](https://docs.shellprotocol.io/tutorials/build-an-amm-with-proteus) ## Primitives ## `DAI+USDC` * `Pool Address:` [`0x537E2d22CC140C15Ec03e99BE399223750DE7737`](https://arbiscan.io/address/0x537e2d22cc140c15ec03e99be399223750de7737) * `LP Token ID: 0xbebb2eb60c5f0f6b2851070df30eb6b21f828c3b8242fd438caed9ca074a4436` * `Component assets: DAI+USDC` * `Fee: 0.025%` ## `USDT+USDC` * `Pool Address:` [`0xd5A7eDB913eae552e341b3bA0704CB2F6971BF7b`](https://arbiscan.io/address/0xd5A7eDB913eae552e341b3bA0704CB2F6971BF7b) * `LP Token ID: 0xaed7b01708bac910285a0331e9d703cc070c2c3ab641b4aec46feffa10f0d46b` * `Component assets: USDT+USDC` * `Fee: 0.025%` ## `Stablepool` * `Pool Address:` [`0x4f9d367636d5d2056f848803C11872Fdbc2afc47`](https://arbiscan.io/address/0x4f9d367636d5d2056f848803C11872Fdbc2afc47) * `LP Token ID: 0x6fa5e1f835f60b6883a60a12ec43e1534c10acef7b090b1b6a36b82876f54de9` * `Component assets: DAI+USDC+USDT` * `Fee: 0.025%` ## `wstETH+ETH` * `Pool Address:` [`0x2EaB95A938d1fAbb1b62132bDB0C5A2405a57887`](https://arbiscan.io/address/0x2EaB95A938d1fAbb1b62132bDB0C5A2405a57887) * `LP Token ID: 0x39d7132d7d4337aea5f75f468e05f6efd8182efd66eb6ddc49a8c900548411db` * `Component assets: wstETH+ETH` * `Fee: 0.025%` # Volatile Token AMMs List of general purpose AMMs for volatile tokens on Shell ## Overview Despite their popularity, many tokens like ETH and BTC can fluctuate wildly in value. Since they are so unpredictable, these 'volatile' tokens make it a bit trickier to design an AMM perfectly tuned to their ups and downs. Nevertheless, it is possible to create a better AMM than the simplistic constant product AMM by using historical price data and fitting that information to a curve with concentrated liquidity. Shell's initial volatile-to-stable pools are designed so that when the pool's liquidity is split 50-50 across both tokens, the swap rate uses the median dollar value of the volatile token over the last year. Interested to read more about how these pools were designed? [Learn how to construct an AMM using Proteus.](https://docs.shellprotocol.io/tutorials/build-an-amm-with-proteus) ## Primitives ## `ETH+USD` * `Pool Address:` [`0xa2dB39e781A5Eee0EAA625dace6F097c17dfF7Ea`](https://arbiscan.io/address/0xa2dB39e781A5Eee0EAA625dace6F097c17dfF7Ea) * `LP Token ID: 0x3d39f7c71b4be4b2b39924b0aefbe172194c1a8b11ff4e31a74896edead80b02` * `Component assets:` * `ETH` * `DAI` * `USDC` * `USDT` * `Fee: 0.25%` ## `WBTC+USD` * `Pool Address:` [`0x3402D87DF0817b2A96b210b8873d33dD979C8D19`](https://arbiscan.io/address/0x3402D87DF0817b2A96b210b8873d33dD979C8D19) * `LP Token ID: 0x0e53d22e36f0a0403bacf365d574a97253953118fb462cb766f6a1a34791d493` * `Component assets:` * `WBTC` * `DAI` * `USDC` * `USDT` * `Fee: 0.25%` ## `ARB+ETH` * `Pool Address:` [`0xA16F40437213020A167c230E4667ff8f13640f75`](https://arbiscan.io/address/0xA16F40437213020A167c230E4667ff8f13640f75) * `LP token ID: 0x977a1e4c16998d4b94d59494909c9503f5bc50642326bc8fa61f2e22761e7a3a` * `Component assets:` * `ARB` * `ETH` * `Fee: 0.25%` ## `MAGIC+ETH` * `Pool Address:`[`0x0699645f2fd448398272ae07f82eee8d0388de1c`](https://arbiscan.io/address/0x0699645f2fd448398272ae07f82eee8d0388de1c) * `LP token: 0xf00fbe5928cf77453911087439475eba4c4ddedd3f3664589eaa91c00e803377` * `Component assets:` * `MAGIC` * `ETH` * `Fee: 0.25%` ## `REUNI+ETH` * `Pool Address:`[`0x3917c74FDeC42071E29461c849bceB81cBC3059c`](https://arbiscan.io/address/0x3917c74FDeC42071E29461c849bceB81cBC3059c) * `LP token: 0x107a8aad95f88121f288baa229d82a6979de4158e6e0762a53e9ab24b4881c25` * `Component assets:` * `REUNI` * `ETH` * `Fee: 0.25%` ## `STG+ETH` * `Pool Address:`[`0xe043EB17Cc12C3fD4f5EaC765D0f1b965975F470`](https://arbiscan.io/address/0xe043EB17Cc12C3fD4f5EaC765D0f1b965975F470) * `LP token: 0x395b21a145e98bc33138d4bc87a25e7ca0839b05bd16c1ed06476c5ceb5c0bfe` * `Component assets:` * `STG` * `ETH` * `Fee: 0.25%` # NFT Fractionalizer About the NFT fractionalizer primitive ## Overview An NFT Fractionalizer allows users to transform a non-fungible token into fractional tokens. Fractionalizing has been used to allow fractional ownership of popular NFTs, among other things. On Shell, you can use an NFT Fractionalizer to simply swap one NFT for any other NFT in the pool. A Fractionalizer is also a necessary component of an NFT AMM. The [Proteus AMM Engine](/how-shell-works/proteus-amm-engine) only works with assets that are considered interchangeable, or fungible. In order to use Proteus, we need to temporarily “fungibilize” the NFTs. This is something you’d only do to an NFT if you consider its value equivalent to any other NFT in the set. In other words: **DO NOT put rare NFTs into a Fractionalizer**! It only makes sense to use common NFTs, aka “floor” NFTs, since these all have similar value. ## Fractionalizer Factory `Address:` [`0x4093ee6cc764e11ce95451f47ddee9d6cc89eed4`](https://arbiscan.io/address/0x4093ee6cc764e11ce95451f47ddee9d6cc89eed4) The **FractionalizerFactory** contract includes a mapping that associates each NFT collection with a fractionalizer contract address. This mapping is used to ensure that there are no duplicate deployments of Fractionalizers for the same NFT collection. Users can invoke the `deploy` function to deploy a new Fractionalizer by providing the address of the Ocean contract, the address of the NFT collection, the exchange rate (the number of fungible tokens exchanged for one NFT), and a boolean value indicating whether the NFT collection is an ERC-721 or ERC-1155 contract. The `getFractionalizer` function can be used to retrieve the address of the Fractionalizer contract associated with a specific NFT collection. ## Fractionalizers The **Fractionalizer** primitive is responsible for facilitating the exchange between NFTs and its fractional tokens. It can be queried for all the relevant information, including the NFT collection address, the exchange rate, the Ocean ID of the fungible token, and the supply of fungible tokens. For example, the Toucan Fractionalizer is a pool that holds shToucans. If you give it a shToucan, it will mint you 100 Toucoin. If you give it 100 Toucoin, you can withdraw any Toucan in the pool. The fractionalizer does not care which Toucan you give or take. Regardless of whether your Toucans are common or extremely rare, all Toucans are exchangeable for the same 100 Toucoin. # NFT AMMs List of AMMs designed for trading with fractionalized NFTs ## Overview Unlike traditional order book NFT markets like OpenSea in which users buy and sell individual NFTs from each other, an NFT AMM allows users to instantly buy or sell NFTs without a counterparty, with the trade price determined algorithmically. This drastically improves liquidity and price discovery in the NFT market, just as the first wave of AMMs did for ERC-20 tokens. This unlocks new possibilities for using NFTs as collateral, or in futures or options markets. The first few NFT AMM platforms like NFTX or Sudoswap were groundbreaking in their own right, but the AMMs they offer are functionally constrained, being subject to the same limitations as Uniswap AMMs or offering a small selection of bonding curves. Moreover, they suffer the same composability issues plaguing the DeFi space. For example, if an NFT is priced in DAI, users first have to convert their ETH before making a purchase. This requires an additional transaction, usually in another app. The [Government Toucan AMM](https://shellprotocol.io/posts/next-generation-nft-swaps-on-shell/), Shell’s first NFT AMM, is our first look at the future of NFT swaps. It’s exciting for a few reasons. First, it uses Proteus, the most flexible AMM engine on the market. Although the TOUCOIN+ETH pool implements a simple constant product curve with Proteus, future NFT pools could take advantage of more sophisticated Proteus bonding curves customized to any asset. Another big leap is its excellent UX, due to [Shell’s composability](https://shellprotocol.io/posts/the-ocean/): The NFT swaps work like any other token swap and can be batched with any other DeFi action. That means you can swap a Toucan for any token you’d like, or buy a Toucan with any token in your wallet. If you want to get really fancy, you can even use LP tokens to buy Toucans! Shell is the only DeFi protocol that can natively interface with both fungible and non-fungible tokens. This is a critical step in bringing DeFi and NFTs closer together, and building out robust financial tools for NFT creators, collectors, and traders. We can already see this happening with Proteus: Because fractionalized NFTs can harness Proteus, it’s now vastly simpler to build finely-tuned concentrated liquidity pools for NFTs. Most importantly, Shell’s NFT swaps showcase the power of composability. As we continue to innovate and add more functionality and new primitives to the core protocol, NFTs will be automatically included in the next wave of DeFi. ## Primitives ## `TOUCOIN+ETH` * `Pool Address:` [`0x81F6F6664E8Ece1E81bc9097084373c1dDDb8Daa`](https://arbiscan.io/address/0x81F6F6664E8Ece1E81bc9097084373c1dDDb8Daa) * `LP Token ID: 0x9b499052e6ba1808bdaf05e612d98955f2aeea34bffd35318ba56c92dd8ead74` * `Component assets:` * `TOUCOIN` * `ETH` * `Fee: 0.25%` ## `Smolpool` * `Pool Address:`[`0x6896177ee52659f22a87b180e8fcb2c850a7427e`](https://arbiscan.io/address/0x6896177ee52659f22a87b180e8fcb2c850a7427e) * `LP Token ID: 0x6aa326cb31e0abc00882250a8489836657da968ec4226710f9e146139eded137` * `Component assets:` * `SMOLCOIN` * `MAGIC` * `ETH` * `Fee: 0.25%` # LBPs (Liquidity Bootstrapping Pools) List of LBPs for tokens and NFTs ## Overview [Evolving Proteus](/how-shell-works/proteus-amm-engine#history-of-proteus) can be utilized to raise liquidity and distribute tokens or NFTs to a community. This is achieved through liquidity bootstrapping pools (LBPs). LBPs begin with a pool containing 100% of one token type and 0% of the other. Over time, the pool rebalances by altering the liquidity curve to gradually sell off the initial token in exchange for the second token. The price is determined by the market, based on the demand for the first token, at each stage of the rebalancing process. An LBP is a type of Dutch auction. However, whereas existing LBPs are limited to simple curve shapes like constant product, Evolving Proteus can be used to create evolving pools with highly customized concentrated liquidity. For instance, imagine creating a new fungible token named SURF. You could set up an Evolving Proteus pool filled with SURF token liquidity. If this pool pairs SURF with Ether, the price of SURF would decrease over time until the pool reaches a predetermined balance point, such as a 50-50 ratio or becoming 100% Ether. This model is also applicable to NFTs. By integrating Evolving Proteus with the Shell Fractionalizer, one can orchestrate the sale of new NFT collections. For example, if you have 10,000 Hermit Crab NFTs, you could fractionalize them into fungible tokens and set up an LBP for those tokens just like you would for the SURF token. This allows users to buy the fungible tokens, which they can then redeem for the NFT of their choice. Furthermore, you could streamline the user experience by creating a user interface that masks the underlying fungible tokens, allowing direct purchase of NFTs at dynamically changing prices as the LBP evolves. Our goal is to develop a browser-based interface for creating these types of pools, making it easier than ever to take advantage of these powerful features with little to no coding. ![](https://shellprotocol.io/static/img/price-analytics-ui.png) ## Primitives {% hint style="info" %} This section is under construction. {% endhint %} # Managed Pools How managed pools could be implemented on Shell {% hint style="info" %} There aren't any managed pools on Shell yet. Want to build one? Check out the [developers page](/getting-started/developers). {% endhint %} ## Market-Tracking Curves One use case for [Evolving Proteus](/how-shell-works/proteus-amm-engine#history-of-proteus) is the creation of market tracking pools. These pools are designed to be updated regularly to align with the trading range of the paired assets. One method for adjusting the curve is manual control by a delegate, similar to [Arrakis](https://www.arrakis.finance/). Take, for instance, if Ether's price increases by 50% in USDC terms. The delegate could then adjust the liquidity concentration to the new price point. With this, the curve only needs to be broad enough to encapsulate the majority of the trading range until the next adjustment, not months of price changes. This market-tracking can also be programmed to occur automatically, with or without a human in the loop. For example, the pool could be designed to follow the time-weighted average price of a token, similar to [Maverick](https://www.mav.xyz/), or draw from a source such as an oracle. # Pools for Large Swaps How pools for large swaps could be implemented on Shell {% hint style="info" %} There aren't any custom pools for large swaps on Shell yet. Want to build one? Check out the [developers page](/getting-started/developers). {% endhint %} ## Price Impact Minimization If you're a user looking to execute a large trade with a token pair that doesn't offer extensive liquidity, or perhaps you're a whale aiming to make a very, very large trade in a pool that has reasonable but not limitless liquidity, your trade will probably incur a high degree of price impact. This is because a single large transaction can severely unbalance the pool. Subsequently, arbitrage bots are quick to capitalize on such trades, effectively making a profit from your loss using the imbalance you create. [Evolving Proteus](/how-shell-works/proteus-amm-engine#history-of-proteus) offers a solution to this problem. It enables the creation of customized pools that gradually sell the tokens you wish to dispose of in exchange for those you want to acquire, spread over a period of time. For example, if you aim to sell 10 million USDC, Evolving Proteus could initiate a pool filled with your USDC, which would then slowly rebalance until it is entirely made up of the token you are looking to purchase. Once the rebalancing is complete, you can then exchange your liquidity provider (LP) tokens for the desired token. The entire process could be designed to be seamless for a front-end user, mimicking a standard swap operation in appearance. It's important to note that there would be gas fees involved in setting up the pool. Therefore, this strategy would be most beneficial for trades above a certain size. Luckily, Shell works to greatly reduce gas fees, making this a potentially practical solution for managing larger trades. # Developers Resources for developers ## Dev Docs Portal {% embed url="" %} ## Quick Links * [GitHub Repositories](/getting-started/overview/github-repositories) * [Contract Addresses](/getting-started/overview/contract-addresses) * [Security & Bounties](/getting-started/security-and-bounties) * [White Papers](/getting-started/overview/white-papers) ## Contents * [What to Build on Shell](/getting-started/developers/what-to-build-on-shell) * [Aggregating Pools](/getting-started/developers/aggregating-pools) # What to Build on Shell An exploration of what you can build on Shell ## Contents * [Build a DeFi Primitive](#build-a-defi-primitive-1) * [Connect External Protocols with Shell](#connect-external-protocols-with-shell) * [Design Next-Generation AMMs](#design-next-generation-amms) * [Innovate with Intents and Gasless Transactions](#innovate-with-good-mev-and-gasless-transactions) * [The UX Combinatrix](#the-ux-combinatrix) ## Build a DeFi Primitive Shell's [Ocean contract](/how-shell-works/the-ocean-accounting-hub) acts as a DeFi accounting hub on the EVM, making it simple and more gas-efficient to handle several tokens or interact with many protocols within a single transaction. If you’re familiar with DeFi, you have probably heard the term “money legos” or “financial primitives” used to describe the various independent DeFi products and protocols. Like lego bricks, the dream is to be able to combine different DeFi protocols together, in order to build more sophisticated financial tools. However, this isn’t as easy as it sounds because it requires the universe of EVM smart contracts to be interoperable. This is the vision of Shell: to make EVM smart contracts more modular and easier to assemble — and in the process, pare down the amount of code overall, reducing the attack surface for the ecosystem. Specifically, under the Shell architecture builders can extract the “accounting logic” from the “business logic” of any DeFi protocol. Accounting logic is the code that transfers tokens between wallets. Business logic is the code that computes how many tokens to move. In the case of an AMM, the business logic computes the exchange rate. For a lending pool, the business logic computes the interest rate. ![](https://cdn-images-1.medium.com/max/1600/0*auNjiIsfIBLOc2Ox) ![](https://cdn-images-1.medium.com/max/1600/0*sL4GuSJHwoESsz3R) **Fig 1: Disentangling business logic from accounting logic to make DeFi protocols more modular.** Once we disentangle the accounting logic, it becomes possible to standardize it and outsource it to the Ocean contract, where the same code can be shared by all primitives. It turns out that there is a universal pattern shared by all DeFi protocols: the accounting logic takes a token as input, and then returns another token as output. As our research shows, the typical DeFi protocol can decompose their business logic from a monolithic mass into smaller, discrete logical components. At Shell, we realized the smallest logical unit of “business logic” in any DeFi protocol could be standardized according to the input and output tokens it sends to an accounting system (before and after it performs its computations). Specifically, a modular financial primitive could look like this: ![](https://cdn-images-1.medium.com/max/1600/0*XgTFbkzR5hzq2uyO) In this example, the user specifies the input token, the output token and the amount given to the primitive. All the primitive needs to figure out is how much of the output token to give to the user. We can use this interface to standardize an accounting system across all DeFi protocols, without any effect on the infinite possibilities of each one’s internal business logic. We call these standardized smart contracts “[DeFi primitives](/getting-started/integrations/shell-native-primitives).” The real magic of standardized accounting is not just that there’s less code to write. It also means that every single DeFi primitive is natively composable with every other DeFi primitive that shares the same accounting hub. That means any protocol on the Ocean may be combined in a permissionless way with many other protocols — all in a single, atomic transaction. Unsurprisingly, Shell’s network effects will be most useful when it has a large network of DeFi primitives. You can be one of the first to build a primitive on Shell. As an early [Shell primitive](/getting-started/integrations/shell-native-primitives), not only would you get early access to Shell’s liquidity and devoted community, your primitive (perhaps an AMM, a lending protocol, an NFT market, etc.) could be one of the foundational building blocks incorporated into other protocols in the future. ## Connect External Protocols with Shell Write an [adapter contract](/getting-started/integrations/protocol-adapters) to integrate your favorite project with Shell. As a completely open and permissionless platform, anyone can write an integration for the project of their liking to connect with other protocols through Shell.\ \ With each integration, Shell and all its integrated protocols become exponentially more powerful. Users can atomically combine interactions with each new protocol in any set of transactions. With major integrations like Curve, Balancer, Uniswap, and Aave, Shell Protocol makes extremely powerful infrastructure for building new composable projects and omni dapps. ## Design Next-Generation AMMs Speaking of AMMs, you may have heard that the [Proteus AMM Engine](/how-shell-works/proteus-amm-engine) allows concentrated liquidity and a time-evolving bonding curve, as well as fungible LP tokens. But the real beauty of Proteus is how it can be used within a fractal network of liquidity pools, made possible by [the Ocean](/how-shell-works/the-ocean-accounting-hub). (The next article details the process of [constructing an AMM using Proteus](broken://pages/FMHlkSHtKB9WjXrrZ1vT).) ![](https://cdn-images-1.medium.com/max/1600/0*DBYIcGfsfQmbNtNY) In other words, it’s a technical stepping stone to the next generation of AMMs: modular and hyper-composable. For example, imagine you hold LP tokens from a DAI+USDC AMM. You could put these LP tokens on one side of an ETH+(DAI+USDC) AMM, and end up holding LP tokens that represent ETH+(DAI+USDC). Using the same principle, you could build any type of multi-asset AMM. Another possibility with Shell is the creation of NFT AMMs. Here’s how it could work: ![](https://cdn-images-1.medium.com/max/1600/0*dTuSCjA1lTC57JMR) The Toucoin AMM will be Shell Protocol’s first [NFT AMM](/getting-started/integrations/shell-native-primitives/nft-amms). It is an AMM composed of two tokens: one a simple USD stablecoin, and the other one is Toucoins. Toucoins are in fact tokens that have been created from another primitive, the Government Toucan NFT “Fungibilizer” — whose purpose, as you may have guessed, is to convert any Toucan NFT into fungible tokens. Users will be able to provide liquidity to the Toucoin AMM by first “fungibilizing” their Toucan NFTs. And guess what? This action can be batched together with any other token swap or liquidity action that users want to make in Shell. Perhaps you have your own idea for implementing an NFT AMM. Or perhaps you’re interested in building an [AMM for options, perpetuals, interest rate swaps](/getting-started/integrations/shell-native-primitives), or something else entirely. Maybe you’d simply like to contribute to the research efforts in this field. Maybe you’d like to investigate which financial or mathematical models we should be implementing in smart contracts in the first place — and perhaps even dream up the next version of Proteus. ## Innovate with Intents and Gasless Transactions If you read about [the Intents (aka MEV Harnessing) System](/how-shell-works/intents-mev-harnessing-system), you’ll know that the design of Shell makes it possible to build a totally new type of MEV system. Similar to the way limit orders work, the [Ocean contract](/how-shell-works/the-ocean-accounting-hub) allows users simply to specify the minimum amount of tokens they would accept at the end of a trade, and then lets anyone (i.e., a “good” MEV bot) execute that trade on the user’s behalf. The more efficient the transaction path, the greater the profit for the MEV bot. In this way, not only does Shell reverse the incentives so that MEV bots must now compete for the user’s benefit — it also means that end users no longer have to hold ETH to pay the gas for their transactions. Instead, the gas cost can be priced into any trade (deducted from whatever tokens the user sent). Only the MEV bot pays the gas, meaning it is the only party that ever needs to hold ETH. The MEV harnessing system is a brand new concept, so there are still many open challenges in building it out. If you’re already brainstorming a plan for organizing the MEV bots, or you’re inspired by the possibilities of gasless transactions, this could be a greenfield project for you. ## The UX Combinatrix The variety of new possibilities offered by Shell requires a dynamic, composable, and intuitive user experience. Not only will we need to develop tools for financial engineers to interact with and compose together DeFi primitives, but we will need a sophisticated graphical user interface for the average user as well, one that incorporates the many possibilities of different types of tokens — LP tokens, NFTs, and other financial products alike. Not only this, but imagine seamlessly integrating MEV protection into that user experience as well. You could call it… the UX combinatrix! These are just a few ideas and possibilities. Are you inspired by Shell? Do you have another idea about what to build? [Hop in the Discord and share!](/getting-started/overview/community#discord) # Aggregating Pools Tips on integrating Shell-native liquidity pools ## Quick Links * [Contract Addresses](/getting-started/overview/contract-addresses) * [Native Primitives](/getting-started/integrations/shell-native-primitives) * [Example of sending a swap through the Ocean](https://github.com/Shell-Protocol/Shell-Protocol/blob/bfbba01472200a4a34ace4cb131f775018cf47c2/test/Interaction.js#L346) * [Shell Protocol GitHub](https://github.com/Shell-Protocol/Shell-Protocol/) ## Swap through Shell-native fractal pools

You can swap any ERC-20s by creating a path through this graph.

You can use Shell pools to swap any ERC-20 (or ERC-721 or ERC-1155) tokens, as long as there exists a viable path of AMMs. Fractal pools can serve as a stepping stone in swapping between ERC-20 tokens. A fractal pool uses LP tokens as one or both of its reserve assets. For example: * The two reserve assets of **`Stablepool`** are **`DAI+USDC`** LP token and `USDT+USDC` LP token. * The two reserve assets for **`ETH+USD`** pool are **`shETH`** and **`Stablepool`** LP token. Let's swap **`shDAI`** to **`shETH`**. You must deposit **`shDAI`** into the **`DAI+USDC`** pool to get the **`DAI+USDC`** LP token, then take that LP token and deposit it into **`Stablepool`** to get the **`Stablepool`** LP token, then swap that LP token to **`shETH`** using the fractal pool (**`ETH+USD`**). {% hint style="info" %} **Tip:** Depositing or withdrawing from a pool is functionally the same as swapping. You call `computeOutputAmount` but with the LP token ID as the output token instead of a wrapped token. {% endhint %} Remember in Shell Protocol, ERC-20 (or 721 or 1155) tokens are wrapped onto a shared ERC-1155 ledger ([the Ocean](/how-shell-works/the-ocean-accounting-hub)). Shell pools always use the Shell-wrapped ERC-1155 version of these tokens. Shell LP tokens are also ERC-1155. They each have their own Ocean IDs, just as the Shell-wrapped ERC-20s do. {% hint style="info" %} **Tip:** You can get the LP token ID from the LP pool contract. There is a read function called `lpTokenId`. {% endhint %} Whenever you swap from one ERC-20 token to another through Shell pools, there will be a wrap and unwrap in that transaction. For example, trading **`DAI`** for **`ETH`** would look like this: 1. wrap **`DAI`** -> **`shDAI`** 2. deposit **`shDAI`** -> **`DAI+USDC`** LP 3. deposit **`DAI+USDC`** LP -> **`Stablepool`** LP 4. swap **`Stablepool`** LP -> **`shETH`** (through **`ETH+USD`** pool) 5. unwrap **`shETH`** -> **`ETH`** {% hint style="info" %} **Tip:** All of this can be done in one function call with `doMultipleInteractions`. {% endhint %} The fractal design makes querying the prices of token pairs somewhat complicated. {% hint style="info" %} **Coming soon:** Sample code for finding the price between two tokens. {% endhint %} # Security & Bounties An overview of Shell's security ## Contents * [Security Statement](#security-statement) * [Ocean Safeguards](#ocean-safeguards) * [Proteus Pool Safeguards](#proteus-pool-safeguards) * [Bounties](#bounties) * [On-Chain Monitoring](#monitoring) * [Audits](#audits) * [Legacy Audits (Shell v1)](#legacy-audits-shell-v1) ## Security Statement The Shell Protocol team holds security as a top priority. Shell contracts are non-custodial, meaning NOBODY (not even the Shell DAO) is able to access the funds held in any of the core contracts. DeFi can be inherently risky and time is the ultimate test, so all new features are released with utmost care, communication, and appropriate incentives for users. There are some safeguards in place to actively monitor security threats and to address unforeseen situations. ## Ocean Safeguards The [Shell DAO](/shell-dao/overview) is able to transfer protocol revenue between wallets or change the protocol beneficiary wallet, as well as adjust Ocean unwrap fees. However, NOBODY can manipulate or confiscate user assets (Shell is 100% non-custodial), freeze the protocol (users can always withdraw their assets at any time), or block new primitives or adapters from joining (anyone can build and deploy on Shell). ## Proteus Pool Safeguards {% hint style="info" %} The ShellMultiSig is a legacy wallet that was used for Shell v2 Proteus pools. {% endhint %} A pool's deployer can assign a wallet the ability to freeze the pool in case of an emergency. LPs may still withdraw their tokens, but swaps and deposits are disabled. The Cowri Labs team controls a 2/3 multi-signature wallet, the ShellMultiSig, that can freeze trading on Proteus pools assigned to it. `ShellMultiSig:` [`0x07F076e66782918c0110e34Ee7610B0d4eE02794`](https://arbiscan.io/address/0x07f076e66782918c0110e34ee7610b0d4ee02794#code) A transaction submitted through the multisig can be in one of the following states: `Uninitialized`, `Pending`, `Queued`, `Executed`, or `Expired`. 
 For normal transactions, any owner on the multisig can submit a transaction by calling `submitTransaction`. This puts the transaction into the `Pending` state, at which point it must be confirmed by two of three of the multisig owners. Owners can also revoke their confirmation by calling `revokeConfirmation`, but only while the transaction is in the `Pending` state. Once the required number of confirmations is reached, any owner can move the transaction into the `Queued` state by calling `queueTransaction`. At this point, the time lock countdown of two days begins. Once the time lock period has passed, any owner can execute the transaction by calling `executeTransaction`, moving it into the `Executed` state. Note that the transaction must be executed within a given grace period of three hours from when the time lock expires. If the transaction has not been executed by the end of this grace period, it will enter the `Expired` state and the entire process must be repeated by submitting a new transaction. There are two special cases of transactions, **freezing** and **unfreezing** a pool. 

 To freeze a pool, any owner on the multisig can call the `freezePool` function and pass in the pool address. The pool will be frozen **immediately** following this transaction, no confirmations or transactions from other owners are required.

 To unfreeze a pool, any owner on the multisig can call the `submitUnfreezePool` function and pass in the pool address. At this point, the unfreeze transaction is in the `Pending` state and requires two of three confirmations from multisig owners. Once the required number of confirmations is reached, the unfreeze transaction can be immediately executed by any owner by calling `executeTransaction` since there is no time lock delay for unfreezing a pool. Note that the one contingency in this case is that the grace period begins as soon as the transaction is initially submitted, meaning the unfreeze transaction must be confirmed and executed within three hours of being initially submitted. ## Bounties Shell has a [bug bounty program](https://immunefi.com/bounty/shellprotocol/) on Immunefi. Please submit bugs there. {% embed url="" %} ## On-Chain Monitoring Shell conducts on-chain security monitoring with Forta. Anyone can [subscribe to updates from the Shell Forta bot](https://explorer.forta.network/bot/0x7f9afc392329ed5a473bcf304565adf9c2588ba4bc060f7d215519005b8303e3). This bot tracks Shell transactions in which wrapping, unwrapping, swapping, depositing, or withdrawals occur over a threshold amount. If transactions occur with unusually high token amounts, the bot sends out an alert. `Shell Forta bot:` [`0x7f9afc392329ed5a473bcf304565adf9c2588ba4bc060f7d215519005b8303e3`](https://explorer.forta.network/bot/0x7f9afc392329ed5a473bcf304565adf9c2588ba4bc060f7d215519005b8303e3) ## Audits [January 5, 2024 by code4rena](https://code4rena.com/reports/2023-11-shellprotocol) [October 4, 2023 by code4rena](https://code4rena.com/reports/2023-08-shell) [September 27, 2022 by Trail of Bits](https://github.com/trailofbits/publications/blob/master/reviews/ShellProtocolv2.pdf) ## Legacy Audits (Shell v1) [June 2020 by Consensys Diligence](https://consensys.net/diligence/audits/2020/06/shell-protocol/) # FAQ Frequently asked questions
Is Shell Protocol a DEX (decentralized exchange)? Shell is much more than a DEX. In addition to swaps, it allows users to make various other types of transactions like LPing, lending, or buying NFTs, that can all be batched in an atomic transaction. This lets users bundle many transactions into one, and it lets [developers](/getting-started/developers) build [complex financial apps, new financial primitives, and more efficient DEXs](/getting-started/integrations/shell-native-primitives).
How can I see Shell stats like TVL or trade volume? A good place to visualize this is [Shell's DeFi Llama page](https://defillama.com/protocol/shell-protocol) or [community-created Dune dashboards](https://dune.com/mrcryptoholic/shell-protocol-stats-arbitrum).
What blockchain is Shell on? Shell is on Ethereum mainnet, Optimism, Base, and Arbitrum. It is EVM-compatible and will be deployed on other chains or L2s in the future. Shell v3 [initially launched on Arbitrum](/how-shell-works/why-arbitrum), an Ethereum rollup.
How does Shell approach security? Shell is [100% non-custodial](/getting-started/security-and-bounties#security-statement) with necessary safeguards, and has been [audited](/getting-started/security-and-bounties#audits) by the best of the best and maintains open [bounties](/getting-started/security-and-bounties#bounties). DeFi can be inherently risky and time is the ultimate test, so all new features are released with utmost care, communication, and appropriate incentives for users.
What is a "sh-" token? The “sh” prefix on a token indicates that it is Shell-wrapped to interact with Shell primitives. Shell-wrapped tokens simply record a token's ownership on [Shell's internal token ledger, the Ocean](/how-shell-works/the-ocean-accounting-hub), instead of the token's native ledger. These tokens are held by the Ocean on an external ledger (ERC-20, ERC-721, or ERC-1155), with a proportional quantity represented on the Ocean ledger and held by the user. For example, shUSDC is USDC wrapped into the Ocean. [Wrapping tokens in Shell Protocol](/user-guide/wrap-tokens) does not affect their value (1 USDC = 1 shUSDC) and they may be unwrapped by the user at any time.
What is a Government Toucan? [Government Toucans](/user-guide/all-about-toucans) are an NFT collection that were mintable for free by the Shell community on April 1, 2022 and have been used for [community votes](/shell-dao/toucan-votes).
What is $SHELL? $SHELL is the ticker for the Shell DAO's [governance token](/shell-dao/shell-token).
Who developed Shell Protocol? [Cowri Labs](/getting-started/overview/ecosystem#cowri-labs) is the team that created and maintains Shell Protocol.
What is Shell v1? [Shell v1](/how-shell-works/shell-v1-retired) (launched October 2020, retired September 2022) was an AMM tailored for trading stablecoins and holding fungible composite assets. From its launch through its retirement, and without any incentives or advertisements, Shell v1 had remained in the top 25 DEXs on Ethereum by TVL, without a security breach. Building Shell v1 taught us that the next evolution of AMMs requires DeFi architecture to be more modular and flexible. It inspired us to modularize DeFi architecture into two components, accounting logic and business logic. The current Shell Protocol introduces this [new system architecture](/how-shell-works/the-ocean-accounting-hub). Not only can we use it to recreate what was possible with Shell v1, but we can also build many [innovative new apps](/getting-started/integrations/shell-native-primitives) with it.
# Overview Shell Protocol governance and tokenomics ## **Forum Portal** {% embed url="" %} ## Contents * [Shell DAO Permissions](/shell-dao/shell-dao-permissions): The Shell DAO has limited capabilities. * [SHELL Token](/shell-dao/shell-token): Learn about mechanics and distribution of the SHELL token. * [veSHELL Staking](/shell-dao/veshell-staking): The SHELL token can be staked as veSHELL for voting power. * [Governance Process](/shell-dao/governance-process): A detailed explainer for governance of the Shell DAO. * [Mutable Protocol Fees](/shell-dao/mutable-protocol-fees): Shell Protocol has one fee that accrues to the Shell DAO. * [DAO Multisig](/shell-dao/dao-multisig): The Shell DAO Multisig is responsible for executing transactions as instructed by veSHELL voters. # Shell DAO Permissions The Shell DAO has limited control over the protocol The Shell DAO (and by extension the [Shell DAO Multisig](/shell-dao/dao-multisig)) has limited control over the protocol. It cannot manipulate or confiscate user assets (Shell is 100% non-custodial), freeze the protocol (users can always withdraw their assets at any time), or block new primitives or adapters from connecting (anyone can build and deploy on Shell). ## Things the Shell DAO can do Officially, there are only seven things the Shell DAO can do. 1. Raise or reduce the [protocol fee](/shell-dao/mutable-protocol-fees) (i.e. the unwrap fee on the Ocean) (maximum fee is 0.05%) 2. Change the protocol "owner" aka beneficiary to another wallet 3. Transfer tokens held in the DAO Treasury 4. Mint new SHELL tokens 5. Add/remove signers on the [Shell DAO Multisig](/shell-dao/dao-multisig) 6. Modify DAO voting procedures 7. Change the sole user followed by the Shell Protocol Twitter account # SHELL Token Shell token distribution and airdrop {% hint style="danger" %} As always, beware of scams. Bookmark the [official app](https://app.shellprotocol.io/) and use the app, [the Discord announcements channel](https://discord.gg/shell-protocol), and the [Shell Protocol Twitter](https://twitter.com/ShellProtocol) as your cross-referenced sources of truth. Of those three, always confirm across at least two that something is real. Pause and tag a [skindiver](/getting-started/overview/community#roles) on Discord when in doubt. {% endhint %} ## Overview SHELL is the token governing Shell Protocol. SHELL token holders collectively control the Shell DAO via voting. The token name and ticker $SHELL was [decided by a community vote](https://shellprotocol.io/posts/sea-vs.-shell-competition/). Why does Shell even need a token? The token is necessary for the long-term sustainable development of the protocol. Building Shell Protocol and upgrading it in the future costs money—people don’t work for free, after all. Unless there is some way to generate value, the protocol won’t be maintained. Many public resources have fallen into this trap, especially in open-source technology. Because SHELL token holders are simultaneously the beneficiaries of Shell Protocol’s revenue, they are incentivized to reinvest in the protocol. With sustainable development of the product and ecosystem, token holders can grow those revenues in the future. Without *you,* the future SHELL token holders overseeing its development, Shell Protocol won’t be sustainable in the long run. ## SHELL Distribution At the time of the token generation event (TGE), 200 million Shell tokens were created. These were apportioned as follows: * 80M - DAO Treasury * 70M - Cowri Labs * 40M - Early Community * 10M - Shell Foundation The Shell DAO has the power to mint more tokens beyond the 200 million supply apportioned above, but that would require a governance vote. ## Airdrop Providing liquidity to Shell v1 (Season 0) or earning [Shell Points](/user-guide/earn-rewards/shell-points-concluded) during Seasons 1-3 made users eligible for participating in the [SHELL airdrop](/shell-dao/shell-token/airdrop-eligibility-and-crab). This was decided by a [Toucan vote](https://snapshot.org/#/shellprotocol.eth/proposal/0x4a8f0fa77abd1180353ff55fd36368b7c2f294105b7620491959d8dd80892485). # Airdrop Eligibility & CRAB Shell Points > CRAB > SHELL {% hint style="danger" %} As always, beware of scams. Bookmark the [official app](https://app.shellprotocol.io/) and use the app, [the Discord announcements channel](https://discord.gg/shell-protocol), and the [Shell Protocol Twitter](https://twitter.com/ShellProtocol) as your cross-referenced sources of truth. Of those three, always confirm across at least two that something is real. Pause and tag a [skindiver](/getting-started/overview/community#roles) on Discord when in doubt. {% endhint %} ## Overview Users that provided liquidity in the early days of Shell v1, as well as users that earned [Shell Points](/user-guide/earn-rewards/shell-points-concluded) during Shell v2, are eligible to claim the intermediate placeholder token CRAB. Upon the launch of the SHELL token, all CRAB became [convertible to SHELL](/shell-dao/shell-token/sablier-vesting-stream-shell). ## CRAB, the Placeholder Token Crabs were an intermediate step in the transition from [Shell Points](/user-guide/earn-rewards/shell-points-concluded) to SHELL. In essence, CRAB is a fungible, on-chain, non-transferable placeholder for future SHELL allocation. At the end of each season, users were able to claim CRAB based on the number of Shell Points earned that season. These Crab tokens are not buyable, sellable, or tradable. Upon release of the Shell governance token (SHELL), CRAB became 1:1 redeemable for SHELL tokens. Every crab needs a shell! Why Crabs? In short, Shell Points were computed off-chain based on users’ on-chain activity on the protocol. This made them easier to calculate but also less "real" from a web3 perspective. With on-chain CRAB allocation, your Crabs are yours. No one can take them away from you. In addition, having CRAB on-chain allowed us to practice more decentralized governance prior to the SHELL token generation event. Unlike Shell Points, we were able to use CRAB with web3 governance platforms like Snapshot. These votes helped determine aspects of the future Shell DAO. More broadly, the release and allocation of CRAB served as a good intermediate step before the full launch of SHELL. Like going to college before entering the real world, giving everyone Crabs got us ready for the real deal. ## Seasons and CRAB Distribution As explained above, CRAB is redeemable for SHELL. It was only necessary pre-token launch. Therefore, a total of 40 million Crabs were created, split across seasons as follows: * Season Zero (Shell v1): 13M CRAB * Season One (Shell v2 Guarded Launch): 11M CRAB * Season Two (May 22, 2023-October 19, 2023): 9M CRAB * Season Three (October 19, 2023-January 15, 2024): 7M CRAB ## How to Earn CRAB (Concluded) For Seasons 1–3, CRAB was distributed proportionally based on [Shell Points](/user-guide/earn-rewards/shell-points-concluded). At the close of each season, we tallied the total points accumulated by all users. Then, CRAB was evenly distributed based on the percentage of total points earned by each user. Note that it’s not a 1:1 conversion. For example, say 1 billion Points were earned across all users in a season. If Alice earned 10 million Points, she holds one percent of that season's total Points, which means she will get one percent of that season's CRAB allocation. If the total CRAB allocation for the season is 10 million, Alice will thus earn 100,000 CRAB, which become 100,000 SHELL after the token launch. As stated earlier, all Shell Points are reset at the end of each season. The compounding points feature was discontinued at the end of Season One. CRAB is claimable through the [Shell app](https://app.shellprotocol.io/). The CRAB distribution for Season Zero was calculated based on a formula tracking liquidity provision over time in Shell v1, from its launch up until September 1, 2022. This allocation has already been finalized. If you were an LP in Shell v1, congratulations and please don’t forget to [migrate your tokens (Shell v1 is now retired)](/user-guide/migrate-from-shell-v1-retired)! # Sablier Vesting Stream SHELL Understanding vesting SHELL tokens ## Overview [CRAB](/shell-dao/shell-token/airdrop-eligibility-and-crab) is convertible into SHELL vesting stream NFTs. For more information about vesting streams, refer to the [Sablier docs](https://docs.sablier.com/concepts/protocol/stream-types). SHELL is subject to a [linear lockup](https://docs.sablier.com/concepts/protocol/stream-types#lockup-linear). You can convert any amount of your CRAB into a vesting NFT worth the equivalent amount of SHELL. The NFT will then disperse SHELL evenly per block from January 22nd, 2024 to January 22, 2026. You can view SHELL stream NFTs on OpenSea by [filtering for the SHELL trait on the Sablier V2 Lockup Linear NFT page](https://opensea.io/collection/sablier-lockup-linear-a4bf69c-on-chain-42161?search\[stringTraits]\[0]\[name]=Asset\&search\[stringTraits]\[0]\[values]\[0]=SHELL\&search\[sortAscending]=true\&search\[sortBy]=UNIT_PRICE). {% hint style="warning" %} Transferring the NFT makes the new owner the recipient of the stream. The funds are not automatically withdrawn for the previous recipient. {% endhint %} ## Vesting The purpose of the vesting schedule is to gradually increase the circulating token supply. Sudden increases to the token supply could have an adverse effect on the nascent Shell ecosystem. The important thing to emphasize is that everyone is on the same vesting schedule; investors, core team and community are treated equally. The following stakeholders are subject to a two-year, linear vesting schedule: * [Cowri Labs Team](/getting-started/overview/ecosystem#cowri-labs) * Cowri Labs Investors * CRAB holders Vesting for CRAB holders is autonomous and once initiated, cannot be reversed by anyone. The following stakeholders are exempt from vesting: * [The Shell DAO](/shell-dao/overview) * [The Shell Foundation](/getting-started/overview/ecosystem#shell-foundation) The Shell DAO's treasury reserve of SHELL will not be subject to vesting, but will be deployed at the DAO’s discretion. Additionally, the Shell Foundation will retain a reserve of SHELL tokens, which will also not be subject to vesting. # veSHELL Staking Vote-Escrowed SHELL {% hint style="warning" %} This page is currently under construction. {% endhint %} ## Overview veSHELL (vote-escrowed SHELL) is a token staking and yield system modeled after [Curve's veToken mechanism](https://curve.readthedocs.io/dao-vecrv.html). DAO members gain votes by staking their SHELL tokens to the DAO. The longer these tokens are staked, the higher the voting power. One veSHELL token = one vote. Users may earn rewards (yield) for staking. A portion of the DAO Treasury is allocated to incentivize users to stake the DAO. For the duration that SHELL tokens are staked, they are locked and non-transferable. However, users may delegate their veSHELL voting power to other users, via the delegation system. ## veShell Mechanics {% hint style="info" %} More info coming soon. {% endhint %} # Governance Process Step by step guide to participating in Shell DAO governance ## Overview There are four stages in the Shell governance process. 1. User posts an RFC (Request for Comment) to the Shell governance forum. 2. Open discussion so the community can provide feedback and revise the RFC. (Suggested 1 week minimum) 3. Anyone with at least 2000 veSHELL in delegation can put the Proposal on Snapshot for a community vote. 4. If the vote is successful and on-chain actions are required, the Shell DAO Multisig will execute it as specified in the Proposal. **Forum:** [**https://commonwealth.im/shell-protocol/**](https://commonwealth.im/shell-protocol/) **Snapshot:** [**https://snapshot.org/#/shellprotocol.eth**](https://snapshot.org/#/shellprotocol.eth) ## Proposal Template All proposals must follow a standard format to be considered valid. At this time, only English-language proposals are accepted. If a field is not relevant for a proposal, write in N/A. Additional fields may be added to the template if necessary, according to the author's discretion. **TITLE** Thread title should adhere to the format:\ **RFC: \[Your Proposal Title] (Category)** **OVERVIEW** * **Title:** \[Your Proposal Title] * **Author(s):** Enter name(s) of authors. * **Category:** \[Constitutional/Protocol Fee/ShUIP/Builder Program/Miscellaneous] * **Related Discussions:** Paste links here, if applicable. **DETAILS** * **Summary:** Provide a brief, simple summary of your proposal in 2-3 sentences (aka the TLDR). * **Link to Transaction Payload PR:** If the proposal requires on-chain actions, include a link to the transaction payload PR on GitHub. * **Motivation:** Explain the key problems this proposal will solve. * **Vision:** Discuss your goals and examine ways this proposal might impact the ecosystem on a technical, financial, or governance level (or all of the above). How would it affect the Shell DAO, the protocol, or the veSHELL ecosystem? Include links for background reading, if applicable. * **Specification:** Follow guidelines in the [Proposal Categories](#proposal-categories). Share a breakdown of implementation details, including any technology or platforms to be used. Describe each step with associated costs or development resources, etc. * **Benefits (Pros):** Summarize key benefits. * **Downside (Cons):** Disclose any potential risks or downsides. * **Overall Cost:** The total cost to implement this proposal. * **Timeline:** Specify important dates or deadlines (e.g., start/end dates, milestones). **VOTING OPTIONS** * **Abstain:** Clearly define the terms/results of an "abstain" vote. * **No:** Clearly define the terms/results of a "no" vote. * **Yes:** Clearly define the terms/results of a "yes" vote. ## Proposal Categories Proposals may be of five categories: Constitutional, Protocol Fee, User Incentives (ShUIP), Builder Program, and Miscellaneous. ### 1. Constitutional Constitutional proposals are meta-governance proposals designed to modify the Governance Process. ### 2. Protocol Fee Shell Protocol has a [singular protocol fee](/shell-dao/mutable-protocol-fees) applied only to "unwraps" (liquidity that leaves the ecosystem). The fee has a hard-coded cap of 0.05% and is initially set to zero. Revenue from the protocol fee accrues to the Shell DAO. Protocol fee proposals are solely about raising or lowering the percent fee. ### 3. User Incentives (ShUIP) The DAO has the ability to use its treasury to incentivize the growth of the protocol’s users. These incentives will fall under the Shell User Incentive Plan (ShUIP). High-level, a ShUIP will incentivize specific on-chain behavior. Rewards will be calculated off-chain. Periodically, these rewards will be pushed to a Merkle root on-chain where users can then claim their tokens. Once a ShUIP has passed a Snapshot vote, a few extra steps will be necessary. On-chain actions are tracked off-chain by the designated party, and hence so are rewards. In order to hold the designated party accountable, rewards will not be transferred from the DAO Treasury until after the exact rewards have been calculated. After the reward Merkle root has been posted, there will be a holding period to contest the results. If no objections are raised within this period, the Multisig will disburse the rewards as indicated. ShUIPs should include the following information in the **Specification**. * Which token(s) from the DAO Treasury will be used, and the amount (e.g. 1,000,000 SHELL) * The duration of the proposal (e.g. 100 days) * The on-chain actions that will be tracked (e.g. LPing in the SHELL+ETH pool) * How to calculate the reward based on the on-chain action (e.g. 10,000 SHELL each day, given out proportionally to the user’s share of the total LP token supply) * A designated party to track users’ on-chain actions off-chain (e.g. Cowri Labs). The designated party must also agree to carry out the ShUIP, should it pass * Length of holding period to resolve disputes (e.g. four days) * Designated party’s incentive/payment (e.g. 1000 SHELL tokens) * How often rewards will be released (e.g. every 2 weeks) * Whether rewards will be subject to a lock-up, and if so, for how long? (e.g. 2 year linear lock up) ### 4. Builder Program The DAO can use its treasury to incentivize protocol and ecosystem development. Once a Builder Program proposal has passed a Snapshot vote, a few extra steps will be necessary. Depending on how project milestones are tracked or reported, they may be monitored off-chain by the designated party, in which case so are rewards. In order to hold the designated party accountable, rewards will not be transferred from the DAO Treasury until after the designated milestone is reached. After agreed-on progress reports are released, there will be a holding period to contest the results. If no objections are raised within this period, the Multisig will disburse the rewards as indicated. Builder Program proposals should include the following information in the **Specification**. * Project name * Project category (Protocol integration, Shell-native primitive, Dapp, Shell Protocol Improvement, Developer resources, etc.) * Team information (Include company or team members and relevant contact info) * Deliverables or metrics that will be tracked (e.g. product releases, media episodes, number of hackathon attendees) * Maintenance and Upgrade Plans * Budget breakdown, including which token(s) from the DAO Treasury will be used (e.g. 50,000 SHELL and 50,000 ARB) * How to calculate the reward, if it varies with deliverables or metrics * Whether rewards will be subject to a lock-up, and if so, for how long? (e.g. 2 year linear lock up) * How often rewards will be released (e.g. every 2 weeks) * Reporting requirements to track progress and maintain accountability, or the name of the party responsible for monitoring progress (e.g. GitHub updates or status briefs posted to the forum, or Shell Foundation) * Additional info ### 5. Miscellaneous For all other proposals, use Miscellaneous. # Governance Stages ## Stage 1: Request for Comment (RFC) In the initial stage, the author posts an RFC to the Shell governance forum on Commonwealth. Anyone may author and post an RFC. To create an RFC, navigate to the Proposals Category on Commonwealth and create a new topic. * Forum post title must follow the format: "RFC: \[Category]/\[Your Proposal Title]" * The text of the post must follow the format in [Proposal Template](/shell-dao/governance-process#proposal-template). * Have an idea for an RFC? Before making a formal post, consider first sharing your thoughts, concerns, or goals on the forum to get early feedback or co-authors. You may then link to this discussion when you post the RFC. Forum moderators will check that RFCs follow the correct format. If there are any issues, the author will be notified and invited to repost the RFC properly. ## Stage 2: Discussion During this stage, the community can provide feedback and help author(s) modify or revise the proposal. It is recommended to allow **at least one week** for open discussion. Complicated or controversial proposals may benefit from a longer discussion period. * Authors are expected to be active participants in the forum discussion. * As the author, you are the champion of this proposal! It's up to you to promote the RFC, get feedback and inspire voters. * Consider using supplemental discussion platforms, such as Discord or Twitter spaces. * Reach out to veSHELL delegates for their support. * Be open to making changes to your proposal as needed. ## Stage 3: Snapshot Vote Once the author(s) consider the proposal finalized, it's time to move to a vote. The Snapshot process begins when an address with at least 2000 veSHELL (individually or by delegation) posts a Proposal that meets all of the required specifications. A valid Snapshot vote must adhere to the following. * The proposal must provide a link to the forum post of the respective RFC. * The order of vote options must be as follows. (The order is important to reduce noise resulting from users who always just click the first option.) 1. ABSTAIN 2. NO 3. YES * The vote must run for **10 days**. * The vote must have a quorum of **10% of the total supply** of veSHELL, as measured at the block it was proposed. * If the proposal receives **more “YES” votes than "NO" votes**, it will be considered “Passed”. * If applicable, the linked payload must match the specification. One veSHELL token = one vote. If a vote fails, it will not be executed. You may post it again to Snapshot for a re-vote, but you are encouraged to wait at least **one month** before doing so, unless other circumstances have meaningfully changed. This is to reduce spam and be considerate of the time and energy required for proper governance. {% hint style="info" %} A Snapshot vote that fails to meet all of the above requirements will not be valid, even if it wins a majority of the votes. If you're unsure, don't be shy! Ask for help. {% endhint %} ## Stage 4: Results and Execution If a vote requiring on-chain activity passes, the [DAO Multisig](/shell-dao/dao-multisig) must then execute the vote as soon as possible, at maximum within **one week**. Upon transaction execution, community moderators are expected to post a comment on the forum thread with a link to the transaction. In case of a delay, multisig signers must post regular updates to the Forum on the Proposal's thread providing an explanation and relevant details. Keep in mind the DAO's on-chain capabilities are limited. All other votes will be executed off-chain following the steps described in the proposal. # Delegating Votes How to delegate veSHELL ## Overview Users with veSHELL can participate in the Shell DAO by voting. However, not all users have the time to be active and informed participants in the governance process. That is why some users choose to delegate their voting power to others. Delegating votes on Snapshot is permissionless and gasless. You may delegate to any wallet. You can change your delegate choices at any time. However, once a Snapshot vote is initiated, any veSHELL you had delegated at the start of the block remains allocated to the same delegate, for the purposes of that vote. So, be careful in case a vote is coming up in which you may want to switch delegates. Delegating your veSHELL never results in a transfer of tokens. Your veSHELL remains yours! Users can delegate their voting power through [Snapshot's UI](https://snapshot.org/#/delegate/shellprotocol.eth). ## Become a delegate Are you interested in taking an active role in Shell Protocol governance? If so, you may want to become a veSHELL delegate. You do not have to hold SHELL to be a delegate. Both individuals and organizations are eligible. Delegates are not currently compensated, but this could change in the future. Delegates are expected to be thoughtful, reliable, and active participants in the Shell ecosystem. Some responsibilities include: * Provide comments and feedback on governance forum posts * Maintain a public profile with open DMs, for example on Twitter * Vote consistently on Snapshot proposals and explain the rationale behind each vote * Stay informed about developments in Shell Protocol's ecosystem and technology Prospective delegates should introduce themselves and respond to community questions in the [Shell Forum](https://commonwealth.im/shell-protocol/). ## Delegate Introduction Template Delegates are encouraged to share the following information about themselves. **Name:** **Snapshot profile:** **Twitter/Discord/Telegram:** **Languages I speak & fluency:** **Professional & web3 background:** **Why I want to be a Shell DAO delegate:** # Mutable Protocol Fees There is only one protocol fee ## Overview Shell Protocol was designed with one, and only one, protocol-level fee. This fee is an "unwrap" fee, to be applied only when users remove value from the Ocean. At this time, the fee is set to zero. The fee has a hard-coded cap of 0.05% to prevent wild rent-seeking behavior. It’s also a security measure—in case the DAO is compromised, an attacker can’t lock user tokens in the protocol by setting the fee to 100%. ## Value Generation How does Shell Protocol generate value? Shell is like a nightclub that is free to enter but costs money to leave. You can stay in the nightclub as long as you want—days, weeks, even years, all the while having a great time without paying a cent. It’s only the moment you walk out the door that you pay an exit fee. Wrapping tokens into Shell’s accounting layer, [the Ocean](/how-shell-works/the-ocean-accounting-hub), is free. It is also free to move your tokens around Shell, whether that means transferring your tokens to other addresses within the Ocean, or using them with various applications in the Shell ecosystem—no matter if you make ten transactions or ten thousand. However, if you want to unwrap tokens, aka remove your liquidity from the Shell ecosystem, you have to pay a percent fee. That's a benefit to using primitives built natively on the Ocean, in contrast to external protocols connected to the Ocean with an adapter. External protocols rely on external token accounting, which means they will ultimately be subject to the unwrap fee. As more people use Shell, more volume will flow in and out of the Ocean, and the protocol collects more revenue. The Shell DAO is the beneficiary of this revenue. SHELL token holders collectively control the DAO via voting. Hence, SHELL tokens directly benefit from the revenue collected by the Ocean. What to do with the protocol revenue is up to the DAO, and thus up to the SHELL token holders. For example, they could distribute the funds amongst themselves. Or, they could reinvest the capital into further developing the protocol. Or, something else entirely. # DAO Multisig Details and composition of the Shell DAO Multisig {% hint style="info" %} The multisig does **not** have custody or control over funds in the Ocean contract, nor in any protocols connected to the Ocean. Even if the multisig is compromised, liquidity in Shell Protocol will remain safe. {% endhint %} The Shell DAO Multisig is a 6/11 wallet on Arbitrum. Composition and signers may be subject to change, depending on the DAO. [View the DAO multisig activity using the Safe app](https://app.safe.global/home?safe=arb1:0x808038B1B6C21c0C6F98cA640f8a19C19B405fba). `Address:` [`0x808038B1B6C21c0C6F98cA640f8a19C19B405fba`](https://arbiscan.io/address/0x808038B1B6C21c0C6F98cA640f8a19C19B405fba) When a DAO vote succeeds on Snapshot, it doesn't automatically trigger the execution of the proposal. Instead, it serves as instructions for the DAO Multisig. Signers on the multisig are like system administrators, or government representatives. They can execute the proposal on-chain on behalf of the DAO. The Shell DAO multisig exists solely to fulfill the wishes of the veSHELL voters, as described in the governance process. Why a multisig, rather than fully on-chain governance? At this early stage in DeFi, on-chain governance is not yet mature. For example, there are no battle tested implementations of vote-escrowed tokens with on-chain governance. Perhaps in the future, when the technology is more robust, the Shell DAO will transition to a different governance model. Although there are disadvantages to concentrating certain privileges in the hands of a multisig, it is much better than a single signer. In this sense, larger multisigs are more secure. Multisig signers are chosen for their trustworthiness in the Shell, Arbitrum, and Ethereum communities. It is an honor and responsibility. Individuals on the multisig are public figures. They must be held accountable to one another and to the veSHELL community. If at any time a signer's actions signify improper conduct, they may be replaced. The following individuals are signers on the multisig.
NameTwitterAddress
Chim9https://twitter.com/thechim90xF44217A8b6b3f258BFFEaD635c226528aa516aea
Etiennehttps://twitter.com/etienneroyole0x4B2d4177d072e6258BD41a7C4DB31E00D08F2E12
Griff Greenhttps://twitter.com/thegrifft0x89E12F054526B985188b946063dDc874a62fEd45
Joe Ahttps://twitter.com/ComfyVentures0xde05E6c4d57CB95894f359D87080cD4D82d1B782
limeshttps://twitter.com/limes_eth0xA7860E99e3ce0752D1ac53b974E309fFf80277C6
Mike Bhttps://x.com/defigod50xc4591c41e01a7a654B5427f39Bbd1dEe5bD45D1D
Virazhttps://twitter.com/Viraz040x72466f2ef6Fd28b8Ed905622c80298f783352aa0
DKhttps://twitter.com/DK3Anon0xAD16ebE6FfC7d96624A380F394cD64395B0C6144
bfreshhttps://twitter.com/BFreshHB0xAE9Df752dc71Fc2Dc224Fa6c142834233AC1f65b
Kevin Nielsenhttps://twitter.com/kevinknielsen0xc1a69F906Ce4366C0C77e0219b3132FeA0969231
Kenny Whitehttps://twitter.com/Dark__Kenny__0xa23754e9f9c5Be3fe68336c7e2F81ced34539819
# Toucan Votes Toucan NFTs for proto-governance community votes ## Proto-governance Holders of Shell's Government Toucan NFT are eligible to vote on various [community polls on Snapshot](https://snapshot.org/#/shellprotocol.eth). It is one of the largest and most active Arbitrum communities on Snapshot. The Toucan is Shell's "proto-governance" NFT. In the past, these polls have dictated such things as [which accounts Shell's Twitter should follow](https://shellprotocol.io/posts/running-our-twitter-with-government-toucans/), to whether [Shell Points should be a factor in a future $SHELL launch distribution](https://snapshot.org/#/shellprotocol.eth/proposal/0x4a8f0fa77abd1180353ff55fd36368b7c2f294105b7620491959d8dd80892485). Shell Protocol's governance may evolve as a "toucameral" system, incorporating both the Toucan community and holders of the SHELL token. ## Background The [Government Toucans event](https://shellprotocol.io/posts/launching-our-government-toucan/) was a 24-hour free NFT mint for the community on April 1, 2022. On that day, 47,021 [Government Toucans](https://arbiscan.io/token/0x642ffab2752df3bce97083709f36080fb1482c80) were born. [Click here to read more about the origin and use of the Government Toucan.](/user-guide/all-about-toucans) # Earn Rewards {% hint style="info" %} This page is a placeholder until the Shell DAO decides on its rewards program. {% endhint %} # Shell Points (Concluded) All about earning Shell Points during Seasons 1-3 {% hint style="info" %} The Shell Points system officially concluded at the end of Season 3 on January 15, 2024. {% endhint %} ## Contents * [Overview](#overview) * [Calculating Earned Points](#calculating-earned-points) * [Dollar Days](#dollar-days) * [Compounding Points (Discontinued)](#compounding-points-discontinued) * [Summed Points](#summed-points) * [Volatile Tokens](#volatile-tokens) * [Quotas](#quotas) ## Overview Shell Points were a way of tracking contributions to Shell Protocol beginning with the Shell v2 guarded launch and continuing until the launch of Shell v3 ([Seasons 1-3](/shell-dao/shell-token/airdrop-eligibility-and-crab#id-24crab-distribution-2)). [Shell Points were originally announced in August 2022](https://shellprotocol.io/posts/introducing-shell-points/). In November 2022, the community [voted in favor](https://snapshot.org/#/shellprotocol.eth/proposal/0x4a8f0fa77abd1180353ff55fd36368b7c2f294105b7620491959d8dd80892485) of using Shell Points as a factor in the upcoming [$SHELL distribution](/shell-dao/overview). Shell Points were calculated off-chain, but they were independently calculable and verifiable for any wallet using publicly available chain data. [Multipliers](/user-guide/earn-rewards/multipliers-and-boosters) and other values used to calculate Shell Points were dynamic, changing as the protocol matured, during new Seasons, or during special events. In short, Shell Points were earned by [wrapping tokens into Shell](/user-guide/wrap-tokens) and holding Shell-native assets. There were also some additional ways to enhance Shell Point scoring potential every once in a while, including special community events. ## **Calculating Earned Points** ### **Dollar Days** The base unit in the Shell Points system is a **dollar day**. At the simplest level, dollar days track the USD value of all the assets in your Shell wallet over a period of time. A user holding a Shell-wrapped or Shell-native token of $1 USD value (such as shDAI or shUSDC) earns one Shell Point per day from that wrapped token. For example, a wallet that holds 10 shDAI for 10 days would earn 100 Shell Points. ![](https://cdn-images-1.medium.com/max/1600/0*zxTGCHOSLma1Rh61) In practice, every token in Shell will have a **multiplier** attached to it. These multipliers will allow you to earn more than one Shell Point per dollar day (**SP/DD**) for holding certain token types. For example, if the LP token of DAI+USDC has a 2x Shell Point multiplier, holding 10 DAI+USDC for 10 days will grant the user 200 Shell Points. ![](https://cdn-images-1.medium.com/max/1600/0*EpXjo4u4mWZaGRUk) You will never lose points. They are calculated every block and accumulate over time. These calculations occur off-chain using publicly available data. They are open-source, and available for anyone to independently track and verify. ### **Compounding Points** {% hint style="info" %} Compounding points were discontinued at the end of [Season One](/shell-dao/shell-token/airdrop-eligibility-and-crab#id-24crab-distribution-2). {% endhint %} Shell Points are also earned through a persistent compounding mechanic. This effect increases over time, and is not based on any particular token held. Instead, it is applied to the entire USD value of all your aggregate Shell-based tokens. Compounding points are not tracked on a per-token basis. Say Alice’s wallet carries an overall Shell balance worth $10,000 USD for 100 days. Without compounding dollar days (and without considering multipliers), her earned Shell Points appear as follows: ![](https://cdn-images-1.medium.com/max/1600/0*t2lteRgVq3ZB9YXc) Now let’s calculate the compounding effect. To do this, we take the total USD value of Alice’s wallet and the number of days elapsed. With this information, we can complete the formula below to find our additional compounding points across 100 days for a wallet worth $10,000 at a compound rate of 0.189%. ![](https://cdn-images-1.medium.com/max/1600/0*yCssG8HnYS5MQY3G) Our goal with compounding dollar days is to provide an additional reward for users who leave sums in Shell for extended periods of time. What happens if the USD value of Alice’s Shell wallet falls and rises over time? Let’s take a look at a few examples to understand. In this first example, Alice has a USD value of $100k in Shell-wrapped assets. She unwraps 100% of them, reducing the USD value of her Shell balance to $0. Then she re-wraps the same amount again. ![](https://cdn-images-1.medium.com/max/1600/0*qXmqpnrlqa2L6Iex) As you can see above, the compounding time of Alice’s wallet was reset when she withdrew all her tokens from Shell. When she re-wrapped her assets back into Shell, the compounding process began again from scratch. Now let’s take a look at a different scenario. In the below example, Alice once again has $100k in USD of Shell-wrapped assets. Here, Alice unwraps half, reducing her Shell balance to $50k. Then she re-wraps additional tokens back in, raising her balance back to $100k. ![](https://cdn-images-1.medium.com/max/1600/0*4Ek7ltBp-wV8u2FB) In this example, half of the wallet’s compounding Shell Points stop compounding when the user’s balance drops to $50k. The other half is maintained, since the balance has remained ‘unbroken’ since the start of the graph. When the balance returns to $100k, a new compounding process begins for the new additional value of 50k. ### **Summed Points** As a reminder, Shell Points are earned based on the dollar value of your held tokens, not the raw count. A token worth $2 USD, for example, would earn a base amount of two Shell Points per day. In the case below, we’ll say that DAI+USDC LP tokens are worth $1 USD each. Now let’s put it together with a practical example. Assume Alice holds 10 LP tokens for the DAI+USDC pool. Let’s use our example multipliers and time bonus value from before. DAI+USDC LP token multiplier: x2 Compound value: 0.189% With these, we can calculate how many Shell Points Alice will earn over a period of days. Let’s look at 100 days. For this period, we’re going to do two separate calculations — one for token multipliers, and one for compounding dollar days. At the end, these two figures are summed. This leaves us with a final value for the Shell Points Alice has earned over the hundred day period. ![](https://cdn-images-1.medium.com/max/1600/0*oZq-k2Trj4LLq_7y) ![](https://cdn-images-1.medium.com/max/1600/0*QjcSwjJrZHrbFtCl) ![](https://cdn-images-1.medium.com/max/1600/0*nvM3Ld27Xr5kruHZ) ### **Volatile Tokens** Since calculating Shell Points involves the USD value of tokens, volatile assets such as ETH present a few unique considerations. The first involves accurate price discovery for tokens and the way these prices should be stored. Token prices fluctuate day-to-day, hour-to-hour, and minute-to-minute. Updating the Shell Points calculation this frequently is not feasible or necessary. Instead, our system will find a rolling weighted average of each token’s price (sourced from CoinGecko) and update it periodically. The second consideration involves the way that volatile assets may affect users’ compounding. A wallet containing 1 shETH, for example, will rise and fall in USD value based on the price of ETH. As such, it will lose part of its ‘legacy compounding’ every time the price of ETH falls. Rolling weighted averages will also help alleviate this concern, insulating users against lost compounding due to short, sharp dips in token value. ## Quotas During the beginning of the Shell guarded launch, wrapped tokens and pools will be in a state of ‘closed beta’. In effect, this means there will be limits on the maximum amount of tokens of each type that a user can use to earn Shell Points. You will be able to wrap and hold tokens in excess of your quota, but the excess will **not count** toward your daily Shell Point gain. The intention of this system is to limit the rate of TVL growth in experimental pools, both for the sake of individual user security and security of the platform overall. ![](https://cdn-images-1.medium.com/max/1600/0*O7iFilF-8_V8duuv) In the example above, you can see the ‘Balance / Quota’ column listed on the user’s Shell Points screen. ‘Balance’ obviously refers to the amount of each token type held. ‘Quota’ meanwhile is the maximum number of tokens of that type that can be used to earn Shell Points. In the example above, the wallet pictured has its Shell token types ‘maxed’, i.e. meeting or exceeding their given quota. As such, they appear in green. These quotas are separately calculated and tracked for each token type listed in the wallet. When a user exceeds a certain token’s quota, they will not earn Shell Points on any excess tokens they hold. These excess tokens will also not count toward a user’s wallet value for the purposes of calculating compounding Shell Points. For example, if a user holds 1,000 shDAI and has a shDAI quota of 500, they will earn Shell Points as if they are only holding 500 shDAI. However, if the user has additional quota available in another token type (such as shUSDT), the user can swap their extra shDAI for shUSDT to maximize their daily points. As stated prior, quotas are not hard caps on the amount of tokens a user can hold or swap. From day one, Shell will be free to use however you like. That said, Shell Points will not be earned on tokens held in excess of the user’s individual quotas. From a points calculation perspective, it will be as if they don’t exist at all. Like Shell Points, quotas are not a part of the actual Solidity code of Shell Protocol. Since Shell Points are calculated off-chain, we do not need to modify the smart contract to make Shell Point and quota adjustments over time. As Shell proves itself on Arbitrum mainnet, we will begin to lift quota limits for specific tokens, transitioning them from ‘closed’ to ‘open’ beta and allowing anyone access.[ Check out this guide to learn how to get quota.](/user-guide/earn-rewards/get-quota) # Bro Kwon's Booty The story of Bro Kwon's Booty and its role in Shell Points ## Contents * [Introduction](#introduction) * [Crate Hunt (Concluded)](#crate-hunt) * [Artifacts](#artifacts) * [Activating Artifacts](#activating-artifacts) * [FAQ](#faqs) ## Overview Bro Kwon's Booty was a community treasure hunt and NFT collection [originally released in November 2022](https://shellprotocol.io/posts/the-tale-of-bro-kwon's-booty/). The NFT collection consists of 35,000 crates, each of which can be "opened" by the owner to reveal an artifact. Certain artifacts can then be [activated](#activating-artifacts) to help users earn Shell Points. `NFT Contract:` [`0x619f1f68a9a3cf939327801012e12f95b0312bb9`](https://arbiscan.io/token/0x619f1f68a9a3cf939327801012e12f95b0312bb9) If you're curious, you can [read up on the backstory](https://shellprotocol.io/posts/signals-from-the-deep/) starring Shell World heroes Alice and Bob. ![](https://shellprotocol.io/static/img/bro-kwons-yacht.png) ## Crate Hunt (Concluded) During the original event on November 14 2022, there were 20,000 *Sunken Crates*, 10,000 *Rare Crates*, and 5,000 *Mythic Crates*. All crates cost 1 DAI to retrieve; however, retrieving *Rare Crates* required owning 1 toucan and retrieving *Mythic Crates* required owning 3 toucans. All original crates are now sold out but may still be purchased on [secondary markets such as OpenSea](https://opensea.io/collection/bro-kwons-booty). ![](https://shellprotocol.io/static/img/crates.png) ## Artifacts Each crate contains a single artifact. To reveal the artifact, you need to open the crate. This will burn the crate NFT and mint a new (random) artifact NFT. **Warning: once revealed, you can’t put the artifact back in the crate!** You can also directly [buy artifacts on secondary markets such as OpenSea](https://opensea.io/collection/bro-kwons-booty). Some artifacts are rarer than others, as indicated in Alice's rarity table below. (Alice believes the *Rare* and *Mythic* crates are more likely to contain more powerful artifacts.)
Artifacts come in three major flavors: [quota expanders](/user-guide/earn-rewards/get-quota), [Shell Points boosters](/user-guide/earn-rewards/multipliers-and-boosters), and [miscellaneous items](/user-guide/earn-rewards/crafting). Expanders increase your token quotas permanently, making you eligible to earn Shell Points. Boosters temporarily increase the rate at which you earn Shell Points. Miscellaneous items don’t seem to have much use by themselves (but Bob thinks he might be able to buidl something with them someday)… Crates and artifacts are NFTs. You can [buy, sell, and trade these on any NFT marketplace on Arbitrum](https://opensea.io/collection/bro-kwons-booty)—but only until the artifact is activated. ## Activating Artifacts Activating an artifact will tap its power, instantly supercharging your wallet with its special ability. But remember, once you activate an artifact to unleash its power, the NFT is burned—meaning you won’t be able to trade the artifact anymore. Wondering whether to activate an artifact? Continue to the next section to learn more about different artifacts and what they do. ## FAQ
What’s the difference between the Sunken, Rare, and Mythic Crates? The only difference between the crates is the drop rate (probability) for containing powerful artifacts. *Sunken Crates* have a standard drop rate; *Rare Crates* have a slightly better drop rate and *Mythic Crates* have the best drop rate. Refer to [Alice's rarity table](#artifacts) for details.
Is it random or predetermined which artifact will come out of my crate? Random. Alice’s rarity table only tracks the probability of discovering any particular artifact in any particular crate. Whenever you open a new crate, it’s like rolling dice—anything could happen!
Are the crates and artifacts NFTs? Yes! Both the crates and the artifacts are NFTs. Up until you activate an artifact, you can [buy, sell, and trade them on any NFT marketplace on Arbitrum](https://opensea.io/collection/bro-kwons-booty). However, once you activate an artifact, the NFT is burned (so you can no longer trade it).
Give me the technical details of the NFTs. The crates correspond to ERC-1155 IDs of 0, 1, and 2, and artifacts correspond to IDs between 3 and 17. When you open a crate, your crate NFT is burned and your balance of some ERC-1155 ID between 3 and 17 is increased. Once you activate an artifact, that NFT is burned too. `NFT Contract:` [`0x619f1f68a9a3cf939327801012e12f95b0312bb9`](https://arbiscan.io/token/0x619f1f68a9a3cf939327801012e12f95b0312bb9)
# Get Quota A guide to getting quota for earning Shell Points ## Contents * [Overview](#overview) * [Expanders](#expanders) * [Initial Quota Allotment](#initial-quota-allotment) ## Overview {% hint style="info" %} Since the start of Season Two, you can earn Shell Points on many pools without any quota! {% endhint %} Some experimental pools may still require quota. During the guarded launch, quota was required to be eligible to earn Shell Points. [Refer to this section to read more about why quotas were required.](/user-guide/earn-rewards/shell-points-concluded#quotas) There are two ways to get quota. The first is by having been included in the [initial quota allotment, as announced on September 2, 2022](https://shellprotocol.io/posts/shell-v2-launch-plan-and-quotas/). The second is by applying expanders, which are artifacts from [Bro Kwon's Booty](/user-guide/earn-rewards/bro-kwons-booty). Remember, you will be able to wrap and hold tokens in excess of your quota, but the excess will **not count** toward your daily Shell Point gain. ## **Expanders** There are five different quota expanders that, when activated, will permanently increase your token quotas. Each type of expander has a different level of power: *Smashed Expander* (good), *Standard Expander* (great), *Chunky Expander* (fantastic), *Expando-Chad* (unbelievable) and *Bro Kwon’s Mastermind* (holy Satoshi, this is awesome). You can activate as many expanders as you want—each one simply adds additional quota to your token quotas. Expanders can now be purchased on [secondary markets such as OpenSea](https://opensea.io/collection/bro-kwons-booty). ![](https://shellprotocol.io/static/img/expanders.png) ## Initial Quota Allotment (Concluded) As [announced September 2, 2022](https://shellprotocol.io/posts/shell-v2-launch-plan-and-quotas/), approximately half of initial quota went toward LPs in Shell v1, and the other half of initial quota was distributed per-[toucan](/user-guide/all-about-toucans). For Shell v1 LPs, quota was based on the percent of total TVL you contributed over the life cycle of the pool. The actual formula is a bit more complicated, but that’s the general framework. This formula was applied to a **snapshot of Shell v1 from its launch until 11:59 pm Hawaii Time on Thursday, September 1, 2022.** No LP activity after the end of that snapshot affected quota allocation. For [toucan holders](/user-guide/all-about-toucans), we’ve made it simple. For every toucan in your wallet at the moment we take our toucan snapshot, you will receive roughly $5 USD of quota for each of the current and near-future tokens on Shell v2. If Alice holds 50 toucans, for example, her initial quota for each pool and wrapped token will be around $250 USD. This toucan snapshot was taken at **noon Pacific Time on Friday, September 9th, 2022**. Your initial quota from toucan ownership will be allotted based on however many toucans are held in your wallet at that exact moment in time. # Multipliers and Boosters A guide to multiplying your rate of earning Shell Points ## Contents * [Overview](#overview) * [Boosters](#boosters) * [Multipliers](#multipliers) ## Overview There are two ways to multiply the rate of the Shell Points you earn over time. The first is by being vigilant of the multipliers, which are applied automatically but differ over time across various tokens and pools. The second is by applying boosters, which are artifacts from Bro Kwon's Booty. ## **Boosters** Boosters temporarily increase the rate at which you earn Shell Points. (Remember, you can’t earn Shell Points until you first have some amount of token quota—and you’ve deposited some tokens in there!) There are four types of boosters: *Mini Booster* (2%), *Main Booster* (3%), *Hyperbooster* (5%), and *Hand of the Accountant* (15%). *Mini* and *Main Boosters* last ten days each, while *Hyperboosters* and *Hands of the Accountant* last thirty days each. You may activate multiple boosters simultaneously, so long as they are of different types (for a maximum 25% increase if all four are activated at one time). If you activate two or more **identical boosters**, note that their powers will be applied **consecutively** over time, rather than simultaneously together. In other words, you will wait for the first to expire, before the next booster starts. For example, if you activate five *Hyperboosters* at the same time, you will get a 5% boost over the next five months. ![](https://shellprotocol.io/static/img/boosters.png) ## Multipliers Like boosters, multipliers increase the rate at which you earn Shell Points. Every token or pool has a **multiplier** attached to it automatically. Multipliers are [dynamic](/user-guide/earn-rewards/dynamic-multipliers), changing as the protocol matures. You can view and sort by multipliers on the Points tab. These multipliers will allow you to earn more than one Shell Point per dollar day (**SP/DD**) for holding them. For example, if the LP token of DAI+USDC has a 2x Shell Point multiplier, holding 10 DAI+USDC for 10 days will grant the user 200 Shell Points.
# Dynamic Multipliers About dynamic multipliers ## Contents * [Overview](#overview) * [Why dynamic multipliers?](#why-dynamic-multipliers) * [How dynamic multipliers work](#how-dynamic-multipliers-work) * [Timeline](#timeline) ## Overview Shell points are awarded by taking the monetary value of a Liquidity Provider (LP) token in dollars and [multiplying it by a set multiplier](/user-guide/earn-rewards/multipliers-and-boosters#multipliers). Initially, the core team assigned discretionary multipliers to newer, more experimental pools. Multipliers were used to reward liquidity providers for smart contract risk and updated by hand as pools matured. Multipliers also help drive liquidity to the pools where it is needed most. As Shell has matured and the pools have survived the test of time, driving liquidity appropriately has become far more important than compensating for smart contract risk. ## Why dynamic multipliers? Good liquidity allocation is crucial for the efficient operation of the fractal pool system of Shell Protocol, as strong liquidity in core pairs (like ETH and stablecoins) is necessary for efficient swaps through the fractal network. Although the original system was effective in reinforcing the liquidity of core pairs, it was also a very broad brush and difficult to precisely tune. Small changes in multipliers can lead to massive shifts in liquidity due to users chasing the highest yield. Instead, Shell is moving to a self-regulating system for dynamic multipliers, replacing the previous system of the core team assigning discretionary multipliers. This new approach to awarding Shell Points will lead to a more balanced and efficient distribution of liquidity across the Shell Protocol ecosystem. ## How dynamic multipliers work Essentially, the lower the supply of a token (such as [TOUCOIN](/getting-started/integrations/shell-native-primitives/nft-fractionalizer) or LP tokens), the more points per dollar value users will receive for holding them. As the supply increases, the multiplier decreases, and vice versa. This approach aims to find equilibrium resting points for certain pools and guide the liquidity of the protocol more thoughtfully. Looking at it a different way, you can imagine there is a fixed number of points per day to be issued to holders of a token. Say there are 100 points per day to be issued and only 10 tokens in existence. This means each token would earn the holder 10 points per day. Now, if the supply increased to 100 tokens, each token would earn the holder only one point per day. With a supply of 200, each token would earn the holder half a point per day. This can be compared to the gauge model by [Curve](https://resources.curve.fi/reward-gauges/understanding-gauges/) or [Balancer](https://docs.balancer.fi/reference/vebal-and-gauges/gauges.html) in its operation. ## Timeline Dynamic multipliers were introduced in a [beta phase with TOUCOIN and wrapped Toucans](https://shellprotocol.io/posts/introducing-dynamic-multipliers/). It was extended to all pools starting in [Season 3](/shell-dao/overview#24crab-distribution-1). # Crafting ## Contents * [Overview](#overview) * [Miscellaneous Artifacts](#miscellaneous-artifacts) ## Overview Crafting recipes allow users to combine artifacts in order to mint a new artifact with different powers. New recipes may become available at times during the guarded launch or for special crafting events. Click here to read about the [first Shell crafting challenge](https://shellprotocol.io/posts/lunar-new-year-crafting-challenge/) for the 2023 lunar new year. Different recipes may require any [artifact](/user-guide/earn-rewards/bro-kwons-booty#artifacts) as ingredients ([expanders](/user-guide/earn-rewards/get-quota#expanders), [boosters](/user-guide/earn-rewards/multipliers-and-boosters#boosters), or [miscellaneous](#miscellaneous-artifacts)). {% hint style="warning" %} Warning: just like *opening* crates and *activating* items, *crafting* a new artifact is irreversible. That means you won’t ever be able to deconstruct your new [Rabbit Booster](https://twitter.com/ShellProtocol/status/1617630250279788545) or [Lucky Chad](https://twitter.com/ShellProtocol/status/1636803784759463937) (or any other crafted item) in order to get the original items back. That’s because under the hood, when you craft a new artifact you’re really minting a new NFT and burning the old NFTs! {% endhint %} ## **Miscellaneous Artifacts** Miscellaneous items don’t increase quota or points by themselves. However, they may be used as ingredients in crafting recipes.
# Wrap Tokens How to wrap fungible tokens into Shell Wrapping tokens is the simplest way to get started with Shell Protocol. Wrapping a token does not affect its value or your balance. It simply switches the ledger on which ownership of the token is recorded. (In this case, ownership of Shell-wrapped tokens is recorded on [the Ocean](/how-shell-works/the-ocean-accounting-hub), Shell's accounting hub.) ## How to wrap tokens To wrap a token, first pick the token that you want to wrap in the 'Swap from' field. In the box below, pick the 'sh-' version of your token. You'll notice 'Swap from' now says 'Wrap from.' ![](https://cdn-images-1.medium.com/max/1600/0*NtR-iMwm5_IhDVcP) Fill in the numbers for how many tokens you want to wrap, and click 'Wrap Token." That's it! ## Why wrap tokens? You can earn [Shell Points](/user-guide/earn-rewards/shell-points-concluded) with comparatively low risk simply by wrapping tokens into Shell during the guarded launch. Wrapping tokens will make it easier and cheaper to use them with [Shell primitives](/getting-started/integrations/shell-native-primitives) later on. # LP in a Pool How to LP (Provide Liquidity) to Shell LP tokens on Shell are fungible, so they act like any other token. Also, since Shell AMMs support single-sided liquidity provision, you can LP using only one token type or an uneven split of assets. In the Shell app, the way to LP (provide liquidity) into pools is by ‘swapping’ from any supported token to a Shell LP token (aka 'shLP' token). ## How to LP in a pool First, select ‘shLP’ as the ‘Swap To’ token in the trade screen. ![](https://cdn-images-1.medium.com/max/1600/0*iN06zXW855BEO6De) Then click ‘Select LP token’ and choose your desired token from the list. ![](https://cdn-images-1.medium.com/max/1600/0*l6uATaBSFMP_xhqI) Each LP token corresponds with a different pool. The names of the tokens indicate what component tokens they have exposure to. In this example, we'll pick USDT+(DAI+USDC). ![](https://cdn-images-1.medium.com/max/1600/0*gvmopKDtLiCN7UBJ) Lastly, complete the swap for your desired LP token just like any other swap. This transfers your liquidity into that pool. ![](https://cdn-images-1.medium.com/max/1600/0*JiEOYp0DlgCapNm_) ## Why to LP? You can earn [Shell Points](/user-guide/earn-rewards/shell-points-concluded) by LPing in Shell pools during the guarded launch. You can also earn a portion of the AMM's revenue earned whenever the pool is used for swaps. ![Providing liquidity with Shell. It’s that simple.](https://cdn-images-1.medium.com/max/1600/0*ruKRY7hOO3FuZsS9) # Wrap NFTs How to wrap non-fungible tokens into Shell ![](https://shellprotocol.io/static/img/ShellGuides.jpg) Imagine you have 100 or so unique Government Toucan NFTs that you want to trade for their lowest value on the open market. Instead of listing and selling them one at a time, NFT wrapping makes it easier by bundling them together. This way, you can trade all your Government Toucan NFTs in a single transaction, making the process faster and simpler. To get started, the initial step is to wrap your Government Toucan NFTs. **1. Visit the Shell Protocol trading platform by navigating to** [**app.shellprotocol.io/trade**](http://app.shellprotocol.io/trade) **2. Verify that the necessary wallet, MetaMask, is set up, and then click the "Connect Wallet" button situated in the top-right corner of the app.** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/4336d177-3231-4563-9e98-abf4c7535b0f/stack_animation.webp) **3. Once you've successfully connected your wallet, navigate to the "NFTs" tab within the Token Selection menu and choose "Government Toucans."** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/15b1b405-1968-4a12-96a5-c7f9f8689802/stack_animation.webp) **4. Next, select the particular NFT(s) that you want to wrap.** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/8941544a-caa3-417a-af60-1e6a1b1958bc/stack_animation.webp) **5. For the bottom Token Selection, navigate to the NFTs tab, switch on the "Wrapped" button and choose "Wrapped Government Toucans.** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/8e6265ce-390c-4bed-9e43-c55ec53b3404/stack_animation.webp) **6. Click "Wrap Token"** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-13/675469b7-18ad-48b2-bcdc-3c3343b7e050/ascreenshot.jpeg?tl_px=757,890\&br_px=2250,1730\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,180) **7. Click "Confirm Trade"** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-13/feba1702-9a96-4677-bc0d-b1e24f509348/ascreenshot.jpeg?tl_px=753,862\&br_px=2246,1702\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,139) **8. Congratulations! You have successfully wrapped your Government Toucan NFT.** # LP in an NFT Pool How to LP (Provide Liquidity) to an NFT pool ![](https://shellprotocol.io/static/img/ShellGuides.jpg) **1. Visit the Shell Protocol trading platform by navigating to** [**app.shellprotocol.io/trade**](http://app.shellprotocol.io/trade) **2. Verify that the necessary wallet, MetaMask, is set up, and then click the "Connect Wallet" button situated in the top-right corner of the app.** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/4336d177-3231-4563-9e98-abf4c7535b0f/stack_animation.webp) **3. Once you've successfully connected your wallet, navigate to the "NFTs" tab within the Token Selection menu and choose "Government Toucans."** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/15b1b405-1968-4a12-96a5-c7f9f8689802/stack_animation.webp) **4. Next, select the particular NFT(s) that you want to LP.** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/8941544a-caa3-417a-af60-1e6a1b1958bc/stack_animation.webp) **5. For the bottom Token Selection, navigate to the Tokens tab, switch on the "Wrapped" button and choose "TOUCOIN".** ![](https://colony-recorder.s3-accelerate.amazonaws.com/files/2023-04-14/9a01b03c-eb9d-45e0-94a1-d23153853109/ascreenshot.jpeg?AWSAccessKeyId=AKIA2JDELI43YPETRQSC\&Signature=iLsD3vlnU3VHdfG5Z9/Gi260ifQ%3D\&Expires=1681453546) **6. Click "Wrap Token"** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/d99ccd3a-89f0-48ae-a0c7-32b9d2dcb24d/ascreenshot.jpeg?tl_px=517,546\&br_px=2010,1386\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,215) **7. Click the "I acknowledge the risk associated with this trade" field. DO NOT WRAP RARE OR SENTIMENTAL NFTS.** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/f13e66a7-372a-457e-93d7-7af26efd29fd/ascreenshot.jpeg?tl_px=273,486\&br_px=1766,1326\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,139) **8. Click "Continue".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/f8d17ebe-bb68-4beb-8433-820f392495da/ascreenshot.jpeg?tl_px=767,546\&br_px=2260,1386\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,154) **9. Click "Confirm Trade".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-13/feba1702-9a96-4677-bc0d-b1e24f509348/ascreenshot.jpeg?tl_px=753,862\&br_px=2246,1702\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,139) **10. Close the modal.** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/0d4c8dac-a088-47b8-b208-fe0bd34d8057/ascreenshot.jpeg?tl_px=1033,0\&br_px=2526,840\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,33) **11. Click the swap button.** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/85778752-e7ed-434b-b724-d2320f2aa39b/ascreenshot.jpeg?tl_px=583,534\&br_px=2076,1374\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,139) **12. Click "TOUCAN".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/fab0621b-5d03-4c26-a066-457adaf2d379/ascreenshot.jpeg?tl_px=1089,336\&br_px=2582,1176\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,139) **13. Click "LP Tokens".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/72120a33-3a87-468e-8551-3f08e7a516e5/ascreenshot.jpeg?tl_px=557,0\&br_px=2050,840\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,18) **14. Click "TOUCOIN+ETH".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/2723376b-2cf5-4305-8e1c-7b065bca13e2/ascreenshot.jpeg?tl_px=351,388\&br_px=1844,1228\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,139) **15. Add a token.** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/3e514734-9470-4507-ba1a-5f187821993e/ascreenshot.jpeg?tl_px=0,0\&br_px=1493,840\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=158,117) **16. Edit the token selection.** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/5f2853b9-2dab-403e-87fc-639b60e6cf72/ascreenshot.jpeg?tl_px=1147,224\&br_px=2640,1064\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,139) **17. Click "ETH".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/0ad0cd1b-57bd-48b6-83f6-ebfdde9c7fe1/ascreenshot.jpeg?tl_px=303,546\&br_px=1796,1386\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,206) **18. Enter the desired number of LP tokens.** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/64cd22b9-8db6-47ef-822e-ce9caf22b4c0/ascreenshot.jpeg?tl_px=245,546\&br_px=1738,1386\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,147) **19. Click "Trade Tokens".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/22b90940-c025-465b-8fcc-498f448a7347/ascreenshot.jpeg?tl_px=695,546\&br_px=2188,1386\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,184) **20. Click "Confirm Trade".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/8d4ac215-5e47-4138-bd67-4730044b4fda/ascreenshot.jpeg?tl_px=617,546\&br_px=2110,1386\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,251) **21. Congratulations! You have successfully done a proportional deposit into the Toucan AMM.** # Swap NFTs with an AMM How to trade NFTs on Shell ![](https://shellprotocol.io/static/img/ShellGuides.jpg) **1. Visit the Shell Protocol trading platform by navigating to** [**app.shellprotocol.io/trade**](http://app.shellprotocol.io/trade) **2. Verify that the necessary wallet, MetaMask, is set up, and then click the "Connect Wallet" button situated in the top-right corner of the app.** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/4336d177-3231-4563-9e98-abf4c7535b0f/stack_animation.webp) **3. Once you've successfully connected your wallet, navigate to the "NFTs" tab within the Token Selection menu and choose "Government Toucans."** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/15b1b405-1968-4a12-96a5-c7f9f8689802/stack_animation.webp) **4. Next, select the particular NFT(s) that you want to swap.** ![](https://colony-recorder.s3.amazonaws.com/files/2023-04-13/8941544a-caa3-417a-af60-1e6a1b1958bc/stack_animation.webp) **5. Choose any token you desire as the bottom token, and click "Swap Token".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/1ee65f42-fc09-4714-a65f-c7ed156dfcfe/ascreenshot.jpeg?tl_px=649,546\&br_px=2142,1386\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,237) **6. Click the "I acknowledge the risk associated with this trade" field. DO NOT WRAP RARE OR SENTIMENTAL NFTS.** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/f13e66a7-372a-457e-93d7-7af26efd29fd/ascreenshot.jpeg?tl_px=273,486\&br_px=1766,1326\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,139) **7. Click "Continue".** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/f8d17ebe-bb68-4beb-8433-820f392495da/ascreenshot.jpeg?tl_px=767,546\&br_px=2260,1386\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,154) **8. Click "Confirm Trade"** ![](https://ajeuwbhvhr.cloudimg.io/colony-recorder.s3.amazonaws.com/files/2023-04-14/01a395e2-0605-459f-ba4d-3388bfb05b4b/ascreenshot.jpeg?tl_px=831,546\&br_px=2324,1386\&sharp=0.8\&width=560\&wat_scale=50\&wat=1\&wat_opacity=0.7\&wat_gravity=northwest\&wat_url=https://colony-labs-public.s3.us-east-2.amazonaws.com/images/watermarks/watermark_default.png\&wat_pad=262,207) **9. Congratulations! You have successfully swapped your Government Toucan NFT.** # Shellscan An introduction to Shell's in-app block explorer ## Explore with Shellscan [Shellscan](https://app.shellprotocol.io/scan) is a user-friendly block explorer just for Shell Protocol transactions. It has its own tab, 'Scan', in the Shell App. [Click here to read more about Shellscan's backstory.](https://shellprotocol.io/posts/introducing-shellscan/) With Shellscan, you can easily see every Shell transaction you’ve ever sent. You can even see a breakdown of the sub-transactions, giving you insight into the inner workings of the [Ocean](/how-shell-works/the-ocean-accounting-hub) and the [Shell primitives](/getting-started/integrations/shell-native-primitives) you’ve used. For example, you can now see the transaction path of a swap. ![](https://cdn-images-1.medium.com/max/3588/0*1ZdLKVQM3YYaET-s) If all you’re looking for is a breakdown of your own account activity, Shellscan is much better than block explorers like Etherscan, which can be a bit overwhelming. If you do want to examine a Shell transaction on [Arbiscan](https://arbiscan.io/), just click the link on its transaction hash. ![](https://cdn-images-1.medium.com/max/7680/1*lZ-kWHiJZmPusMutilBelA.png) # All About Toucans A guide to Shell's proto-governance NFT ![](https://miro.medium.com/max/1400/1*WOJSErXBtn2YQ97-43V1Mg.png) ## Quick Links * Buy a toucan from Shell's [Toucan AMM](/getting-started/integrations/shell-native-primitives/nft-amms) * Buy a toucan from secondary NFT markets: [Tofu](https://tofunft.com/collection/government-toucans/items) or [Opensea](https://opensea.io/collection/government-toucans) * Read about [Toucan Votes](/shell-dao/toucan-votes) * `Contract address:` [`0x642ffab2752df3bce97083709f36080fb1482c80`](https://arbiscan.io/token/0x642ffab2752df3bce97083709f36080fb1482c80) ## Contents * [Introduction](#introduction) * [What do Toucans do?](#what-do-toucans-do) * [Toucan history](#toucan-history) ## Introduction The [Government Toucans event](https://shellprotocol.io/posts/launching-our-government-toucan/) was a 24-hour free NFT mint for the community on April 1, 2022. On that day, 47,021 [Government Toucans](https://arbiscan.io/token/0x642ffab2752df3bce97083709f36080fb1482c80) were born. ## What do Toucans do? The NFT drop was originally a one-time gift, but became a long-lasting symbol of Shell Protocol due to the enthusiasm of the community. The Toucan is now Shell's 'proto-governance' NFT, and is used in a 'toucameral' voting system to guide Shell's social activity. Holders of Shell's Government Toucan NFT are [eligible to vote](/shell-dao/toucan-votes) on various [community polls on Snapshot](https://snapshot.org/#/shellprotocol.eth). In the past, these polls have dictated such things as [which accounts Shell's Twitter should follow](https://shellprotocol.io/posts/running-our-twitter-with-government-toucans/), to whether [Shell Points should be a factor in a future $SHELL launch distribution](https://snapshot.org/#/shellprotocol.eth/proposal/0x4a8f0fa77abd1180353ff55fd36368b7c2f294105b7620491959d8dd80892485). As a beloved symbol of the community, having a toucan has granted several privileges to date. Toucan holders were [allocated initial quota](/user-guide/earn-rewards/get-quota) for participation in Shell's guarded launch. Having a toucan in your wallet would have helped you recover rarer crates during the [Bro Kwon's Booty event](/user-guide/earn-rewards/bro-kwons-booty). They also made holders eligible for a special [Discord](/getting-started/overview/community#discord) role that granted access to a secret toucan channel. ## Toucan history Every DeFi denizen knows those two fateful words — 'Wen token?' In Discord lobbies, in AMAs, and all across Twitter the question rings out. In time it becomes constant, another piece of background noise in the bustling DeFi metropolis. But, every once in a while, a flash of new and bold innovation cuts through the chatter. It demands your attention, staying in your mind long after the moment has passed. On November 26, 2021, such innovation was delivered in the Shell Protocol Discord server by user Joe \[Comfy Ventures]: ![](https://cdn-images-1.medium.com/max/1600/0*B6E8xTFoczefdFrl) *Toucan.* That was the word he spoke. So alike what had come before, and yet utterly transformed. *When? When toucan?* When toucan, indeed. Our team spent many long and painstaking minutes poring over this question, and in the end the conclusion was clear. We had to devote scarce and vital resources to finding this man an answer. On April 1, 2022, the Shell team put together a ‘token’ gift for the community. For 24 hours, anyone could visit the [Toucanomics](http://www.shellprotocol.io/toucanomics) page to mint their very own Government Toucan, a free Shell Protocol NFT. All that was needed was a wallet, and enough Arbitrum ETH to cover the network fee. Government Toucan minting was limited to one mint per wallet, although of course they can be sold and transferred. These Toucans were the **first ever Shell Protocol NFT drop**, and the team's first ever deployment of code on the [Arbitrum network](/how-shell-works/why-arbitrum) — both pretty exciting milestones for the protocol and the community. ![](https://shellprotocol.io/static/img/toucangif-compressed.gif) # Using Arbitrum Getting started with Arbitrum, Shell's first L2 home {% hint style="warning" %} Shell v3 now has deployments on several chains and L2s besides Arbitrum. This article dates from the launch on Arbitrum. {% endhint %} ## Contents * [Introduction](#introduction) * [Step 1: Bridging assets from Ethereum](#step-1-bridging-assets-from-ethereum) * [Step 2: Connect to Arbitrum from the Shell App](#step-2-connect-to-arbitrum-from-the-shell-app) ## Introduction Shell Protocol is deployed on [Arbitrum One](https://arbitrum.io/), an Ethereum rollup. That means you need to move tokens from Ethereum mainnet to Arbitrum in order to interact with the [Shell app](https://app.shellprotocol.io/trade). If you've never used Arbitrum before, this guide will show you how to bridge your assets and connect to the Shell app. You can [read more about the benefits of Arbitrum here](/how-shell-works/why-arbitrum). Before continuing, make sure to [set up Metamask on a desktop browser](https://metamask.io/) if you haven’t already. ## Step 1: Bridging assets from Ethereum Before using the Shell app, you'll have to send yourself ETH (and perhaps other tokens) using a bridge. [Follow this excellent tutorial for bridging assets](https://arbitrum.io/bridge-tutorial/) or use the quick guide below. **Make sure you select Arbitrum One as the network**, not Arbitrum Nova. Arbitrum bridge: ![](https://cdn-images-1.medium.com/max/1600/0*tJIPbG7Tq3nQyq90) In the Arbitrum bridge, select Mainnet as your source and Arbitrum One as your destination. Then select whichever token type you’d like to bridge first. You will need to pay a small gas fee (and potential authorization fee) for each token type you bridge. The actual bridging process will take roughly ten minutes from the time it is initiated. You do not have to wait for one token type to finish bridging before you start the next one. ![](https://cdn-images-1.medium.com/max/1600/0*tgjcqgmjFSth4Kb2) Once bridging is completed, success banners will appear for your bridged tokens on the Arbitrum bridge site. Now we can head over to the Shell app and deposit our funds. ## Step 2: Connect to Arbitrum from the Shell App Once you've bridged your assets, navigate back to the [Shell app](https://app.shellprotocol.io/trade). Click "Connect Wallet". In your Metamask wallet, change the network to Arbitrum One. Congratulations! You're now connected to the Shell App. ![Bob and Alice welcome Arbinauts to Shell World. It’s the beginning of a beautiful friendship.](https://cdn-images-1.medium.com/max/1600/1*XNAgJscgOHZLzmAlumUoQw.jpeg) # Migrate from Shell v2 (Retired) How to migrate your liquidity from Shell v2 You can access all tokens that were wrapped on Shell v2, through an archived version of the v2 front end. Only wrapped tokens need to be migrated. LP tokens in Shell v2 pools do not need to be migrated. 1. First unwrap your tokens on the [archived front end](https://v2.shellprotocol.io/trade). 2. Then go to the regular [Shell app](https://app.shellprotocol.io/trade). You'll be able to use your tokens with any Shell pool or wrap them using the current version of the protocol. **Shell v2 website:** [**https://v2.shellprotocol.io/trade**](https://v2.shellprotocol.io/trade) # Migrate from Shell v1 (Retired) How to migrate your liquidity from Shell v1 ## Quick Links * Use the retired Shell v1 interface here: ([Regular](https://v1.shellprotocol.io/), [Deactivated](https://deactivated-v1.shellprotocol.io/)) * [Learn more about Shell v1](/how-shell-works/shell-v1-retired) ## Contents * [Introduction](#introduction) * [Step 1: Connect to Shell v1](#step-1-connect-to-shell-v1) * [Step 2: Bridge funds to Arbitrum](#step-2-bridge-funds-to-arbitrum) * [Step 3: Connect to the Shell app](#step-3-connect-to-the-shell-app) ## Introduction After nearly two years of active life, Shell v1 has transitioned into a graceful retirement. The Shell team has no immediate plans to disable access to Shell v1 or its app interface. After all, nothing ever really disappears on the blockchain. However, the time has definitely come for LPs in Shell v1 to withdraw their funds and transition to the next iteration of Shell Protocol. A simple guide below explains how to get this done. ## Step 1: Connect to Shell v1 ![](https://cdn-images-1.medium.com/max/1600/0*fLbtwsBpBTaz8ZX7) First, visit the Shell v1 app and connect either your MetaMask or WalletConnect wallet. (Tip: the second iteration of Shell Protocol currently only supports Metamask.) If you have funds stored in the deactivated version of the Shell v1 pools, you may need to visit the deactivated Shell v1 app to retrieve them. On either app, the withdrawal process is the same. ![](https://cdn-images-1.medium.com/max/1600/0*LewkBf4NahOXGCKG) Once you connect your wallet, you will be able to see your balances for each active pool in the ‘Your Balance’ column marked orange in the screenshot above. If both of these pools show zero balance, you do not have any funds deposited in Shell v1 via your currently-connected wallet. ![](https://cdn-images-1.medium.com/max/1600/0*SiwlV1kwRkbE71m7) To withdraw funds from a pool, click that pool to go to the pool details screen. Here, you will see a gray ‘Withdraw’ button at the bottom. Click that. ![](https://cdn-images-1.medium.com/max/1600/0*2IvR6GxWZ1po_jjP) On the next screen, you will have the option to either ‘Withdraw Everything’ proportionally or specify which tokens you would like to withdraw to. For the stablecoin pool, if you withdraw everything proportionally, you will receive roughly 30% DAI, 30% USDC, 30% USDT and 10% SUSD. **Please note that the Shell team has no present plans to support SUSD in the updated Shell Protocol at any time**, so funds withdrawn as SUSD will not be able to wrap into Shell v2. If you do not want to receive part of your withdrawal in SUSD (or any other particular token), you can instead type values for each withdrawal token in the fields above. The app will warn you when the sum of the tokens you have typed exceeds your current balance. Depending on which tokens you are withdrawing to, you may see a slight additional gain or loss of value in your pending withdrawal. This mechanic gives you additional funds if your withdrawal brings the pool closer to its balanced state, and subtracts some funds if your withdrawal brings the pool further from its balanced state. A ‘Withdraw Everything’ withdrawal will do neither. Once you have found a balance of tokens that you are satisfied with, click ‘Withdraw.’ You will be charged a small amount of gas on mainnet for the transaction, and the stablecoins will be transferred to your wallet. For the wrapped BTC pool, withdrawal works identically, save for the fact that you can withdraw to any combination of WBTC, renBTC, and sBTC (instead of stablecoins). Tip: WBTC can be wrapped into the updated Shell Protocol. ## Step 2: Bridge funds to Arbitrum Now that you have withdrawn your funds from Shell v1, we can move them over to Arbitrum One just like any other tokens. We do this by visiting the Arbitrum bridge. [Check out the Arbitrum bridge tutorial](/user-guide/using-arbitrum) or jump straight to [the Arbitrum bridge here](https://bridge.arbitrum.io/). **Make sure you select Arbitrum One as the network**, not Arbitrum Nova. ![](https://cdn-images-1.medium.com/max/1600/0*tJIPbG7Tq3nQyq90) In the Arbitrum bridge, select Mainnet as your source and Arbitrum One as your destination. Then select whichever token type you’d like to bridge first. You will need to pay a small gas fee (and potential authorization fee) for each token type you bridge. The actual bridging process will take roughly ten minutes from the time it is initiated. You do not have to wait for one token type to finish bridging before you start the next one. ![](https://cdn-images-1.medium.com/max/1600/0*tgjcqgmjFSth4Kb2) Once bridging is completed, success banners will appear for your bridged tokens on the Arbitrum bridge site. Now we can head over to the Shell app and deposit our funds. ## Step 3: Connect to the Shell app ![](https://cdn-images-1.medium.com/max/1600/0*NtR-iMwm5_IhDVcP) In the new [Shell app](https://app.shellprotocol.io/trade), you can either wrap or LP to move your funds into Shell Protocol. Either way, during the guarded launch you will begin earning [Shell Points](/user-guide/earn-rewards/shell-points-concluded) (up to your [quota limit](/user-guide/earn-rewards/get-quota)). The option to LP will appear in the trade screen just like any other token. In the Shell app, you LP into pools by ‘swapping’ from any supported token to the LP token of your choice. ![](https://cdn-images-1.medium.com/max/1600/0*iN06zXW855BEO6De) ![](https://cdn-images-1.medium.com/max/1600/0*l6uATaBSFMP_xhqI) ![](https://cdn-images-1.medium.com/max/1600/0*gvmopKDtLiCN7UBJ) First, select ‘shLP’ as the ‘Swap To’ token in the trade screen. Then click ‘Select LP token’ and choose your desired token from the list. Each LP token corresponds with a different pool. The names of the tokens indicate what component tokens they have exposure to. ![](https://cdn-images-1.medium.com/max/1600/0*JiEOYp0DlgCapNm_) Lastly, complete the swap for your desired LP token just like any other swap to transfer your liquidity into that pool. # Art of Shell NFTs A collection of unique art charting the Shell Protocol journey Art of Shell is [an NFT collection released in August 2022](https://shellprotocol.io/posts/art-of-shell-nft-release/) just before the Shell Protocol guarded launch, to commemorate the community's journey. Owners of an Art of Shell NFT received the 'Collector' role in the [Shell Discord](/getting-started/overview/community#discord). Ten percent of all proceeds from the initial sales were [donated to Sustainable Coastlines Hawaii](https://twitter.com/ShellProtocol/status/1565803303983755267), a charity specializing in ocean cleanup of sensitive Pacific ecosystems. View the art below or [check out the collection on OpenSea](https://opensea.io/collection/art-of-shell-arbitrum) to see if any are up for sale. ![](https://shellprotocol.io/static/img/1_ietdf-pnmshkkbbdl_rh9g-1.png) [**Welcome to Shell World**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/0) The first-ever drawing of Alice and Bob. Created to welcome users to Shell World and announce a call for new full-time team members. ![](https://shellprotocol.io/static/img/image2.png) [**Discovering Proteus**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/1) Alice and Bob discover the strange Proteus machine on the shoreline. Proteus himself looms in the clouds above. Created to mark the announcement of the Proteus AMM engine. ![](https://shellprotocol.io/static/img/image8.png) [**The Ocean Network**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/2) A vast network of enormous tower spans across a beautiful tropical landscape, connected with energy beams. Created to mark the announcement of the Ocean accounting system for Shell v2. ![](https://shellprotocol.io/static/img/image1.png) [**Reaching The Tower**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/3) Alice and Bob hike to the base of a huge, powerful Ocean tower above the clouds. Created to mark the announcement of the Ocean accounting system for Shell v2. ![](https://shellprotocol.io/static/img/image4.png) [**Undersea Network**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/4) Ocean technology runs along the seafloor of Shell World, creating a single network of unlimited potential. Created to mark the announcement of the Ocean accounting system for Shell v2. ![](https://shellprotocol.io/static/img/0_5K4g_lufT0HrtApg.png) [**Sea vs Shell**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/5) Alice and Bob face off in a heated discussion over the name and ticker of the future Shell Protocol governance token. Created to mark the announcement of the Sea vs. Shell event, the first-ever community vote. ![](https://shellprotocol.io/static/img/the-voyage-ahead.jpg) [**Toucan Picnic**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/6) Alice and Bob share colorful drinks, surrounded by playful toucans on a Shell World beach after a tiring hike. Created to commemorate the massive success of the Government Toucan mint on April 1, 2022. ![](https://shellprotocol.io/static/img/image5.png) [**Discovering the Accountant**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/7) Alice and Bob dive deep beneath the surface of the Ocean to discover the enigmatic Accountant below. Created to emphasize the potential of the Ocean accounting system in Shell v2. ![](https://shellprotocol.io/static/img/image11.png) [**Testnet Tower Hack**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/8) Alice and Bob scale the heights of a Shell World tower to access the Accountant's network. Created to mark the launch of the Shell v2 testnet. ![](https://shellprotocol.io/static/img/arbinaut.jpg) [**Arbinaut Landing**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/9) Bob shakes hands with an Arbinaut captain on a Shell World beach as toucans flock. Created to mark the announcement of Shell v2's deployment on Arbitrum mainnet. ![](https://shellprotocol.io/static/img/shell-world-eve-reveal-compress.jpg) [**Eve**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/10) The first-ever appearance of Eve, riding on her MEV bot swarm to seek fortune and cause mischief in Shell World. Created to mark the announcement of the MEV harnessing system for Shell v2. ![](https://shellprotocol.io/static/img/shell-world-illustration-alpha-fleet-compressed.jpg) [**The Alpha Fleet**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/11) Bob stands on a rocky cliff, waving a Shell World flag to call the Alpha Fleet into a harbor. Created to mark the announcement of the Alpha Fleet program for Shell Protocol partners. ![](https://shellprotocol.io/static/img/image7.png) [**Carnival Ride**](https://stratosnft.io/asset/0x7cfCbbD2AFDA3c656C909AA6bA9E372A1d2bA9A4/12) Alice and Bob laugh in the seats of a Shell World carnival ride, holding shimmering Shell Point tickets in hand. Created to mark the announcement of Shell Points on Shell v2. # Architecture Overview An overview of Shell's major components Shell's main smart contract is [the Ocean](/how-shell-works/the-ocean-accounting-hub), a simpler and more efficient home for composing DeFi operations. It is three things in one: a shared multi-token ledger, a standardized accounting framework for DeFi primitives, and a smarter system for composing primitives. The first primitive on Shell was [Proteus](/how-shell-works/proteus-amm-engine), a tool that can precisely implement any trading strategy, allowing concentrated liquidity with fungible LP tokens, as well as bonding curves that can evolve over time. As an AMM engine, it allows financial engineers to design custom AMMs without ever writing a line of Solidity code. The Proteus AMM Engine owes its flexibility to the fact that it was designed as a [Shell-native primitive](/getting-started/integrations/shell-native-primitives). In other words, the first set of AMMs released using Proteus were also the very first primitives on Shell. Although the Ocean is the main hub, Proteus is a major component of Shell Protocol because of its role in creating fungible LP tokens, which are fundamental building blocks not only in many DeFi applications, but also the future of money. # The Ocean: Accounting Hub An explanation of the Ocean architecture {% hint style="info" %} There is an upcoming addendum to the Ocean white paper, to detail modifications in Shell v3 (launched January 2023). {% endhint %} ## Quick Links * [Ocean GitHub](https://github.com/Shell-Protocol/Shell-Protocol) * Shell v2 [Ocean White Paper](https://shellprotocol.io/static/Ocean_-_Shell_v2_Part_2.pdf) (February 2022), [blog post](https://shellprotocol.io/posts/the-ocean/) ## Contents * [Introduction](#introduction) * [Composable Utopia](#composable-utopia) * [Key Insights for the Ocean](#key-insights-for-the-ocean) * [Insight #1: EVM Token Standards Are Broken](#insight-1-evm-token-standards-are-broken) * [Insight #2: All Primitives Speak the Same Accounting Language](#insight-2-all-primitives-speak-the-same-accounting-language) * [Insight #3: Transitory Updates Need Not be Saved to the Blockchain](#insight-3-transitory-updates-need-not-be-saved-to-the-blockchain) * [How the Ocean Works](#how-the-ocean-works) * [The Ocean Uses 3x Less Gas](#the-ocean-uses-3x-less-gas) * [Advantages of the Ocean](#advantages-of-the-ocean) ## Introduction Shell Protocol is a new paradigm that reimagines how to build and compose financial primitives like AMMs, lending pools, or algorithmic stablecoins. The key to this achievement is the Ocean, a new shared accounting system that reduces code complexity and costs up to four times less gas for multi-step transactions. To understand this revolution and what makes it possible, we first need to understand a bit about DeFi’s great ambition and its current limitations. ![](https://shellprotocol.io/static/img/ocean-illustration-3-compressed.jpg) ## Composable Utopia Financial primitives are the building blocks of DeFi. Often described as “money legos,” these simple components can be connected together (“composed”) into complex systems and transactions. Composability is perhaps the single most important feature of DeFi, opening the door to financial innovation. For example, consider this transaction: depositing ETH to mint DAI, then swapping DAI for USDC, which is then used as collateral to borrow more ETH. Good composability makes it easy for users to design and conduct transactions like this, unleashing creative and unexpected use cases. At least, that’s the promise. In reality, composing primitives is onerous. Typically, you have to interact with one primitive at a time, waiting idly for each successive transaction to get mined. Not only is this inconvenient and costs a lot of gas, it also means you can’t make atomic transactions (required for certain use cases like arbitrage trading). A few niche projects offer special-purpose smart contracts that help users compose certain types of primitives. For example, DEX aggregators such as 1inch let users split swaps through multiple AMMs in order to get the best rate, and InstaDapp lets users compose AMMs with lending pools in order to gain leverage. Solutions like this are a lot of work. They rely on large teams of developers to continuously build new “adapter” smart contracts every time a big, complicated primitive has to connect to another big, complicated primitive — to say nothing of connecting a third, fourth, or fifth primitive. This strategy is a bit like cable adapter kits: one adapter for USB, one for HDMI, one for Lightning, etc. A tangled web of adapters is better than nothing, but suboptimal compared to a universal standard such as USB-C. Why is this the status quo for DeFi and how can we improve it? ![](https://miro.medium.com/max/1400/0*vU5Qhvhw4WNNZcuN) ## Key Insights for the Ocean ### ***Insight #1: EVM Token Standards Are Broken*** Under the hood, every token is just a number on a ledger. When Alice “sends” a token to Bob, the token is simply subtracted from Alice’s balance and added to Bob’s balance. However, most token ledgers currently exist in a dedicated smart contract. This is like having a separate database for every token! Intuitively, it would be much simpler to have one database, one ledger, for all tokens. Moreover, consider that every time a user invokes a new smart contract, they have to pay a fixed cost of 2,600 gas. This adds up! If all tokens lived in the same smart contract, it would not only be a major simplification of the token architecture — it would also significantly reduce gas costs. ### ***Insight #2: All Primitives Speak the Same Accounting Language*** From a token ledger’s perspective, all DeFi primitives follow the same pattern: They take one token as input and give another token as output. For example, when swapping DAI for USDC, an AMM primitive will take DAI as input and return USDC as output. When staking collateral to mint an algorithmic stablecoin, the primitive will take the collateral as input and mint new stablecoins as output. From the token ledger’s perspective, the accounting logic is always the same. The input token is added to the primitive’s balance and subtracted from the user’s balance, and vice versa for the output token. The ledger can treat the primitive like a black box, unconcerned with what happens inside. Why should DeFi protocols each deploy their own accounting logic when they could just share a standardized accounting framework? In other words — why don’t we have a “USB-C” equivalent for DeFi? ### ***Insight #3: Transitory Updates Need Not be Saved to the Blockchain*** When composing multiple primitives, you inevitably add and subtract a lot of input and output numbers. However, many of these balance updates may be transitory, meaning they simply cancel out by the end of the transaction. For example, consider a two-step swap from DAI to USDC, then USDC to USDT. At the end of the final swap, you won’t be left with any USDC, so your balance on the USDC ledger should remain zero. The Ethereum Virtual Machine (EVM) is like a computer that has the equivalent of a hard drive, referred to as “storage.” When smart contracts save data to storage, it’s expensive because it is replicated in thousands of computers around the world to live on the blockchain *forever*. A “storage write” can cost between 5,000 to 20,000 gas. Thankfully, the EVM also has the equivalent of RAM, referred to as “memory.” Saving data to memory is much cheaper because at the end of the transaction, the data in memory is erased. Writing data to memory can cost as little as 3 gas! We would save a lot of gas by tracking transitory balance updates in memory instead of storage. ## How the Ocean Works The Ocean synthesizes these three insights into a single smart contract, acting as a conduit between users, tokens, and primitives (see Figure 1). In particular, the Ocean: * Has a single ERC-1155 ledger for all tokens * Uses a standardized accounting framework for all primitives * Tracks intermediate balance updates in memory instead of storage As a ledger, the Ocean can support all major token types: ERC-20, ERC-721 and ERC-1155. Old tokens can be wrapped into the Ocean’s ledger, and new tokens can be created natively on the ledger. As an accounting system, the Ocean can support any primitive type: AMMs, lending pools, algorithmic stablecoins, NFT markets, and even primitives yet to be invented. Primitives that are built using the Ocean’s framework (i.e., Ocean-native primitives) will be much simpler than older DeFi primitives because they only need to compute input and output tokens; all accounting logic is outsourced to the Ocean. ![Figure 1: Complete architecture diagram of the Ocean](https://miro.medium.com/max/1400/0*ZwcTn8hFcSGaSpZI) To compose primitives, the user simply sends a list of primitive interactions to the Ocean. For each interaction, the user specifies: * The targeted primitive * The input token * The output token * The input amount The Ocean queries each primitive, asking it to compute the output amount. The Ocean then directly updates both the user’s and the primitives’ balances on its ledger, either in memory or storage where appropriate. If the user wants to wrap or unwrap external tokens, they can do so using the same framework. ## The Ocean Uses 3x Less Gas The Ocean provides substantial gas savings when composing primitives. In fact, the more primitives being composed, the more gas the Ocean saves. As can be seen in Figure 2, the marginal cost of interacting with a primitive on the Ocean is 27 thousand gas. In other words, if you’re already interacting with a few primitives, it only costs 27 thousand gas to add just one more. That is over 4x lower than interacting with primitives one at a time. Because the Ocean’s marginal cost is so low, after 10 primitive interactions, the total cost of transacting on the Ocean is 3x lower than alternatives (see Figure 3). ![Figure 2: Comparison of marginal gas costs with and without the Ocean](https://miro.medium.com/max/1400/0*0XjCPsrdrJ8pkVZ7) ![Figure 3: Comparison of total gas costs with and without the Ocean](https://shellprotocol.io/static/img/blog-chart-1.png) ## Advantages of the Ocean Even beyond gas savings, the Ocean has several advantages. For one thing, developer teams previously had to write custom contracts in order to atomically compose DeFi primitives. Now any Web3 developer can accomplish this — no Solidity necessary! But the biggest beneficiaries of the Ocean may be the primitives themselves. The more primitives that join the ecosystem, the more options for composability, and the more each individual primitive benefits. This creates a positive network effect for the whole ecosystem. ![](https://miro.medium.com/max/1400/0*x7Q0DuXnVHHKNjbF) # Proteus: AMM Engine An explanation of the Proteus design ## Quick Links * [Proteus GitHub](https://github.com/Shell-Protocol/Shell-Protocol). * [Desmos demo of the Proteus algorithm](https://www.desmos.com/calculator/0rq42rdkec). * [How to build an AMM with Proteus](https://docs.shellprotocol.io/tutorials/build-an-amm-with-proteus). * [Evolving Proteus blog post](https://shellprotocol.io/posts/introducing-evolving-proteus/) * [Paper 3 (November 2022)](https://shell-protocol.notion.site/Proteus-AMM-Engine-Update-3-7f33b7e1561347b696874a8ba02b9782), [blog post](https://shellprotocol.io/posts/shell-launches-proteus-amm-engine/) * [Paper 2 (September 2022)](https://github.com/cowri/Proteus/blob/main/Proteus_white_paper_UPDATED.pdf) \[past iteration] * [Paper 1 (October 2021)](https://shellprotocol.io/static/Proteus_AMM_Engine_-_Shell_v2_Part_1.pdf) \[past iteration], [blog post](https://shellprotocol.io/posts/proteus-amm-engine/) ## Contents * [Introduction](#introduction) * [Capital Efficiency](#capital-efficiency) * [User Experience](#user-experience) * [Evolving Proteus](#history-of-proteus) * [History of Proteus](#history-of-proteus) ## Introduction Off the island of Pharos, an old sea god lives among the waves. He is primordial, more ancient than man, and his power of endless self-transformation is as vast as the ocean. We hope he finds here an appropriate homage. The Proteus AMM engine is a tool that allows developers to create liquidity pools with custom bonding curves. Like its namesake, Proteus is incredibly flexible, enabling concentrated liquidity with fungible LP tokens. Proteus is the next step in the evolution of AMMs. It’s simultaneously more capital efficient than Uniswap v3 AND more user-friendly than Uniswap v2. It can offer excellent swap rates with [only a fraction of the liquidity](https://twitter.com/ShellProtocol/status/1597393613037907968?s=20\&t=TlMoDHnsq6eQm4CiYwP9sg) of its competitors. How is this possible? ![“Then spake Proteus, great Naiad, and seas churned beneath his mutable form.” — Sir Edmund Hale](https://shellprotocol.io/static/img/proteus-logo-full.jpg) ## Capital Efficiency An AMM, short for automated market maker, is an algorithm that takes your tokens and trades them on your behalf. For it to work, you must first tell the algorithm how much to trade in a given price bucket. For example, you could tell the AMM to trade 10 ETH when the price ranges from $1,400 to $1,600, and trade another 10 ETH when the price ranges from $1,600 to $2,000. Overall, liquidity will be more concentrated in the $1,400-$1,600 range and less concentrated in the $1,600-$2,000 range. The more precision you have in setting these price buckets and the more price buckets you have, the better the AMM will be at making trades and the more money it will make for you. You can think of price buckets as pixels on a television screen. The more pixels you have, the better the image quality. Would you want a clunky TV from 2005, or an ultra-high-resolution 4K TV from the 2020s? This is where the advantage in capital efficiency of Proteus takes shape, versus Uniswap v3. Proteus has much higher precision, and can support more price buckets than Uni v3. Consider the DAI+USDC pool on Uniswap. Virtually all of its liquidity is concentrated between 0.9998 and 1.0002. Due to the constraints of the algorithm, it’s hard for LPs (liquidity providers) to do much better than this when using Uniswap. This is because the smallest possible price range for a bucket is 0.0001. Additionally, if you want to add more price buckets, each bucket requires minting a new non-fungible LP token, which is neither cost-effective nor convenient. ![Fig. 1: The only viable LP strategy on Uniswap v3 for a DAI+USDC pool is to deposit in the range of 0.9998–1.0002.](https://cdn-images-1.medium.com/max/1600/0*JF_Kef2aMgUaUXWC) When we look at a histogram of the DAI/USDC exchange rate over the past year, it's clear that there is a lot of precision Uniswap v3 isn’t capturing. If you can find a way to match the price buckets to the data, you ought to be able to improve the performance of the AMM. ![Fig. 2: Histogram of DAI+USDC price history over most of 2022.](https://cdn-images-1.medium.com/max/1600/0*EDhNFANYX3oH8f0V) Enter Proteus. Unlike Uniswap, Proteus has practically no limit to its precision (the parameters for our first pool are specified up to the tenth decimal place). Additionally, the entire distribution can be encapsulated in a **fungible token**, with no need to mint multiple NFTs. The figure below shows the approximate liquidity concentration of the first deployed Proteus pool, [DAI+USDC](/getting-started/integrations/shell-native-primitives/stable-token-amms). Notice how it corresponds to the price histogram? This precision unlocks a new level of performance. To put it another way, Proteus lets us trade in 4K, better mapping our price curve to the intricacies of the market. ![Fig. 3: Approximate liquidity concentration of the Proteus DAI+USDC pool](https://cdn-images-1.medium.com/max/1600/0*C6i7nrZyaFfIEz3G) ## User Experience But, surely this level of trading performance comes at the expense of usability? Surely Proteus pools are only for the most elite financial engineers? Nope. In addition to being more flexible and precise, Proteus is even more user friendly than Uniswap v2 (never mind v3). If you want to LP into a Uniswap v2 pool, you must have equal amounts of each reserve token. If you don’t, you’ll have to swap for the correct amounts before you LP. Proteus lets you LP with only one token, or two (they don’t even have to be equal amounts). This is known as single-sided liquidity provision. If you want to migrate your funds from one Uni v2 pool to another Uni v2 pool, you first need to make a withdrawal. After that, you must swap (possibly twice) to get the correct ratio. Only after all this, two-to-three separate transactions in total, can you LP into the new pool. With Proteus, migrating LP funds is literally as simple as doing a single swap. ![Fig. 4: Providing liquidity with Shell. It’s that simple.](https://cdn-images-1.medium.com/max/1600/0*ruKRY7hOO3FuZsS9) How is Proteus so easy to use? Under the hood, Proteus is built on the Ocean, Shell’s composability layer. Moving tokens across the Ocean is seamless and gas efficient. ([Read more about the Ocean and its capabilities here.](/how-shell-works/the-ocean-accounting-hub)) ## Evolving Proteus Evolving Proteus is the version of Proteus that can create liquidity concentration that changes shape over time. This lets anyone create pools that shift their liquidity to follow the current exchange rate, in turn capturing more trade volume and providing more utility. It can also be used to sell off tokens or NFTs with a Dutch auction style mechanism. This second method can be used for liquidity bootstrapping, and to help whales move large quantities of tokens without sudden price disruption. Blockchain-based AMMs have never been able to compete with trading rates offered in TradFi, simply because blockchains are slower, always a step behind real-world prices. It has always been an industry-wide existential challenge to make AMMs competitive in this domain. Evolving Proteus takes us a step closer to this goal, enabling broad innovation in the creation of new market-tracking curves. These curves can change dynamically according to innovative signals of price movement, while retaining customized liquidity concentration with high precision. Beyond this, Evolving Proteus will enable fairer and more efficient token launches, including NFT launches. With the popularity of blockchain-based games, which use large NFT collections, customizable NFT launches will be more important than ever. Further, as the industry grows more robust, more institutions will be brought on-chain, requiring better resources for secure operations dealing with large trades. Evolving Proteus is one more tool that raises the bar for handling such operations. ## History of Proteus In 2021, the Shell team [unveiled a proof of concept](https://shellprotocol.io/posts/proteus-amm-engine/) for an “automated market maker engine” that could precisely replicate any bonding curve. Just as a video game graphics engine lets game designers build more powerful video games, Proteus would let financial engineers design more powerful AMMs. The purpose of Proteus is not to create the most capital efficient AMM per se. The purpose is to build an AMM engine that that can implement *any* trading strategy. That way, financial engineers can design trading strategies without ever having to write a line of Solidity code. An operating system is an abstraction layer between application developers and a computer’s hardware. Proteus’ AMM engine is an abstraction layer between financial engineers and the Ethereum Virtual Machine. How is this possible? An AMM’s trading strategy is determined by the shape of its bonding curve. For example, a flat bonding curve has highly concentrated liquidity, while one with high curvature has diffuse liquidity. Proteus uses a bonding curve algorithm based on multiple curve segments stitched together in a composite function. This allows the algorithm to replicate virtually any curve, any trading strategy. While it may seem complicated, the algorithm is based on mathematics you could teach to a high school student. ![](https://miro.medium.com/max/1400/1*kB4f7V-Z3ZuEFL7rMNFV_Q.png) # Intents (MEV Harnessing System) Shell opens new possibilities for fighting MEV {% hint style="info" %} The MEV system described in this article is now commonly known as an "intents" framework. Shell has an intent-centric design. All projects on Shell will natively support intents once the system is released. {% endhint %} ## Contents * [Introduction](#introduction) * [Maximum Extractable Value (MEV)](#maximum-extractable-value) * [A Basic Sandwich Attack](#a-basic-sandwich-attack) * [Slippage-Protected Trades](#slippage-protected-trades) * [Complex Atomic Transactions](#complex-atomic-transactions) * [Harnessing MEV](#harnessing-mev) ## Introduction This article explains the mechanics and game theory behind the upcoming MEV harnessing system. It does not dive deeply into details on technical implementation, which will be explored in a forthcoming white paper. ## Maximum Extractable Value (MEV) What if you could turn MEV bots from frontrunning nuisances into blockchain navigators competing to complete your trade with optimal efficiency? With the new MEV harnessing system in Shell, it happens automatically with every trade. How? To understand what makes this method work, we need to lay out a few things about MEV. [MEV](https://ethereum.org/en/developers/docs/mev/), short for ‘maximal extractable value,’ occurs when a block producer strategically orders transactions to extract value from the ecosystem. (See another overview from Paradigm Research [here]().) In some cases, MEV can be a good thing, making DeFi more efficient. For example, arbitrage bots keep DEX prices aligned with each other. Additionally, liquidator bots help protocols such as Maker or Aave stay over-collateralized. However, some types of MEV exploitation can be rather pernicious. One particularly common example is the act of frontrunning. Before users’ transactions get added to a block, they sit in the mempool. This means that frontrunning bots can view your trades before they happen. Using this information, these bots can trade against you and take your money before your transaction is processed. Frontrunning has existed as a problem for markets since their inception. With the Ethereum blockchain, transactions are publicly viewable before they are added to a block. That means a potential front runner can see your transaction before it happens and immediately trade against you. There is no way to fix this problem without fundamentally changing how Ethereum works. Fortunately, with Shell, we don’t need to eliminate MEV. We can instead harness it, incentivizing MEV bots to execute trades on behalf of our users. With this change, MEV makes trades more efficient, not more expensive. The previously adversarial goals of transactors and block producers are now aligned. ## A Basic Sandwich Attack To understand how the harnessing system works, let’s first take a closer look at a typical sandwich attack. A form of MEV, sandwich attacks place exploitative bot transactions before and after a user’s transaction in the block. By manipulating prices, this ‘order sandwich’ causes the user to pay higher fees than she otherwise would. Say Alice wants to swap 100 DAI for USDC using a DEX. In a world without MEV, here’s what would happen: ![](https://cdn-images-1.medium.com/max/1600/0*jh0lpdH7wT1cZjYV) This is the basic idea of a blockchain transaction. In an adversarial environment, however, it’s not always that simple. In the next example, Eve is a frontrunner. She’s monitoring the mempool, and she sees Alice’s pending swap transaction before it gets ‘mined,’ or committed to the blockchain. With this knowledge, Eve decides to execute a sandwich attack, placing her own orders just before and after Alice’s transaction: ![](https://cdn-images-1.medium.com/max/1600/0*1W0ovG2OuN_KWf42) By swapping 1,000 DAI for USDC right before Alice’s trade, Eve moves the price balance between USDC and DAI in the trading pool. As a result, Alice’s trade is executed at a less favorable exchange rate than normal, causing her to receive less USDC than expected for her traded DAI. After this, Eve’s second transaction goes through, reversing Eve’s prior swap and capturing the DAI that Alice lost due to the temporary shift in exchange rate. ### Slippage-Protected Trades Generally, Alice can protect herself from sandwich attacks like these by using slippage protection. Slippage is the difference between the expected and actual cost of her trade. Slippage protection works by allowing Alice to specify the largest actual cost she’s willing to accept. Here’s an example of slippage protection in a submitted transaction: ![](https://cdn-images-1.medium.com/max/1600/0*I5RqfKFHpKqhuoxw) The ‘require’ statement in Alice’s transaction specifies the minimum amount of DAI she’s willing to accept in exchange for her USDC. In the example above, Alice requires that for every 1 DAI she trades, she must receive at least 0.99 USDC. If the threshold isn’t met, her trade does not execute. Thus, Eve has no reason to sandwich attack the trade, since manipulating the exchange rate would simply cause Alice’s transaction to cancel. This works for simple swaps. But what happens if Alice wants to execute a complex transaction, one which invokes many different financial primitives on the blockchain? With our MEV harnessing system, Shell provides an elegant solution. ## Complex Atomic Transactions To understand how it works, we need to go over some of the core mechanisms in Shell. Specifically, we need to look at [the Ocean](/how-shell-works/the-ocean-accounting-hub), Shell’s central accounting system. ![The Ocean seamlessly connects every contract in the Shell v2 ecosystem.](https://cdn-images-1.medium.com/max/1600/0*nGqsYzMPdJ56kJ-C) DeFi is made up of many independent smart contracts known as financial primitives. These can be tokens, exchanges, or anything else you can think of. Since each primitive is built in a different way, connecting them together for a big transaction can be hard and expensive. Shell makes this easier by providing a unified accounting layer known as the Ocean. When a primitive is built on top of the Ocean, developers can save time by allowing Shell to handle token balances, allowing the devs to focus solely on the financial model of their primitive. The end result is an easily scalable network of primitives with automatically linked and standardized accounting logic. This makes the prospect of complex, multi-primitive transactions way, way cheaper. It also allows these big transactions to be performed in a single block instead of multiple time-consuming and vulnerable steps. This saves a huge amount of gas, creating a new world of possibility for projects that utilize the potential of Shell’s complex transactions. But let’s talk about how the Ocean allows everyday traders to harness MEV for their own gain. Say, for example, that Alice wants to make a complex series of trades. She wants to swap DAI for USDC, then USDC for ETH, then use ETH to purchase an NFT. Without Shell v2, Alice would have to conduct these trades across multiple transactions, each one of which would be vulnerable to MEV exploitation. Here’s how her transactions might look without Shell v2: ![](https://cdn-images-1.medium.com/max/1600/0*7VZvicg5C7VdBsUz) At each step of this transaction, Alice has to worry about MEV. That means she needs to set slippage protection parameters for every trade. The more trades she has to do, the harder it is to know the appropriate level of protection, because the price of early trades will have downstream effects on the price of later trades. Shell can dramatically simplify slippage protection for complex transactions like the one above. Instead of protecting each step individually, Alice can check to make sure that the input (DAI) and the output (NFT) are what she was expecting. Shell makes this possible because it seamlessly bundles multi-step transactions and can check the net changes to Alice’s DAI and NFT balances. ![](https://cdn-images-1.medium.com/max/1600/0*w14oAyuNzcSwdCfi) With only two checks, one for DAI and one for the NFT, Alice can protect her entire transaction against frontrunning — no matter how complicated the intermediate steps might be. With the right user interface, this example case can appear to a user as one seamless step, allowing traders on a marketplace to purchase NFTs with any supported denomination of fungible token they like. Under the hood, it’s one transaction, meaning there’s no opportunity for hostile actors to ‘inject’ exploitative transactions in between the steps. Because Shell’s Ocean contract supports any type of DeFi primitive, this single-transaction schema can be extended to encompass AMMs, lending pools, and even primitives yet to be invented. So MEV is solved, right? GG, EZ. We saved the ecosystem… …but we can do even better. ## Harnessing MEV Although we can now write simple balance checks to limit the value extracted by frontrunners, we haven’t fundamentally changed Eve’s incentives. She and her bot army are still out there, watching and waiting for Alice to make a mistake. Whenever the bounty looks good enough, she’ll pounce. But, what if there was a way to harness Eve’s incredible talent and ambition for the purpose of good? With some clever cryptography, it turns out that Alice can completely realign Eve’s incentives to the point where Alice herself doesn’t even need to execute the trade. Instead, Eve will execute it for her, as efficiently as she possibly can. How is this possible? Right now, our transaction-writing paradigm begins with a transaction path, then includes appropriate checks to make sure Alice doesn’t get ‘ripped off’ in the process. But, what are we actually trying to accomplish here? Alice wants a specific NFT, and she wants to spend DAI to buy it — even though the NFT sale contract trades in ETH. As long as she spends what she has and gets what she wants, she’s happy. The steps her tokens take to get there don’t need to be set in stone. ![With the right touch, Alice can harness the incredible power of the Ocean Accountant.](https://cdn-images-1.medium.com/max/1600/0*-B-t-jlZxW47i4M0) So, let’s flip things around. Instead of starting with a path, Alice writes a transaction stating that she wants to spend 100 DAI to purchase a specific NFT. Alice can then sign the message, telling Shell’s Ocean Accountant that she will accept any transaction path which meets these specifications. You can think of Alice’s signed transaction as a job posting, a bounty open to any intrepid Ocean navigator. She’s willing to spend 100 DAI as long as she ends up with the NFT she wants. Anyone, including Eve, can submit a transaction that fulfills it. If Eve finds an even more efficient path, she gets to keep the difference in DAI as profit. Here’s an example. ![](https://cdn-images-1.medium.com/max/1600/0*XCRkG21nMQQyjm2v) In the above case, Alice wrote and signed a transaction offering to spend 100 DAI in exchange for a specific NFT. Eve, seeing Alice’s offer, plotted a path to complete the trade with high efficiency, routing Alice’s DAI through multiple stablecoin pools to reduce the slippage cost. Why would Eve help Alice? It’s because she gets to keep the change on Alice’s 100 DAI. After buying the NFT, Eve’s transaction delivers it to Alice, keeping the saved 1.00 DAI as compensation for her efforts. Even better, Alice’s price is all-inclusive. Eve handles the gas, and Alice doesn’t have to worry about spending anything past her 100 DAI budget. Eve not only found a valid path through the Shell v2 network, she actually found a more efficient path than Alice’s original plan. With this system, Alice doesn’t have to worry about figuring out trade paths. She posts her bid as a signed transaction, then waits for Eve or someone like her to fulfill it. Eve, meanwhile, gets to focus on doing what she does best — using her considerable powers to find arbitrage opportunities. She’s no longer waiting for Alice to make a mistake. Instead, she’s competing to fulfill Alice’s bid, earning more and more the better she gets at efficient routing. The former frontrunner is now the executor of Alice’s trade. Alice signs an offer transaction and Eve fulfills it. The incentives are aligned, and the on-chain actors are able to specialize symbiotically according to their skills. A bandit is now a bodyguard. Eve is Alice’s protector, her navigator-for-hire. ![Alice and Bob are ready to explore the Shell World for fun and adventure.](https://cdn-images-1.medium.com/max/1600/0*NaMQFakzR0j4DSag) This innovation is even bigger than it sounds. For every individual offer transaction, of course, Eve’s incentive is to find the most efficient possible path. That much is clear. Now, what about when a block contains a multitude of offer transactions? Say Eve is the block producer here. Not only will she find the best swap routing paths, she will also find the best transaction order. Eve controls every aspect she can to bring trade costs down, maximizing her profits and increasing the efficiency of the system. # Why Arbitrum A discussion of Shell's first L2 home {% hint style="warning" %} Shell v3 now has deployments on several chains and L2s besides Arbitrum. This article dates from the launch on Arbitrum. {% endhint %} Shell v3 was initially deployed on [Arbitrum One](https://arbitrum.io/), an Ethereum rollup. Long before the protocol launch, [the Government Toucans were launched](https://shellprotocol.io/posts/launching-our-government-toucan/) on Arbitrum, and Shell had undergone a successful trial period with the [testnet on Arbitrum Rinkeby](https://shellprotocol.io/posts/shell-v2-testnet-release/). In other words, this was a careful and long-considered decision. Why not deploy on Ethereum mainnet? Well, a lot has changed since [Shell v1 ](/how-shell-works/shell-v1-retired)was first deployed there. Layer 2s (L2s) have matured significantly as a sector, and rising usage of Ethereum mainnet has pushed gas fees consistently upward over time, the current bear market notwithstanding. Why an L2 over a sidechain? Two reasons. First, Ethereum is the most mature from a security standpoint. There is no substitute for longevity when it comes to assessing security risk. Second, Ethereum is where nearly two-thirds of the assets in web3 are located at the time of writing. Therefore, other L1s have to bridge assets from Ethereum to their chain. Even if these sidechains are secure, oftentimes their Ethereum bridges are not. As of writing, over $1 billion has been stolen from bridges already. L2s solve both problems. Because they are built directly on top of Ethereum’s L1, they inherit Ethereum’s security. Furthermore, bridging between an L1 and an L2 is far more reliable than bridging between Ethereum and a sidechain. From another perspective, it makes sense to combine Shell and Arbitrum’s gas-saving effects to deliver as much efficiency as possible. Our goal with Shell Protocol is to connect web3 projects in one large network, making it simpler and more affordable to batch complex transactions. It makes sense to combine Shell’s composability with Arbitrum’s gas savings. Not to mention, Arbitrum has extremely low latency, giving our desktop app a smooth user experience. This in turn increases our attractiveness to users and builders, helping bootstrap the development of the Shell ecosystem. We see Ethereum, Arbitrum, and Shell together as an ideal ‘dev stack’ for the smart contract deployments of the future. With Ethereum’s security, Arbitrum’s cost efficiency, and Shell’s networked composability, our builders are ideally positioned to rise to the top of the next wave of DeFi.

The ideal dev stack

Now, why Arbitrum in particular? If we’re looking for a rollup on which to deploy Shell, the leading options are either optimistic or zero-knowledge proof rollups. While both systems have merit, optimistic rollups appear as the more developed and mature of the two. At this point, the field grows slim, and Arbitrum is certainly a sector leader in the field of optimistic rollups for Ethereum. The Shell team was initially drawn to the Arbitrum project because of its longevity, development ethos, and unique approach to multi-round fraud proofs. But the team behind Arbitrum is also a group of people committed to nurturing a diverse ecosystem of bold, independent developers. In short, it's an excellent home for Shell Protocol. # Shell v1 (Retired) A discussion of the earliest iteration of Shell Protocol ## Quick Links * [Guide to migrate funds from Shell v1](/user-guide/migrate-from-shell-v1-retired) * [Shell v1 white paper](https://github.com/cowri/shell-solidity-v1/blob/master/Shell_White_Paper_v1.0.pdf) ## Contents * [Introduction](#introduction) * [Shell v1 overview](#shell-v1-overview) * [Flexible curves](#flexible-curves) * [Security](#security) * [Vision](#vision) ## Introduction In October of 2020, Shell Protocol [launched](https://medium.com/shell-protocol/shell-protocol-launches-first-stablecoin-pool-f874d383d25e) its first-ever AMM pools on Ethereum mainnet, known as Shell v1. They were a novel approach to a particular set of problems, offering deep liquidity and (presciently) broken peg protection for like-value tokens (such as stablecoin-stablecoin or wrapped BTC-wrapped BTC). Unfortunately Shell v1 was unique in offering broken peg protection, otherwise more protocols may have been able to mitigate damage caused by the great stablecoin crash of 2021. A visionary product in many ways, Shell v1 also contained the seeds of an ambition for a composable liquidity network — an ambition now borne out by its v2 and v3 successors. As such, after nearly two years of active life, Shell v1 transitioned into a graceful retirement. The Shell team has no immediate plans to disable access to Shell v1 or its app interface. After all, nothing ever really disappears on the blockchain. However, the time has definitely come for LPs in Shell v1 to [withdraw their funds and transition to the next iteration of Shell Protocol](/user-guide/migrate-from-shell-v1-retired). If you would like to dive in to the architecture, check out the [Shell v1 white paper.](https://github.com/cowri/shell-solidity-v1/blob/master/Shell_White_Paper_v1.0.pdf) For a brief overview, continue below. ## Shell v1 overview Shell v1 pools had five features worth emphasizing: 1. Deep stablecoin liquidity 2. Reserve weights 3. Protections against a broken peg 4. Dynamic fees 5. Interoperability with aTokens and cTokens These five features incorporated facets of several DeFi protocols: [Curve](https://www.curve.fi/), [Balancer](https://balancer.finance/), [mStable](https://mstable.org/) and [Mooniswap](https://mooniswap.exchange/#/swap). Like Curve, Shell v1 could facilitate large stablecoin-to-stablecoin trades with minimal slippage. Like Balancer, Shell pools could have weights. [For example, the maiden pool had target weights of 30% DAI, 30% USDC, 30% USDT and 10% SUSD.](#user-content-fn-1)[^1] Similar to mStable, Shell pools had minimum and maximum allocations for each stablecoin. For example, the pool must always have between 3% and 57% of a given stablecoin. This ensured that if a reserve permanently loses its peg, liquidity providers won’t lose all of their capital. Without these protections, a single broken peg could drain the entire pool as traders swap the worthless stablecoin into the pool and take out the viable stablecoins. [This will continue until there is no value left.](#user-content-fn-2)[^2] Therefore, the more stablecoins added to a pool, the riskier it gets because the more likely it is for a stablecoin to de-peg. That is why Shell v1 pools had safeguards. In addition to charging a fixed fee on every swap, Shell v1 pools charged a dynamic fee that increased in proportion with the pool’s slippage. The more a stablecoin deviated from its peg, the higher the fee assessed by the pool. This is a mechanic that is similar to Mooniswap’s dynamic fee. Dynamic fees redistribute profits form arbitrage traders to liquidity providers. Not only could Shell v1 facilitate trades between stablecoins, it could also facilitate direct trades between [Aave](https://aave.com/) and [Compound](https://compound.finance/). For example, you could trade between aUSDC and cUSDT. Therefore, moving funds between lending pools on Shell v1 did not require [ZapperFi](https://zapper.fi/). ## **Flexible curves** The best part about Shell v1 was its flexibility. Each of these behaviors could be fine-tuned by adjusting parameters, and these parameters could be changed dynamically post-deployment. This allowed Shell v1 pools to adapt to new use cases and market conditions. The ultimate goal was to create an "operating system" for stablecoin liquidity pools that could implement arbitrary stablecoin AMMs.

A “standard” Shell v1 bonding curve for an evenly weighted pool. The shape of the curve determines the AMM’s behavior. Each point along the line (A, B, C, D, E) can be set by parameters, making the curve highly adaptable.

## **Security** Shell v1 underwent two separate [audits](/getting-started/security-and-bounties#legacy-audits-shell-v1) from Consensys Diligence and ABDK. From the time of its launch until its retirement almost two years later, Shell v1 has been live on mainnet without a security breach, while remaining in the top 25 DEXs on Ethereum by TVL. However, as always, this is no guarantee of security and Shell's liquidity providers were always encouraged to exercise caution. Shell v1 is now retired and any Shell v1 LPs should immediately [withdraw their funds and transition to Shell v2](/user-guide/migrate-from-shell-v1-retired). ## **Vision** Shell v1 was more than just an AMM protocol. The vision was to use stablecoins as building blocks to create an internet monetary system: a borderless, programmable medium of exchange accessible to all. Ultimately, this is the dream that led to the [current iteration of Shell Protocol](/how-shell-works/architecture-overview). [^1]: check this [^2]: Great opportunity to point out the real life situations where this happened # ShellDrop DAO (Retired) Administering external airdrops to the Shell community ## Community Treasury The sole purpose of the [ShellDrop DAO](https://snapshot.org/#/shelldrop.eth) is to serve as a treasury to administer airdrops from other projects to the Shell community. Votes are conducted on Snapshot. Anyone holding at least ten Government Toucans is eligible to make a proposal that other members can vote on. This DAO is available for any drops occurring after its launch on March 22, 2023. The treasury wallet is a Gnosis Safe 3/5 multi-signature wallet. Snapshot: `ShellDrop MultiSig:` [`0xe29fE11Fa4a6f04A6c582D75A71B0B795A3b9A87`](https://arbiscan.io/address/0xe29fE11Fa4a6f04A6c582D75A71B0B795A3b9A87) # Hidden Fortune Treasure and intrigue in Shell World For months now, there have been [rumors of hidden fortune](https://shellprotocol.io/posts/rumors-of-hidden-fortune/). In a [Shell Discord](/getting-started/overview/community#discord) channel known as #shell-treasure, messages of uncertain origin have appeared. Posted documents discuss a mysterious point in space and a coming ascendance. A symbol appears throughout — the seekers’ mark. * 17 March 2022: [End of first sequence](https://twitter.com/jb_office1/status/1504680476325281796) * 24 March 2022: [Sequence II cache](https://etherscan.io/nft/0x8cc3740191502735da4e5a28217a685f3bcf1d70/0) * 21 June 2022: [Sequence III announced](https://twitter.com/jb_office1/status/1539477275787137024) Shell partners at the I.R.E.G. have buried, concealed, and otherwise secreted away digital and material clues leading to various caches in the form of wallet private keys. Find the key, and the corresponding wallet is yours. ![](https://miro.medium.com/max/1400/1*sfH5rRDUPzMFHWvISutVmQ.png)