31:T634,md` Table interpretation: - **value (as $)** shows the *total value* of all assets in the position (USD, ETH, and LP equity), as denominated in USD at the current exchange rate. Likewise for **value (as Ð)**. For instance, if the position has 1 ETH, 500 USD, and 0 LP equity, and the exchange rate is 1000 USD/ETH, then **value (as $)** is 1500 and **value (as Ð)** is 1.5. It follows that, at any given time, the two **value** columns are equivalent to each other at the current exchange rate, and are also equivalent to the sum of **held** and **pooled**. - **held** shows the basket of USD and ETH held outside the liquidity pool. - **pooled** shows the USD and ETH that you would receive if you burned all LP tokens at the current exchange rate. - **k ($ · Ð)** shows the "constant product" for the liquidity pool. - **rate ($/Ð)** shows the current market price of ETH in USD. It's worth noting that the "real" assets that you hold are **held** and **k**. In particular, **pooled** is a reflection of **k** and the current market price, and thus so is **value (as \*)**. Actions: - Updating the exchange rate does not change **held** or **k**. However, it does cause the pool to rebalance, thus updating **pooled** and therefore **value (as \*)**. - Adding liquidity to the pool decreases **held** and increases **k** such that **value \(as \*)** is unchanged. - Depositing new funds updates **held**, and thus also **value (as \*)**. - Accruing fees updates **k**, and thus also **pooled** and **value (as \*)**. `32:T4f9,/** * Update an initial state with each action in turn, printing the state each time. * Each action should be a function from `State` to `State`, or `null` as an alias * for the identity function (for React-style convenience). */ function simulate(actions) { let state = new State(usdPerEth(1)); function row(t, state) { const value = state.value(); const held = state.held(); const pooled = state.pooled(); function both(x) { return `\$${(x.usd.usd / 1000).toFixed(1)}k + ${x.eth.eth.toFixed(1)}Ð`; } return `| ${t} | ${(value.asUsd.usd / 1000).toFixed(1)}k | ${value.asEth.eth.toFixed(1)} | ${both(held)} | ${both(pooled)} | ${state.poolConstant().usdEth.toFixed(0)} | ${state.exchangeRate().usdPerEth} |`; } const rows = [ "| _t_ | value (as $) | value (as Ð) | held | pooled | k ($ · Ð) | rate ($ / Ð) |", "|--:|--:|--:|--:|--:|--:|--:|", // row(state), // uncomment to include zero state in table ]; for (let i = 0; i < actions.length; i++) { state = (actions[i] || ((s) => s))(state); if (!(state instanceof State)) throw new Error(`action ${i} did not return a State`); rows.push(row(i + 1, state)); } return md`${rows.map((s) => s + "\n").join("")}`; }33:Te0b,/** * Immutable state tracking ETH held, USD held, total liquidity pool value * (denominated in USD*ETH), and current exchange rate. */ class State { constructor(exchangeRate) { if (exchangeRate.type !== "USD_PER_ETH") throw new Error("bad exchange rate"); this._held = {usd: usd(0), eth: eth(0)}; this._poolConstant = usdEth(0); this._exchangeRate = exchangeRate; } exchangeRate() { return this._exchangeRate; } held() { return {...this._held}; } poolConstant() { return this._poolConstant; } pooled() { return { usd: usd(Math.sqrt(this._poolConstant.usdEth * this._exchangeRate.usdPerEth)), eth: eth(Math.sqrt(this._poolConstant.usdEth / this._exchangeRate.usdPerEth)), }; } /** Compute the combined value of held funds plus pooled funds. */ value() { let totalEth = 0; totalEth += this._held.eth.eth; totalEth += this.usdToEth(this._held.usd).eth; const pooled = this.pooled(); totalEth += pooled.eth.eth; totalEth += this.usdToEth(pooled.usd).eth; const asEth = eth(totalEth); const asUsd = this.ethToUsd(asEth); return {asEth, asUsd}; } setExchangeRate(exchangeRate) { const result = this.clone(); result._exchangeRate = exchangeRate; return result; } /** Deposit funds to be held, increasing value out of nowhere. */ deposit(amount) { const result = this.clone(); if (amount.eth != null) result._held.eth = eth(result._held.eth.eth + amount.eth.eth); if (amount.usd != null) result._held.usd = usd(result._held.usd.usd + amount.usd.usd); return result; } /** * Move held funds into the pool. Pass either `usd(...)` or `eth(...)`; an equal value * of the other token will also be contributed, based on current exchange rate. */ pool(usdOrEth) { const toPool = { usd: usdOrEth.type === "USD" ? usdOrEth : this.ethToUsd(usdOrEth), eth: usdOrEth.type === "ETH" ? usdOrEth : this.usdToEth(usdOrEth), }; const pooled = this.pooled(); pooled.usd = usd(pooled.usd.usd + toPool.usd.usd); pooled.eth = eth(pooled.eth.eth + toPool.eth.eth); const newPoolConstant = usdEth(pooled.usd.usd * pooled.eth.eth); const result = this.clone(); result._held.usd = usd(result._held.usd.usd - toPool.usd.usd); result._held.eth = eth(result._held.eth.eth - toPool.eth.eth); result._poolConstant = newPoolConstant; return result; } /** * Increase the total value of the pool by a factor of `r` (multiply by `1 + r`). * For instance, at a fee rate of 0.3%, passing `r = 0.006` corresponds to * the fees from swaps whose total value is twice the original pool value. * * NOTE: In a Uniswap LP, no first-order mechanism makes fees "compound". * If the pool's liquidity remains constant and volume remains constant, * then fees per unit time remain constant rather than growing exponentially. * Thus, calling `accrueFees(r)` many times for constant `r` may not be * a realistic model. For small `r` and small `n`, though, it may be * good enough (this is basically Bernoulli's inequality). */ accrueFees(r) { const result = this.clone(); result._poolConstant = usdEth(result._poolConstant.usdEth * (1 + r) ** 2); return result; } ethToUsd(eth) { return usd(eth.eth * this._exchangeRate.usdPerEth); } usdToEth(usd) { return eth(usd.usd / this._exchangeRate.usdPerEth); } clone() { const result = new State(this._exchangeRate); result._held = {...this._held}; result._poolConstant = this._poolConstant; return result; } }34:[] 2f:{"title":"Uniswap liquidity pool explorations","cells":[{"id":0,"value":"md`# Uniswap liquidity pool explorations\n\n(Standard caveats apply: no warranty, this thing does currency math\nwith floats and will destroy all that you hold dear, etc.)\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":251,"value":"md`## Configuration`","pinned":false,"hidden":false,"mode":"ojs"},{"id":294,"value":"viewof params = {\n const cbPool = html``;\n const cbFees = html``;\n const form = html`\n \n `;\n function update() {\n form.value = {\n pool: cbPool.checked,\n fees: cbFees.checked,\n };\n cbFees.disabled = !form.value.pool;\n };\n cbPool.oninput = cbFees.oninput = update;\n update();\n return form;\n};","pinned":false,"hidden":false,"mode":"ojs"},{"id":305,"value":"params","pinned":true,"hidden":false,"mode":"ojs"},{"id":254,"value":"md`## Simulation`","pinned":false,"hidden":false,"mode":"ojs"},{"id":136,"value":"simulate([\n (s) => s.setExchangeRate(usdPerEth(1800)).deposit({usd: usd(50000), eth: eth(30)}),\n (s) => !params.pool ? s : s.pool(usd(10000)),\n (s) => !params.fees ? s : s.accrueFees(feeRatio({days: 30})),\n (s) => s.setExchangeRate(usdPerEth(2400)),\n (s) => !params.pool ? s : s.pool(usd(10000)),\n (s) => !params.fees ? s : s.accrueFees(feeRatio({days: 30})),\n (s) => s.setExchangeRate(usdPerEth(2500)),\n])","pinned":true,"hidden":false,"mode":"ojs"},{"id":333,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":267,"value":"// Rough guess.\nfeeRatio = ({days}) => {\n const baseFeeProportion = 30/10000;\n // (24h trading volume) / (total pool liquidity)\n const dailyVolumePerLiquidity = 0.3;\n return baseFeeProportion * dailyVolumePerLiquidity * days;\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":272,"value":"// my empirical 28-day fee ratio is 0.0262, so this is a fine guess\nfeeRatio({days: 28})","pinned":true,"hidden":false,"mode":"ojs"},{"id":60,"value":"$32","pinned":true,"hidden":false,"mode":"ojs"},{"id":40,"value":"$33","pinned":true,"hidden":false,"mode":"ojs"},{"id":336,"value":"md`Type-safe, dimension-safe constructors.\n\nUsage:\n\n\\`\\`\\`javascript\nconst x = eth(0.1);\nconst y = eth(0.2);\nconst sum = eth(x.eth + y.eth);\n\\`\\`\\`\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":7,"value":"function eth(amount) { return Object.freeze({type: \"ETH\", eth: amount}) }","pinned":false,"hidden":false,"mode":"ojs"},{"id":17,"value":"function usd(amount) { return Object.freeze({type: \"USD\", usd: amount}) }","pinned":false,"hidden":false,"mode":"ojs"},{"id":27,"value":"function usdPerEth(rate) { return Object.freeze({type: \"USD_PER_ETH\", usdPerEth: rate}) }","pinned":false,"hidden":false,"mode":"ojs"},{"id":35,"value":"function usdEth(product) { return Object.freeze({type: \"USD_ETH\", usdEth: product}) }","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W34","stdlib":"1","titling":"auto"}