# Insula Investment Management Technical Decentralised Whitepaper > A fully crypto asset manager. > Designed exclusively for professional investors. > At STATION F & in the City. Insulα is a quantitative investment manager that provides accredited investors with an exposure to the cryptocurrency investment universe. "Insula Deccentralized Autonomous Corporation operates in the framework of its own unregulated free-market economy" [Visualise Insula Tokens live statistics on their native Ethereum blockchain](https://bloxy.info/tokens?blockchain_id=1&q=insula) # Welcome to the Insula Blockchain Ecosystem. •Insulα Investment Management ™ is a decentralized autonomous corporation. It is an employee owned, fully automated crypto-only long/short hedge fund boutique based in London. •We are focused on portfolio diversification and limited supply cryptoassets on the electronic crypto-market universe. •We deliver continuous active returns and a core crypto market exposure by building  a portfolio made of hundreds of cryptocurrencies rebalanced on a high frequency/low latency basis. •Insula's key attributes are highly sophisticated algorithms, and very short-term investment horizons on and off-chain.   •Our investment philosophy is characterised by high turnover rates, and high order-to-trade ratios that leverages high-frequency financial data and short term electronic trading tools.   A new decentralised approach to institutional digital asset management. > *Insula, a Decentralised Finance (DeFi) Company.* > ![](https://i.imgur.com/plqswwP.png) > [color=#E21C21] [TOC] # Introduction > [(https://cotrader.com/#/fund/0xCB60D600160D005845Ec999f64266D5608fd8943](/e0Rk5AXRSYWEHRpr5auE6w) > > [(https://uniswap.exchange/swap/0x697ef32b4a3f5a4c39de1cb7563f24ca7bfc5947](/e0Rk5AXRSYWEHRpr5auE6w) > Uniswap is a protocol for automated token exchange on Ethereum. It is designed around ease-of-use, gas efficiency, censorship resistance, and zero rent extraction. It is useful for traders and functions particularily well as a component of other smart contracts which require guaranteed on-chain liquidity. Most exchanges maintain an order book and facilitate matches between buyers and sellers. Uniswap smart contracts hold liquidity reserves of various tokens, and trades are executed directly against these reserves. Prices are set automatically using the constant product ([`x*y=k`](https://ethresear.ch/t/improving-front-running-resistance-of-x-y-k-market-makers/1281)) market maker mechanism, which keeps overall reserves in relative equilibrium. Reserves are pooled between a network of liquidity providers who supply the system with tokens in exchange for a proportional share of transaction fees. An important feature of Uniswap is the utilization of a factory/registry contract that deploys a separate exchange contract for each ERC20 token. These exchange contracts each hold a reserve of ETH and their associated ERC20. This allows trades between the two based on relative supply. Exchange contracts are linked through the registry, allowing for direct ERC20 to ERC20 trades between any tokens using ETH as an itermediary. This document outlines the core mechanics and technical details for Uniswap. Some code is simplified for readability. Safety features such as overflow checks and purchase minimums are ommited. The full source code is availible on GitHub. **Welcome to Insulα DAO:** The decentralized place where Insula Token holders meet . InsulaDEXPools are decentralized liquidity pools that aim at stabilising the price of Insula Token. InsulaDAO is a toolbox for Insula Token holders  to interact with a continuous, decentralized and auditable liquidity on various Ethereum - based tokens, including Insula Token. InsulaDAO allows demand and supply for Insula Token to practically  meet via instantly settled on chain transactions, also called atomic swaps. We propose a series of smart contracts through which orders of our own corporate utility token (ISLA) can be funnelled, removing execution control from the users and putting it in the hands of complex systems of logic. Such a system allows tokens listed on InsulaDAO to have a limited exposure to: >1-front-running >2-transaction reordering >3-price-consensus instability # **Insula Token decentralised autonomous liquidity pools:** stake your Insula Tokens here >Set up : you need Metamask installed on Chrome Browser with a positive ETH  and ISLA balance. # Insula Token decentralised autonomous exchange >Set up : you need Metamask installed on Chrome Browser with a positive ETH and ISLA balance. # Insula Token decentralised autonomous payment rails >Set up : you need Metamask installed on Chrome Browser with a positive ETH and ISLA balance. > # Insula decentralised autonomous smart hedge fund   Set up : you need Metamask installed on Chrome Browser with a positive ETH and ISLA balance. # Management Fees Benchmark | Fund | Insula (FND) | Insula Elba(FND) | Insula Sark(FND) | |----------------------|---------|-------------|---------|------------------|---------------------|---------------------| | Management Fee | [0%](https://bloxy.info/portfolios/0xCB60D600160D005845Ec999f64266D5608fd8943) | [0%](https://bloxy.info/portfolios/0x9f73d7874aa731a6e3185e2fdc201a07c736f45b) | [0%](https://bloxy.info/portfolios/0x10603633e9a021b8dbc1f0ccb172178b07dfb1f4) | Performance Fee | [>0.01% %](https://etherscan.io/tx/0xc06aeb2b6794271c978b2d41b16ba0e75f80f55ab9160b21212d0d4eb918f6e1) | [30%](https://etherscan.io/tx/0x550961cbe81995c2300550b75654c75fb112fa5ba4a20ab7af1c02ed218af8e1) | | [30%](https://etherscan.io/tx/0x550961cbe81995c2300550b75654c75fb112fa5b| | [30%](https://etherscan.io/tx/0x550961cbe81995c2300550b75654c75fb112fa5ba # Insula decentralised autonomous smart relay liquidity tokens   # Insula decentralised autonomous hedge funds Insula hedge fund products Consult our first decentralised hedge fund performance below: **Insula Elba Fund :** >https://bloxy.info/portfolios/0xCB60D600160D005845Ec999f64266D5608fd8943 >https://cotrader.com/#/fund/0xCB60D600160D005845Ec999f64266D5608fd8943 >https://etherscan.io/token/0xcb60d600160d005845ec999f64266d5608fd8943 >https://etherscan.io/address/0xcb60d600160d005845ec999f64266d5608fd8943 ***Our hedge fund portfolio:*** **Traction** >5 decentralised  investors **Profit (Total)** >25% **Past 3 months yield:** >20% **Trading Frequency** >Low frequency algorithmic DEX PMS & OEMS.  **Current Development Status** >In Full Function **Business Status** >Decentralised Autonomous Fund (DAF)  **Currency** >Ethereum (ETH) **Liquidity** >Capital Withdrawable At Anytime **Performance Fee** >0.01% > **Management Fee** >0% **Custodian** >Ethereum Blockchain  >on-chain Custody. **Auditors** >Ethereum Blockchain *To interact with Insula's Smart fund in the windows below, please make sure you meet the set up requirement. Set up : you need Metamask installed on Chrome Browser with a positive ETH and ISLA balance.* **In the link below:** >Filter Funds >  > In Find fund by Name type “Insula” (Capital sensitive) >  > Click search icon on the right hand side >  > Click Fund Page [Click here to access Insula DEX FUND:](https://cotrader.com/#/fund/0xCB60D600160D005845Ec999f64266D5608fd8943) # Insula Token products Discover our upcoming improved trading infrastructure for Insula Token: [UniswapV2](https://uniswap.org/blog/uniswap-v2/) [Why are we running our trading operations on Uniswap?](https://cointelegraph.com/news/vitalik-proposes-solution-to-embarrassing-lack-of-bitcoinethereum-bridge) Our Insula Token product range allows investor to hold their Insula Tokens, hedged against Ethereum's dominance changes and the price fluctuations that result from these changes. ![](https://i.imgur.com/fV97mlq.png) Insula is listing on LAToken in February 2020 Insula Token's Initial Exchange Offering, and listing on LAToken (Top15 worldwide exchange) is planned for February 2020. ISLA/BTC, ISLA/ETH ISLA/USDT trading pairs will be added on LAToken markets following the sale of 200 000 Insula Tokens at a fixed rate of 1 ETH = 100 ISLA. **Traction** >265 unique holders >597 transfers >900 smart contract calls **Total fixed supply** >1,049,675.602077199999701949 ISLA **Liquidity** >Capital Withdrawable At Anytime **Management Fee** >0% **Total Trading Volume** >3.25M+ Insula Tokens moved on-chain **Defi Liquidity** >10+Decentralised Exchanges >on 100+ ETH Tokens >https://bloxy.info/token_trades/0x697ef32b4a3f5a4c39de1cb7563f24ca7bfc5947 **Custodian** >Ethereum Blockchain **Current Development Status** >In Full Function **Staking Daily Average Yield** >0.020% (est). **Exchange Listing** *On LA Token:* >(BTC/ISLA), (ETH/ISLA), (USDT/ISLA) Current network staking reward  >7% per annum for providing decentralised liquidity (est). **Auditors** >Insula's Distributed Ledger via Etherscan >https://etherscan.io/token/0x697ef32b4a3f5a4c39de1cb7563f24ca7bfc5947 **Legal Status** >Utility Token x **Our Decentralised capacity** We bring together systemic stability and price stability in one single investable asset:  Insula, the diversified and decentralised blockchain fund. Links to Insulas wrebsite DAO and DEX pools links Constituents of INSULA DAO: # INSULA DECENTRALISED AUTONOMOUS CORPORATION : AN OVERVIEW # InsulaDAO   <iframe frameborder="0" style="width:900px;height:1043px;" src="https://www.draw.io/?lightbox=1&highlight=0000ff&edit=_blank&layers=1&nav=1&title=Scaled%20Insula%20DAC%20final%20website%20embedded%20version%20.drawio#Uhttps%3A%2F%2Fdrive.google.com%2Fuc%3Fid%3D1f4yTLDB5GQ0EPKGt79B-NHfnrVWxfSnA%26export%3Ddownload"></iframe>) Please note: Insula Token (ISLA), is a cryptocurrency (a utility token). It is used in limited supply within Insula Blockchain Ecosystem.  Insula's present and future funds prototypes, or decentralised funds are strictly different products than Insula's cryptocurrency, that is an Ethereum ERC20 Token called Insula (ISLA). **General Uniswap Exchange Documentation:** >docs.uniswap.io **Insula Token's specific Uniswap Exchange address:** >docs.uniswap.io/ isla.. **Code:** >https://github.com/insula-investment-management/ >https://etherscan.io/token/0x697ef32b4a3f5a4c39de1cb7563f24ca7bfc5947 **Formalized Model:** >https://github.com/runtimeverification/verified-smart-contracts/blob/uniswap/uniswap/x-y-k.pdf) **Decentralised Trading Protocol Website:** >uniswap.io # Gas Benchmarks Uniswap is very gas efficient due to its minimalistic design. For ETH to ERC20 trades it uses almost 10x less gas than Bancor. It can perform ERC20 to ERC20 trades more efficiently than 0x, and has significant gas reductions when compared to on-chain order book exchanges, such as EtherDelta and IDEX. | Exchange | Uniswap | EtherDelta | Bancor | Radar Relay (0x) | IDEX | Airswap | |----------------------|---------|-------------|---------|------------------|---------------------|---------------------| | ETH to ERC20 | 46,000 | [108,000](https://etherscan.io/tx/0xb0d4330872132a808381bc709069e233c6f69f0bd4c4a4b87e2d40142866a0c7) | [440,000](https://etherscan.io/tx/0x462a3ad9dd05ce18cb33412fde02ee8cfa782d69a9df85be97ac8216a5c8b422) | [113,000](https://etherscan.io/tx/0xe2ca9f47926e2b262cf9b060f735c5ebfda1a4edd55af236d95b274c75be5449)* | [143,000](https://etherscan.io/tx/0xe2ca9f47926e2b262cf9b060f735c5ebfda1a4edd55af236d95b274c75be5449) | [90,000](https://etherscan.io/tx/0xccc10f160bde7779a35cda22f5d67532d0a4beaf76c9296f3d645ff1edf424ec) | | ERC20 to ETH | 60,000 | [93,000](https://etherscan.io/tx/0xc06aeb2b6794271c978b2d41b16ba0e75f80f55ab9160b21212d0d4eb918f6e1) | [403,000](https://etherscan.io/tx/0x550961cbe81995c2300550b75654c75fb112fa5ba4a20ab7af1c02ed218af8e1) | [113,000](https://etherscan.io/tx/0xe2ca9f47926e2b262cf9b060f735c5ebfda1a4edd55af236d95b274c75be5449)* | [143,000](https://etherscan.io/tx/0xe2ca9f47926e2b262cf9b060f735c5ebfda1a4edd55af236d95b274c75be5449) | [120,000](https://etherscan.io/tx/0xf4576e9cd6a598b50e8dec2c248049fa5cdc40d5994d185da70447d671094734)* | | ERC20 to ERC20 | 88,000 | no | [538,000](https://etherscan.io/tx/0x4f0595d122a2202022960d8c89773de206f4e4ab4da26336b68f1993691334b2) | [113,000](https://etherscan.io/tx/0xe2ca9f47926e2b262cf9b060f735c5ebfda1a4edd55af236d95b274c75be5449) | no| no| *wrapped ETH The cost of a direct ERC20 token transfer is 36,000 gas - approximately 20% less than an ETH to ERC20 trade on Uniswap. # Creating Exchanges [`uniswap_factory.vy`](https://github.com/Uniswap/contracts-vyper/blob/master/contracts/uniswap_factory.vy) is a smart contract that serves as both a factory and registry for Uniswap exchanges. The public function `createExchange()` allows any Ethereum user to deploy an exchange contract for any ERC20 that does not already have one. ```java exchangeTemplate: public(address) token_to_exchange: address[address] exchange_to_token: address[address] @public def __init__(template: address): self.exchangeTemplate = template @public def createExchange(token: address) -> address: assert self.token_to_exchange[token] == ZERO_ADDRESS new_exchange: address = create_with_code_of(self.exchangeTemplate) self.token_to_exchange[token] = new_exchange self.exchange_to_token[new_exchange] = token return new_exchange ``` A record of all tokens and their assoicated exchanges is stored in the factory. With either a token or exchange address, the functions `getExchange()` and `getToken()` can be used to look up the other. ```java @public @constant def getExchange(token: address) -> address: return self.token_to_exchange[token] @public @constant def getToken(exchange: address) -> address: return self.exchange_to_token[exchange] ``` The factory does not perform any checks on a token when launching an exchange contract, other than enforcing the one-exchange-per-token limit. Users and frontends should only interact with exchanges associated with tokens they trust. # ETH ⇄ ERC20 Trades Each exchange contract ([`uniswap_exchange.vy`](https://github.com/Uniswap/contracts-vyper/blob/master/contracts/uniswap_exchange.vy)) is associated with a single ERC20 token and holds a liquidity pool of both ETH and that token. The exchange rate between ETH and an ERC20 is based on the relative sizes of their liquidity pools within the contract. This is done by maintaining the relationship `eth_pool * token_pool = invariant`. This invariant is held constant during trades and only changes when liquidity is added or removed from the market. A simplified version of `ethToTokenSwap()`, the function for converting ETH to ERC20 tokens, is shown below: ```java eth_pool: uint256 token_pool: uint256 token: address(ERC20) @public @payable def ethToTokenSwap(): fee: uint256 = msg.value / 500 invariant: uint256 = self.eth_pool * self.token_pool new_eth_pool: uint256 = self.eth_pool + msg.value new_token_pool: uint256 = invariant / (new_eth_pool - fee) tokens_out: uint256 = self.token_pool - new_token_pool self.eth_pool = new_eth_pool self.token_pool = new_token_pool self.token.transfer(msg.sender, tokens_out) ``` :::info **Note:** For gas efficiency `eth_pool` and `token_pool` are not stored variables. They are found using `self.balance` and through an external call to `self.token.balanceOf(self)` ::: When ETH is sent to the function ```eth_pool``` increases. In order to maintain the relationship `eth_pool * token_pool = invariant`, `token pool` is decreased by a proporitonal amount. The amount by which `token_pool` is decreased is the amount of tokens purchased. This change in reserve ratio shifts the ETH to ERC20 exchange rate, incentivizing trades in the opposite direction. Exchanging tokens for ETH is done with the function `tokenToEthSwap()`: ```java @public def tokenToEthSwap(tokens_in: uint256): fee: uint256 = tokens_in / 500 invariant: uint256 = self.eth_pool * self.token_pool new_token_pool: uint256 = self.token_pool + tokens_in new_eth_pool: uint256 = self.invariant / (new_token_pool - fee) eth_out: uint256 = self.eth_pool - new_eth_pool self.eth_pool = new_eth_pool self.token_pool = new_token_pool self.token.transferFrom(msg.sender, self, tokens_out) send(msg.sender, eth_out) ``` This increases `token_pool` and decreases `eth_pool`, shifting the price in the opposite direction. An example ETH to ISLA purchase is shown below. --- ## Example: ETH → ISLA 10 ETH and 500 ISLA (ERC20) are deposited into a smart contract by liquidity providers. An invariant is automatically set such that `ETH_pool * ISLA_pool = invariant`. >[color=#E21C21] ETH_pool = 10 > > ISLA_pool = 500 > > invariant = 10 * 500 = 5000 > An ISLA buyer sends 1 ETH to the contract. A 0.25% fee is taken out for the liquidity providers, and the remaining 0.9975 ETH is added to `ETH_pool`. Next, the invariant is divided by the new amount of ETH in the liquidity pool to determine the new size of `ISLA_pool`. The remaining ISLA is sent to the buyer. >[color=#E21C21] Buyer sends: 1 ETH > >Fee = 1 ETH / 500 = 0.0025 ETH > > ETH_pool = 10 + 1 - 0.0025 = 10.9975 > > ISLA_pool = 5000/10.9975 = 454.65 > > Buyer receieves: 500 - 454.65 = 45.35 ISLA The fee is now added back into the liquidity pool, which acts as a payout to liquidity providers that is collected when liquidity is removed from the market. Since the fee is added after price calculation, the invariant increases slightly with every trade, making the system profitable for liquidity providers. In fact, what the invariant really represents is `ETH_pool * ISLA_pool` at the end of the previous trade. >[color=#E21C21] ETH_pool = 10.9975 + 0.0025 = 11 > > ISLA_pool = 454.65 > > new invariant = 11 * 454.65 = 5,001.15 In this case the buyer received a rate of 45.35 ISLA/ETH. However the price has shifted. If another buyer makes a trade in the same direction, they will get a slightly worse rate of ISLA/ETH. However, if a buyer makes a trade in the opposite direction they will get a slightly better ETH/ISLA rate. >[color=#E21C21] 1 ETH in > 44.5 ISLA out > Rate = 45.35 ISLA/ETH Purchases that are large relative to the total size of the liquidity pools will cause price slippage. In an active market, aribitrage will ensure that the price will not shift too far from that of other exchanges. ![](https://i.imgur.com/YNImnzt.png) # ERC20 ⇄ ERC20 Trades Since ETH is used as a common pair for all ERC20 tokens, it can be used as an intermediary for direct ERC20 to ERC20 swaps. For example, it is possible to convert from ISLA to ETH on one exchange and then from ETH to KNC on another within a single transaction. To convert from ISLA to KNC (for example), a buyer calls the function `tokenToTokenSwap()` on the ISLA exchange contract: ```java contract Factory(): def getExchange(token_addr: address) -> address: constant contract Exchange(): def ethToTokenTransfer(recipent: address) -> bool: modifying factory: Factory @public def tokenToTokenSwap(token_addr: address, tokens_sold: uint256): exchange: address = self.factory.getExchange(token_addr) fee: uint256 = tokens_sold / 500 invariant: uint256 = self.eth_pool * self.token_pool new_token_pool: uint256 = self.token_pool + tokens_sold new_eth_pool: uint256 = invariant / (new_token_pool - fee) eth_out: uint256 = self.eth_pool - new_eth_pool self.eth_pool = new_eth_pool self.token_pool = new_token_pool Exchange(exchange).ethToTokenTransfer(msg.sender, value=eth_out) ``` where `token_addr` is the address of KNC token and `tokens_sold` is the amount of ISLA being sold. This function first checks the factory to retreive the KNC exchange address. Next, the exchange converts the input ISLA to ETH. However instead of returning the purchased ETH to the buyer, the function instead calls the payable function `ethToTokenTransfer()` on the KNC exchange: ```java @public @payable def ethToTokenTransfer(recipent: address): fee: uint256 = msg.value / 500 invariant: uint256 = self.eth_pool * self.token_pool new_eth_pool: uint256 = self.eth_pool + msg.value new_token_pool: uint256 = invariant / (new_eth_pool - fee) tokens_out: uint256 = self.token_pool - new_token_pool self.eth_pool = new_eth_pool self.token_pool = new_token_pool self.invariant = new_eth_pool * new_token_pool self.token.transfer(recipent, tokens_out) ``` `ethToTokenTransfer()` receives the ETH and buyer address, verifies that the call is made from an exchange in the registry, converts the ETH to KNC, and forwards the KNC to the original buyer. `ethToTokenTransfer()` functions indentically to `ethToTokenSwap()` but has the additional input parameter `recipient: address`. This is used to forward purchased tokens to the original buyer instead of `msg.sender`, which in this case would be the exchange. ![](https://i.imgur.com/0yDILRq.png) # Swaps vs Transfers The functions `ethToTokenSwap()`, `tokenToEthSwap()` , and `tokenToTokenSwap()` return purchased tokens to the buyers address. The functions `ethToTokenTransfer()`, `tokenToEthTransfer()`, and `tokenToTokenTransfer()` allow buyers to make a trade and then immediately transfer purchased tokens to a recipient address. # Providing Liquidity ## Adding Liquidity Adding liquidity requires depositing an equivalent value of ETH and ERC20 tokens into the ERC20 token's associated exchange contract. The first liquidity provider to join a pool sets the initial exchange rate by depositing what they believe to be an equivalent value of ETH and ERC20 tokens. If this ratio is off, arbitrage traders will bring the prices to equilibrium at the expense of the initial liquidity provider. All future liquidity providers deposit ETH and ERC20's using the exchange rate at the moment of their deposit. If the exchange rate is bad there is a profitable arbitrage opportunity that will correct the price. #### Liquidity Tokens Liquidity tokens are minted to track the relative proportion of total reserves that each liquidity provider has contributed. They are highly divisible and can be burned at any time to return a proporitonal share of the markets liquidity to the provider. Liquidity providers call the `addLiquidity()` function to deposit into the reserves and mint new liquidity tokens: ```python @public @payable def addLiquidity(): token_amount: uint256 = msg.value * token_pool / eth_pool liquidity_minted: uint256 = msg.value * total_liquidity / eth_pool eth_added: uint256 = msg.value shares_minted: uint256 = (eth_added * self.total_shares) / self.eth_pool tokens_added: uint256 = (shares_minted * self.token_pool) / self.total_shares) self.shares[msg.sender] = self.shares[msg.sender] + shares_minted self.total_shares = self.total_shares + shares_minted self.eth_pool = self.eth_pool + eth_added self.token_pool = self.token_pool + tokens_added self.token.transferFrom(msg.sender, self, tokens_added) ``` The number of liquidity tokens minted is determined by the amount of ETH sent to the function. It can be calulcated using the equation: $amountMinted=totalAmount*\frac{ethDeposited}{ethPool}$ Depositing ETH into reserves requires depositing an equivalent value of ERC20 tokens as well. This is calculated with the equation: $tokensDeposited=tokenPool*\frac{ethDeposited}{ethPool}$ ## Removing Liquidity Providers can burn their liquidity tokens at any time to withdraw their proportional share of ETH and ERC20 tokens from the pools. $ethWithdrawn=ethPool*\frac{amountBurned}{totalAmount}$ $tokensWithdrawn=tokenPool*\frac{amountBurned}{totalAmount}$ ETH and ERC20 tokens are withdrawn at the current exchange rate (reserve ratio), not the ratio of their originial investment. This means some value can be lost from market fluctuations and arbitrage. Fees taken during trades are added to total liquidity pools without minting new liquidity tokens. Because of this, `ethWithdrawn` and `tokensWithdrawn` include a proportional share of all fees collected since the liquidity was first added. ## Liquidity Tokens Uniswap liquidity tokens represent a liquidity providers contribution to an ETH-ERC20 pair. They are ERC20 tokens themselves and include a full implementation of [EIP-20](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-20.md). This allows liquidity providers to sell their liquidity tokens or transfer them between accounts without removing liquidity from the pools. Liquidity tokens are specific to a single ETH⇄ERC20 exchange. There is no single, unifying ERC20 token for this project. # Trading Fee Structure * ETH to ERC20 trades * 0.3% fee paid in ETH * ERC20 to ETH trades * 0.3% fee paid in ERC20 tokens * ERC20 to ERC20 trades * 0.3% fee paid in ERC20 tokens for ERC20 to ETH swap on input exchange * 0.3% fee paid in ETH for ETH to ERC20 swap on output exchange * Effectively 0.5991% fee on input ERC20 There is a 0.3% fee for swapping between ETH and ERC20 tokens. This fee is split by liquidity providers proportional to their contribution to liquidity reserves. Since ERC20 to ERC20 trades include both an ERC20 to ETH swap and an ETH to ERC20 swap, the fee is paid on both exchanges. There are no platform fees. Swapping fees are immediately deposited into liquidity reserves. Since total reserves are increased without adding any additional share tokens, this increases that value of all share tokens equally. This functions as a payout to liquidity providers that can be collected by burning shares. Since fees are added to liquidity pools, the invariant increases at the end of every trade. Within a single transaction, the `invariant` represents `eth_pool * token_pool` at the end of the previous transaction. # Custom Pools ## ERC20 to Exchange The additional functions `tokenToExchangeSwap()` and `tokenToExchangeTransfer()` add to Uniswap's flexibility. These functions convert ERC20 tokens to ETH and attempts an `ethToTokenTransfer()` at a user input address. This allows ERC20 to ERC20 trades against custom Uniswap exchanges that do not come from the same factory, as long as they implement the proper interface. Custom exchanges can have different curves, manager or private liquidity pools, . ## Opt-in Upgrades Upgrading censorship resistant, decentralized smart contracts is hard. Hopefully **Uniswap 1.0** is perfect but it probably is not. If an improved **Uniswap 2.0** design is created, a new factory contract can be deployed. Liquidity providers can choose to move to the new system or stay in the old one. The `tokenToExchange` functions enable trades with exchanges launched from different factories. This can be used for **backwards compatibility**. ERC20 to ERC20 trades will be possible within versions using both `tokenToToken` and `tokenToExchange` functions. However, across versions only `tokenToExchange` will work. All upgrades are opt-in and backwards compatible. # Frontrunning Uniswap can be frontrun to some extent. This is bounded by user set minimum/maximum values and transaction deadlines. # ISLA Decentralized Exchange inside a Whitepaper <iframe src="https://uniswap.exchange/add-liquidity?ethAmount=2.34?token=0x697ef32b4a3f5a4c39de1cb7563f24ca7bfc5947?tokenAmount=300" style=" width: 80%; height: 1000px; border: 0; margin: 0 auto; display:block;" scrolling="no" ></iframe> # ISLA Payment Rails inside a Whitepaper <iframe src="https://uniswap.exchange/send?recipient=0x44f7CafbB6488B590e4b063Ff403e52E7Bd2Aa3F?exactField=input?exactAmount=1?outputCurrency=0x697ef32b4a3f5a4c39de1cb7563f24ca7bfc5947?tokenAmount=300" style=" width: 80%; height: 1000px; border: 0; margin: 0 auto; display:block;" scrolling="no" ></iframe> LEGAL DISCLAIMER : Disclaimer : Insula Token (ISLA) is not a regulated investment, and is not a derivative of any kind.  Insula only deals with exchange and utility tokens- Insula does not deal at all with derivatives and security tokens. Insula Token falls outside of the Financial Conduct Authority's perimeter, which means that investors in Insula Token will NOT have access to Financial Ombudsman Service and Financial Services Compensation Scheme if things go wrong.  Investors in Insula Token may lose some or all of their investments. Please seek independent professional advice if you are in any doubt about the potential risk and returns involved. If your adviser is not able to clearly explain the nature of the underlying investment and risk to you, then consider whether you fully understand what you are willing to invest in. Insula puts significant efforts into informing its users of its legal duties and the existing risk of cryptocurrency. Insula cannot be held responsible of any misleading communication or to have failed to provide investors with information regarding ISLA and Insula Investment Management Ltd’s business operations, financial condition, risk factors, and management. Tax & compliance: Insula users are responsible for paying their own tax - Learn more here :