Contract 0x061b87122ed14b9526a813209c8a59a633257bab 14

 
Txn Hash Method
Block
From
To
Value
0x9eeed8af119e6805ecf895a8b2c57b9a5a00c06ac248cb55889b8430103c98a0Exchange_underly...1180363392024-03-29 0:17:351 hr 21 mins ago0x10364bc63464bd9cd6492e9a1c6de7bf91e60d38 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000105892530.031198198
0xbfaa9024d082930ff5184a559410684e63acce677e02dc54545f666f85f0808dExchange_underly...1180362142024-03-29 0:13:251 hr 25 mins ago0x57f2f4d938b4b0143f2c373292e6c0a07668b663 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000094177320.028623556
0xe8593a606a921e790d562cc6efa9a4ffdbf70cf1fabea84d7aa30c2643cbb4e7Exchange_underly...1180349972024-03-28 23:32:512 hrs 6 mins ago0xa3e6bdd3330ecacfeabe391e52e2d4ce8e105994 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.000013151740.030250195
0x3b13b0a3e23b40f7d5aaa8b0b075a4ed8d59d3b5eed83ec981b06409a090d5bcExchange_underly...1180347102024-03-28 23:23:172 hrs 16 mins ago0x908a854daa5224a685a0f99c528ed4351edb1e38 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000102530560.030224662
0xd7489f6b12c6004937bf6f51bc9ba40a0e3592d7262ad32cd6e02934e0356071Approve1180345532024-03-28 23:18:032 hrs 21 mins ago0xd235992a3f4b4f002f93a83b810f2ef4193d5c7c IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000027490880.031356986
0xe218b51133d959af9774461902962d200d98a17017f178efb33202baff725c72Exchange_underly...1180338102024-03-28 22:53:172 hrs 46 mins ago0x9f555983e1e9cfbbe6ca6776f7a6328ce0467ea1 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000099990820.030519826
0x516f94d7998818be15f13b4b2eb2f5b8599c73821fe434bd59bb996f46b9e29cApprove1180334382024-03-28 22:40:532 hrs 58 mins ago0x8ce0205b455765984230435ec5c06a6e536971d8 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000029664090.027930472
0x9851149395eb7a7844fd1052654a152970ea1180c41f314d98648e857cdc9f47Exchange_underly...1180331762024-03-28 22:32:093 hrs 7 mins ago 0xe782657a1043062087232b3c20c4d25e2a982cb3 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000104067360.031350669
0xb98144ed51406ea8b5458175237ff34a289619f867213373521bf295bc0988f3Approve1180330792024-03-28 22:28:553 hrs 10 mins ago0x8aaa8e6494b13116ad65168283ec5269479611ff IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000025171970.031018
0x09aea183358ee7608c7ddfea4989eaaea17efabce726195c0d0833703be8c967Approve1180326112024-03-28 22:13:193 hrs 26 mins ago0x289a8dd5848a603098f3292703640eccf33e0f51 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000023721930.028714128
0x33bdaa0e287c4e98a15386afcb2ee683cbf469d26ff13003020680e1cf08c7ceApprove1180320962024-03-28 21:56:093 hrs 43 mins ago0x8b6e8643dcc36bb66ed70e7ebb18c5cf46363cc4 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000028226420.029291879
0x5bbd09d35861082ed16b5e5e848b8713cb58854b566e1011ece648f8eda5a957Exchange_underly...1180314542024-03-28 21:34:454 hrs 4 mins ago0x6b020dc9a5371b8e5421bdfb8aa0d6f52d0abc4a IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000104109370.031480427
0xa53f3553b3ea82a10f86213902be1372c766dcf207772d222093f48474c6d2e6Exchange_underly...1180311132024-03-28 21:23:234 hrs 15 mins ago0x684ef1484b6d31e4ea62321eafb7f816e1987f51 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000114613520.03143313
0x6712608d1f4b0af88ef9e314e097ceabd54201c6abcc17e891cc754163781218Exchange_underly...1180309092024-03-28 21:16:354 hrs 22 mins ago0xde57dd241ea13a5ee749b940897538cf4ff4c25d IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000106974790.03123281
0x320e59d98dd5ad8a080fc2b8a0addb9ff01e2a54f21d625ada6692eeb8abfa78Approve1180298612024-03-28 20:41:394 hrs 57 mins ago0xc118aad878cd75907cf14945326dfda1a70835af IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000024645040.0312872
0xfc6210e4fe4525f70eea7e8e2983afd352884aef356bfdea7152857068579fb5Approve1180290032024-03-28 20:13:035 hrs 26 mins ago0x421592c3f5453b41703103d3d8175c68a25f904a IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000015450250.030222546
0x110a306dea4409afdc060c878e3ba82d7d87d41ffe0e55547f9aae070833a63cApprove1180279822024-03-28 19:39:016 hrs ago0x55ed215381b2f016ea41083c73fac26e236a4e83 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000030976210.023423572
0xb3379dbf8a181ef090ca6f7d8b5ec03a4cf0f79b8d822a13edc978c19782cb54Approve1180274962024-03-28 19:22:496 hrs 16 mins ago0x5267a70b1fcacd6f5cc5e96e2632f407f406e174 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000061104830.020201258
0xdf9d3ea2ba156f9f20bcf4d4b6819a0a101d4efdcb751398adb94e7f6d5c58d8Approve1180274222024-03-28 19:20:216 hrs 19 mins ago0x5267a70b1fcacd6f5cc5e96e2632f407f406e174 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000058545590.021166984
0x6e8f9a674749220076fd130faf6f7e865439a42f9a48a752cfa6089578e194f5Approve1180266392024-03-28 18:54:156 hrs 45 mins ago0x203a7f8a55eeeb8fb7d3da0ecc440b798627e15f IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000090679540.0278871
0xf7e5d38da3e87a0932c2f78966c292e4d1c3cbf994a39de5c2506a876cd9f861Approve1180265942024-03-28 18:52:456 hrs 46 mins ago0xc96fddf685ca33d682f6faf8f5cd8a5bc50d637a IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000064481720.0298122
0x43fa02a240fe83e4ce07f4221f26ea50e59cab04f4caa41b9a4e8025fabbeabcApprove1180265882024-03-28 18:52:336 hrs 46 mins ago0x203a7f8a55eeeb8fb7d3da0ecc440b798627e15f IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000066396020.0299328
0xedd19945f6f0fbf484e7ea7d4cc6c43e309dffbd3d7d1b6dcb847c1807d7036eExchange_underly...1180262732024-03-28 18:42:036 hrs 57 mins ago0xccff766fc9e0b1e238224fcbeb0f0d083b5e1792 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000155783190.030979775
0x8b76457d39a24cc37375e3f617783173a9432c633bca0360c1ac63efdf8d7f0dApprove1180260112024-03-28 18:33:197 hrs 6 mins ago0x3dbfa6ccad745835033fc03046ac10ee0f3c28f3 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000078418740.03130341
0xa77f68d791e0de055c4e1e002045146c7bd7d5949ea2479ca045adffd38c4b13Approve1180259492024-03-28 18:31:157 hrs 8 mins ago0xef75d606fb8b08d1ee5800fd379843ca53464ce1 IN  0x061b87122ed14b9526a813209c8a59a633257bab0 ETH0.0000560541471.030866268
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x78cf256256c8089d68cde634cf7cdefb392864700 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0xed4da4d3b90cb359d0216c0016ac6d9241d817c3 0x061b87122ed14b9526a813209c8a59a633257bab0 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x78cf256256c8089d68cde634cf7cdefb392864700 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0xed4da4d3b90cb359d0216c0016ac6d9241d817c3 0x061b87122ed14b9526a813209c8a59a633257bab0 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x78cf256256c8089d68cde634cf7cdefb392864700 ETH
0xcf5337010de47f79ebb460f65278d5cc19fd3f3a41cd054e6d07283052d1a1281075582932023-07-30 11:09:23242 days 14 hrs ago 0xed4da4d3b90cb359d0216c0016ac6d9241d817c3 0x061b87122ed14b9526a813209c8a59a633257bab0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x78cf256256c8089d68cde634cf7cdefb392864700 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0xed4da4d3b90cb359d0216c0016ac6d9241d817c3 0x061b87122ed14b9526a813209c8a59a633257bab0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x78cf256256c8089d68cde634cf7cdefb392864700 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0xed4da4d3b90cb359d0216c0016ac6d9241d817c3 0x061b87122ed14b9526a813209c8a59a633257bab0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x78cf256256c8089d68cde634cf7cdefb392864700 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0xed4da4d3b90cb359d0216c0016ac6d9241d817c3 0x061b87122ed14b9526a813209c8a59a633257bab0 ETH
0x301b20fde3563b77356759367ccf408f3779b7aaae8d0aa9dade92ecfd3b1a111075582542023-07-30 11:08:05242 days 14 hrs ago 0x061b87122ed14b9526a813209c8a59a633257bab 0x1337bedc9d22ecbe766df105c9623922a27963ec0 ETH
[ Download CSV Export 
Loading

Minimal Proxy Contract for 0x78cf256256c8089d68cde634cf7cdefb39286470

Contract Name:
Vyper_contract

Compiler Version
vyper:0.3.1

Optimization Enabled:
N/A

Other Settings:
None license
Decompile ByteCode

Contract Source Code (Vyper language format)

# @version 0.3.1
"""
@title StableSwap
@author Curve.Fi
@license Copyright (c) Curve.Fi, 2020-2021 - all rights reserved
@notice 3pool metapool implementation contract
@dev ERC20 support for return True/revert, return True/False, return None
"""

interface ERC20:
    def approve(_spender: address, _amount: uint256): nonpayable
    def balanceOf(_owner: address) -> uint256: view

interface Curve:
    def coins(i: uint256) -> address: view
    def get_virtual_price() -> uint256: view
    def calc_token_amount(amounts: uint256[BASE_N_COINS], deposit: bool) -> uint256: view
    def calc_withdraw_one_coin(_token_amount: uint256, i: int128) -> uint256: view
    def fee() -> uint256: view
    def get_dy(i: int128, j: int128, dx: uint256) -> uint256: view
    def exchange(i: int128, j: int128, dx: uint256, min_dy: uint256): nonpayable
    def add_liquidity(amounts: uint256[BASE_N_COINS], min_mint_amount: uint256): nonpayable
    def remove_liquidity_one_coin(_token_amount: uint256, i: int128, min_amount: uint256): nonpayable

interface Factory:
    def convert_metapool_fees() -> bool: nonpayable
    def get_fee_receiver(_pool: address) -> address: view
    def admin() -> address: view

interface ERC1271:
    def isValidSignature(_hash: bytes32, _signature: Bytes[65]) -> bytes32: view


event Transfer:
    sender: indexed(address)
    receiver: indexed(address)
    value: uint256

event Approval:
    owner: indexed(address)
    spender: indexed(address)
    value: uint256

event TokenExchange:
    buyer: indexed(address)
    sold_id: int128
    tokens_sold: uint256
    bought_id: int128
    tokens_bought: uint256

event TokenExchangeUnderlying:
    buyer: indexed(address)
    sold_id: int128
    tokens_sold: uint256
    bought_id: int128
    tokens_bought: uint256

event AddLiquidity:
    provider: indexed(address)
    token_amounts: uint256[N_COINS]
    fees: uint256[N_COINS]
    invariant: uint256
    token_supply: uint256

event RemoveLiquidity:
    provider: indexed(address)
    token_amounts: uint256[N_COINS]
    fees: uint256[N_COINS]
    token_supply: uint256

event RemoveLiquidityOne:
    provider: indexed(address)
    token_amount: uint256
    coin_amount: uint256
    token_supply: uint256

event RemoveLiquidityImbalance:
    provider: indexed(address)
    token_amounts: uint256[N_COINS]
    fees: uint256[N_COINS]
    invariant: uint256
    token_supply: uint256

event RampA:
    old_A: uint256
    new_A: uint256
    initial_time: uint256
    future_time: uint256

event StopRampA:
    A: uint256
    t: uint256


BASE_POOL: constant(address) = 0x1337BedC9D22ecbe766dF105c9623922A27963EC
BASE_N_COINS: constant(int128) = 3
BASE_COINS: constant(address[BASE_N_COINS]) = [
    0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1,
    0x7F5c764cBc14f9669B88837ca1490cCa17c31607,
    0x94b008aA00579c1307B0EF2c499aD98a8ce58e58
]
BASE_LP_TOKEN: constant(address) = 0x1337BedC9D22ecbe766dF105c9623922A27963EC

N_COINS: constant(int128) = 2
MAX_COIN: constant(int128) = N_COINS - 1
PRECISION: constant(uint256) = 10 ** 18

FEE_DENOMINATOR: constant(uint256) = 10 ** 10
ADMIN_FEE: constant(uint256) = 5000000000

A_PRECISION: constant(uint256) = 100
MAX_A: constant(uint256) = 10 ** 6
MAX_A_CHANGE: constant(uint256) = 10
MIN_RAMP_TIME: constant(uint256) = 86400

EIP712_TYPEHASH: constant(bytes32) = keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)")
PERMIT_TYPEHASH: constant(bytes32) = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)")

# keccak256("isValidSignature(bytes32,bytes)")[:4] << 224
ERC1271_MAGIC_VAL: constant(bytes32) = 0x1626ba7e00000000000000000000000000000000000000000000000000000000
VERSION: constant(String[8]) = "v5.0.0"


factory: address

coins: public(address[N_COINS])
balances: public(uint256[N_COINS])
fee: public(uint256)  # fee * 1e10

initial_A: public(uint256)
future_A: public(uint256)
initial_A_time: public(uint256)
future_A_time: public(uint256)

rate_multiplier: uint256

name: public(String[64])
symbol: public(String[32])

balanceOf: public(HashMap[address, uint256])
allowance: public(HashMap[address, HashMap[address, uint256]])
totalSupply: public(uint256)

DOMAIN_SEPARATOR: public(bytes32)
nonces: public(HashMap[address, uint256])


@external
def __init__():
    # we do this to prevent the implementation contract from being used as a pool
    self.fee = 31337


@external
def initialize(
    _name: String[32],
    _symbol: String[10],
    _coin: address,
    _rate_multiplier: uint256,
    _A: uint256,
    _fee: uint256
):
    """
    @notice Contract initializer
    @param _name Name of the new pool
    @param _symbol Token symbol
    @param _coin Addresses of ERC20 conracts of coins
    @param _rate_multiplier Rate multiplier for `_coin` (10 ** (36 - decimals))
    @param _A Amplification coefficient multiplied by n ** (n - 1)
    @param _fee Fee to charge for exchanges
    """
    # check if fee was already set to prevent initializing contract twice
    assert self.fee == 0

    A: uint256 = _A * A_PRECISION
    self.coins = [_coin, BASE_LP_TOKEN]
    self.rate_multiplier = _rate_multiplier
    self.initial_A = A
    self.future_A = A
    self.fee = _fee
    self.factory = msg.sender

    name: String[64] = concat("Curve.fi Factory USD Metapool: ", _name)
    self.name = name
    self.symbol = concat(_symbol, "3CRV-f")

    for coin in BASE_COINS:
        ERC20(coin).approve(BASE_POOL, MAX_UINT256)

    self.DOMAIN_SEPARATOR = keccak256(
        _abi_encode(EIP712_TYPEHASH, keccak256(name), keccak256(VERSION), chain.id, self)
    )

    # fire a transfer event so block explorers identify the contract as an ERC20
    log Transfer(ZERO_ADDRESS, self, 0)


### ERC20 Functionality ###

@view
@external
def decimals() -> uint256:
    """
    @notice Get the number of decimals for this token
    @dev Implemented as a view method to reduce gas costs
    @return uint256 decimal places
    """
    return 18


@internal
def _transfer(_from: address, _to: address, _value: uint256):
    # # NOTE: vyper does not allow underflows
    # #       so the following subtraction would revert on insufficient balance
    self.balanceOf[_from] -= _value
    self.balanceOf[_to] += _value

    log Transfer(_from, _to, _value)


@external
def transfer(_to : address, _value : uint256) -> bool:
    """
    @dev Transfer token for a specified address
    @param _to The address to transfer to.
    @param _value The amount to be transferred.
    """
    self._transfer(msg.sender, _to, _value)
    return True


@external
def transferFrom(_from : address, _to : address, _value : uint256) -> bool:
    """
     @dev Transfer tokens from one address to another.
     @param _from address The address which you want to send tokens from
     @param _to address The address which you want to transfer to
     @param _value uint256 the amount of tokens to be transferred
    """
    self._transfer(_from, _to, _value)

    _allowance: uint256 = self.allowance[_from][msg.sender]
    if _allowance != MAX_UINT256:
        self.allowance[_from][msg.sender] = _allowance - _value

    return True


@external
def approve(_spender : address, _value : uint256) -> bool:
    """
    @notice Approve the passed address to transfer the specified amount of
            tokens on behalf of msg.sender
    @dev Beware that changing an allowance via this method brings the risk that
         someone may use both the old and new allowance by unfortunate transaction
         ordering: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
    @param _spender The address which will transfer the funds
    @param _value The amount of tokens that may be transferred
    @return bool success
    """
    self.allowance[msg.sender][_spender] = _value

    log Approval(msg.sender, _spender, _value)
    return True


@external
def permit(
    _owner: address,
    _spender: address,
    _value: uint256,
    _deadline: uint256,
    _v: uint8,
    _r: bytes32,
    _s: bytes32
) -> bool:
    """
    @notice Approves spender by owner's signature to expend owner's tokens.
        See https://eips.ethereum.org/EIPS/eip-2612.
    @dev Inspired by https://github.com/yearn/yearn-vaults/blob/main/contracts/Vault.vy#L753-L793
    @dev Supports smart contract wallets which implement ERC1271
        https://eips.ethereum.org/EIPS/eip-1271
    @param _owner The address which is a source of funds and has signed the Permit.
    @param _spender The address which is allowed to spend the funds.
    @param _value The amount of tokens to be spent.
    @param _deadline The timestamp after which the Permit is no longer valid.
    @param _v The bytes[64] of the valid secp256k1 signature of permit by owner
    @param _r The bytes[0:32] of the valid secp256k1 signature of permit by owner
    @param _s The bytes[32:64] of the valid secp256k1 signature of permit by owner
    @return True, if transaction completes successfully
    """
    assert _owner != ZERO_ADDRESS
    assert block.timestamp <= _deadline

    nonce: uint256 = self.nonces[_owner]
    digest: bytes32 = keccak256(
        concat(
            b"\x19\x01",
            self.DOMAIN_SEPARATOR,
            keccak256(_abi_encode(PERMIT_TYPEHASH, _owner, _spender, _value, nonce, _deadline))
        )
    )

    if _owner.is_contract:
        sig: Bytes[65] = concat(_abi_encode(_r, _s), slice(convert(_v, bytes32), 31, 1))
        # reentrancy not a concern since this is a staticcall
        assert ERC1271(_owner).isValidSignature(digest, sig) == ERC1271_MAGIC_VAL
    else:
        assert ecrecover(digest, convert(_v, uint256), convert(_r, uint256), convert(_s, uint256)) == _owner

    self.allowance[_owner][_spender] = _value
    self.nonces[_owner] = nonce + 1

    log Approval(_owner, _spender, _value)
    return True


### StableSwap Functionality ###

@view
@internal
def _A() -> uint256:
    """
    Handle ramping A up or down
    """
    t1: uint256 = self.future_A_time
    A1: uint256 = self.future_A

    if block.timestamp < t1:
        A0: uint256 = self.initial_A
        t0: uint256 = self.initial_A_time
        # Expressions in uint256 cannot have negative numbers, thus "if"
        if A1 > A0:
            return A0 + (A1 - A0) * (block.timestamp - t0) / (t1 - t0)
        else:
            return A0 - (A0 - A1) * (block.timestamp - t0) / (t1 - t0)

    else:  # when t1 == 0 or block.timestamp >= t1
        return A1


@view
@external
def admin_fee() -> uint256:
    return ADMIN_FEE


@view
@external
def A() -> uint256:
    return self._A() / A_PRECISION


@view
@external
def A_precise() -> uint256:
    return self._A()


@pure
@internal
def _xp_mem(_rates: uint256[N_COINS], _balances: uint256[N_COINS]) -> uint256[N_COINS]:
    result: uint256[N_COINS] = empty(uint256[N_COINS])
    for i in range(N_COINS):
        result[i] = _rates[i] * _balances[i] / PRECISION
    return result


@pure
@internal
def get_D(_xp: uint256[N_COINS], _amp: uint256) -> uint256:
    """
    D invariant calculation in non-overflowing integer operations
    iteratively

    A * sum(x_i) * n**n + D = A * D * n**n + D**(n+1) / (n**n * prod(x_i))

    Converging solution:
    D[j+1] = (A * n**n * sum(x_i) - D[j]**(n+1) / (n**n prod(x_i))) / (A * n**n - 1)
    """
    S: uint256 = 0
    Dprev: uint256 = 0
    for x in _xp:
        S += x
    if S == 0:
        return 0

    D: uint256 = S
    Ann: uint256 = _amp * N_COINS
    for i in range(255):
        D_P: uint256 = D
        for x in _xp:
            D_P = D_P * D / (x * N_COINS)  # If division by 0, this will be borked: only withdrawal will work. And that is good
        Dprev = D
        D = (Ann * S / A_PRECISION + D_P * N_COINS) * D / ((Ann - A_PRECISION) * D / A_PRECISION + (N_COINS + 1) * D_P)
        # Equality with the precision of 1
        if D > Dprev:
            if D - Dprev <= 1:
                return D
        else:
            if Dprev - D <= 1:
                return D
    # convergence typically occurs in 4 rounds or less, this should be unreachable!
    # if it does happen the pool is borked and LPs can withdraw via `remove_liquidity`
    raise


@view
@internal
def get_D_mem(_rates: uint256[N_COINS], _balances: uint256[N_COINS], _amp: uint256) -> uint256:
    xp: uint256[N_COINS] = self._xp_mem(_rates, _balances)
    return self.get_D(xp, _amp)


@view
@external
def get_virtual_price() -> uint256:
    """
    @notice The current virtual price of the pool LP token
    @dev Useful for calculating profits
    @return LP token virtual price normalized to 1e18
    """
    amp: uint256 = self._A()
    rates: uint256[N_COINS] = [self.rate_multiplier, Curve(BASE_POOL).get_virtual_price()]
    xp: uint256[N_COINS] = self._xp_mem(rates, self.balances)
    D: uint256 = self.get_D(xp, amp)
    # D is in the units similar to DAI (e.g. converted to precision 1e18)
    # When balanced, D = n * x_u - total virtual value of the portfolio
    return D * PRECISION / self.totalSupply


@view
@external
def calc_token_amount(_amounts: uint256[N_COINS], _is_deposit: bool) -> uint256:
    """
    @notice Calculate addition or reduction in token supply from a deposit or withdrawal
    @dev This calculation accounts for slippage, but not fees.
         Needed to prevent front-running, not for precise calculations!
    @param _amounts Amount of each coin being deposited
    @param _is_deposit set True for deposits, False for withdrawals
    @return Expected amount of LP tokens received
    """
    amp: uint256 = self._A()
    rates: uint256[N_COINS] = [self.rate_multiplier, Curve(BASE_POOL).get_virtual_price()]
    balances: uint256[N_COINS] = self.balances

    D0: uint256 = self.get_D_mem(rates, balances, amp)
    for i in range(N_COINS):
        amount: uint256 = _amounts[i]
        if _is_deposit:
            balances[i] += amount
        else:
            balances[i] -= amount
    D1: uint256 = self.get_D_mem(rates, balances, amp)
    diff: uint256 = 0
    if _is_deposit:
        diff = D1 - D0
    else:
        diff = D0 - D1
    return diff * self.totalSupply / D0


@external
@nonreentrant('lock')
def add_liquidity(
    _amounts: uint256[N_COINS],
    _min_mint_amount: uint256,
    _receiver: address = msg.sender
) -> uint256:
    """
    @notice Deposit coins into the pool
    @param _amounts List of amounts of coins to deposit
    @param _min_mint_amount Minimum amount of LP tokens to mint from the deposit
    @param _receiver Address that owns the minted LP tokens
    @return Amount of LP tokens received by depositing
    """
    amp: uint256 = self._A()
    rates: uint256[N_COINS] = [self.rate_multiplier, Curve(BASE_POOL).get_virtual_price()]

    # Initial invariant
    old_balances: uint256[N_COINS] = self.balances
    D0: uint256 = self.get_D_mem(rates, old_balances, amp)
    new_balances: uint256[N_COINS] = old_balances

    total_supply: uint256 = self.totalSupply
    for i in range(N_COINS):
        amount: uint256 = _amounts[i]
        if amount == 0:
            assert total_supply > 0
        else:
            response: Bytes[32] = raw_call(
                self.coins[i],
                _abi_encode(
                    msg.sender,
                    self,
                    amount,
                    method_id=method_id("transferFrom(address,address,uint256)")
                ),
                max_outsize=32,
            )
            if len(response) > 0:
                assert convert(response, bool)
            new_balances[i] += amount

    # Invariant after change
    D1: uint256 = self.get_D_mem(rates, new_balances, amp)
    assert D1 > D0

    # We need to recalculate the invariant accounting for fees
    # to calculate fair user's share
    fees: uint256[N_COINS] = empty(uint256[N_COINS])
    mint_amount: uint256 = 0
    if total_supply > 0:
        # Only account for fees if we are not the first to deposit
        base_fee: uint256 = self.fee * N_COINS / (4 * (N_COINS - 1))
        for i in range(N_COINS):
            ideal_balance: uint256 = D1 * old_balances[i] / D0
            difference: uint256 = 0
            new_balance: uint256 = new_balances[i]
            if ideal_balance > new_balance:
                difference = ideal_balance - new_balance
            else:
                difference = new_balance - ideal_balance
            fees[i] = base_fee * difference / FEE_DENOMINATOR
            self.balances[i] = new_balance - (fees[i] * ADMIN_FEE / FEE_DENOMINATOR)
            new_balances[i] -= fees[i]
        D2: uint256 = self.get_D_mem(rates, new_balances, amp)
        mint_amount = total_supply * (D2 - D0) / D0
    else:
        self.balances = new_balances
        mint_amount = D1  # Take the dust if there was any

    assert mint_amount >= _min_mint_amount

    # Mint pool tokens
    total_supply += mint_amount
    self.balanceOf[_receiver] += mint_amount
    self.totalSupply = total_supply
    log Transfer(ZERO_ADDRESS, _receiver, mint_amount)
    log AddLiquidity(msg.sender, _amounts, fees, D1, total_supply)

    return mint_amount


@view
@internal
def get_y(i: int128, j: int128, x: uint256, xp: uint256[N_COINS]) -> uint256:
    # x in the input is converted to the same price/precision

    assert i != j       # dev: same coin
    assert j >= 0       # dev: j below zero
    assert j < N_COINS  # dev: j above N_COINS

    # should be unreachable, but good for safety
    assert i >= 0
    assert i < N_COINS

    amp: uint256 = self._A()
    D: uint256 = self.get_D(xp, amp)
    S_: uint256 = 0
    _x: uint256 = 0
    y_prev: uint256 = 0
    c: uint256 = D
    Ann: uint256 = amp * N_COINS

    for _i in range(N_COINS):
        if _i == i:
            _x = x
        elif _i != j:
            _x = xp[_i]
        else:
            continue
        S_ += _x
        c = c * D / (_x * N_COINS)

    c = c * D * A_PRECISION / (Ann * N_COINS)
    b: uint256 = S_ + D * A_PRECISION / Ann  # - D
    y: uint256 = D

    for _i in range(255):
        y_prev = y
        y = (y*y + c) / (2 * y + b - D)
        # Equality with the precision of 1
        if y > y_prev:
            if y - y_prev <= 1:
                return y
        else:
            if y_prev - y <= 1:
                return y
    raise


@view
@external
def get_dy(i: int128, j: int128, dx: uint256) -> uint256:
    """
    @notice Calculate the current output dy given input dx
    @dev Index values can be found via the `coins` public getter method
    @param i Index value for the coin to send
    @param j Index valie of the coin to recieve
    @param dx Amount of `i` being exchanged
    @return Amount of `j` predicted
    """
    rates: uint256[N_COINS] = [self.rate_multiplier, Curve(BASE_POOL).get_virtual_price()]
    xp: uint256[N_COINS] = self._xp_mem(rates, self.balances)

    x: uint256 = xp[i] + (dx * rates[i] / PRECISION)
    y: uint256 = self.get_y(i, j, x, xp)
    dy: uint256 = xp[j] - y - 1
    fee: uint256 = self.fee * dy / FEE_DENOMINATOR
    return (dy - fee) * PRECISION / rates[j]


@view
@external
def get_dy_underlying(i: int128, j: int128, dx: uint256) -> uint256:
    """
    @notice Calculate the current output dy given input dx on underlying
    @dev Index values can be found via the `coins` public getter method
    @param i Index value for the coin to send
    @param j Index valie of the coin to recieve
    @param dx Amount of `i` being exchanged
    @return Amount of `j` predicted
    """
    rates: uint256[N_COINS] = [self.rate_multiplier, Curve(BASE_POOL).get_virtual_price()]
    xp: uint256[N_COINS] = self._xp_mem(rates, self.balances)

    x: uint256 = 0
    base_i: int128 = 0
    base_j: int128 = 0
    meta_i: int128 = 0
    meta_j: int128 = 0

    if i != 0:
        base_i = i - MAX_COIN
        meta_i = 1
    if j != 0:
        base_j = j - MAX_COIN
        meta_j = 1

    if i == 0:
        x = xp[i] + dx * (rates[0] / 10**18)
    else:
        if j == 0:
            # i is from BasePool
            # At first, get the amount of pool tokens
            base_inputs: uint256[BASE_N_COINS] = empty(uint256[BASE_N_COINS])
            base_inputs[base_i] = dx
            # Token amount transformed to underlying "dollars"
            x = Curve(BASE_POOL).calc_token_amount(base_inputs, True) * rates[1] / PRECISION
            # Accounting for deposit/withdraw fees approximately
            x -= x * Curve(BASE_POOL).fee() / (2 * FEE_DENOMINATOR)
            # Adding number of pool tokens
            x += xp[MAX_COIN]
        else:
            # If both are from the base pool
            return Curve(BASE_POOL).get_dy(base_i, base_j, dx)

    # This pool is involved only when in-pool assets are used
    y: uint256 = self.get_y(meta_i, meta_j, x, xp)
    dy: uint256 = xp[meta_j] - y - 1
    dy = (dy - self.fee * dy / FEE_DENOMINATOR)

    # If output is going via the metapool
    if j == 0:
        dy /= (rates[0] / 10**18)
    else:
        # j is from BasePool
        # The fee is already accounted for
        dy = Curve(BASE_POOL).calc_withdraw_one_coin(dy * PRECISION / rates[1], base_j)

    return dy


@external
@nonreentrant('lock')
def exchange(
    i: int128,
    j: int128,
    _dx: uint256,
    _min_dy: uint256,
    _receiver: address = msg.sender,
) -> uint256:
    """
    @notice Perform an exchange between two coins
    @dev Index values can be found via the `coins` public getter method
    @param i Index value for the coin to send
    @param j Index valie of the coin to recieve
    @param _dx Amount of `i` being exchanged
    @param _min_dy Minimum amount of `j` to receive
    @param _receiver Address that receives `j`
    @return Actual amount of `j` received
    """
    rates: uint256[N_COINS] = [self.rate_multiplier, Curve(BASE_POOL).get_virtual_price()]

    old_balances: uint256[N_COINS] = self.balances
    xp: uint256[N_COINS] = self._xp_mem(rates, old_balances)

    x: uint256 = xp[i] + _dx * rates[i] / PRECISION
    y: uint256 = self.get_y(i, j, x, xp)

    dy: uint256 = xp[j] - y - 1  # -1 just in case there were some rounding errors
    dy_fee: uint256 = dy * self.fee / FEE_DENOMINATOR

    # Convert all to real units
    dy = (dy - dy_fee) * PRECISION / rates[j]
    assert dy >= _min_dy

    dy_admin_fee: uint256 = dy_fee * ADMIN_FEE / FEE_DENOMINATOR
    dy_admin_fee = dy_admin_fee * PRECISION / rates[j]

    # Change balances exactly in same way as we change actual ERC20 coin amounts
    self.balances[i] = old_balances[i] + _dx
    # When rounding errors happen, we undercharge admin fee in favor of LP
    self.balances[j] = old_balances[j] - dy - dy_admin_fee

    response: Bytes[32] = raw_call(
        self.coins[i],
        _abi_encode(
            msg.sender, self, _dx, method_id=method_id("transferFrom(address,address,uint256)")
        ),
        max_outsize=32,
    )
    if len(response) > 0:
        assert convert(response, bool)

    response = raw_call(
        self.coins[j],
        _abi_encode(_receiver, dy, method_id=method_id("transfer(address,uint256)")),
        max_outsize=32,
    )
    if len(response) > 0:
        assert convert(response, bool)

    log TokenExchange(msg.sender, i, _dx, j, dy)

    return dy


@external
@nonreentrant('lock')
def exchange_underlying(
    i: int128,
    j: int128,
    _dx: uint256,
    _min_dy: uint256,
    _receiver: address = msg.sender,
) -> uint256:
    """
    @notice Perform an exchange between two underlying coins
    @param i Index value for the underlying coin to send
    @param j Index valie of the underlying coin to receive
    @param _dx Amount of `i` being exchanged
    @param _min_dy Minimum amount of `j` to receive
    @param _receiver Address that receives `j`
    @return Actual amount of `j` received
    """
    rates: uint256[N_COINS] = [self.rate_multiplier, Curve(BASE_POOL).get_virtual_price()]
    old_balances: uint256[N_COINS] = self.balances
    xp: uint256[N_COINS] = self._xp_mem(rates, old_balances)

    base_coins: address[BASE_N_COINS] = BASE_COINS

    dy: uint256 = 0
    base_i: int128 = 0
    base_j: int128 = 0
    meta_i: int128 = 0
    meta_j: int128 = 0
    x: uint256 = 0
    input_coin: address = ZERO_ADDRESS
    output_coin: address = ZERO_ADDRESS

    if i == 0:
        input_coin = self.coins[0]
    else:
        base_i = i - MAX_COIN
        meta_i = 1
        input_coin = base_coins[base_i]
    if j == 0:
        output_coin = self.coins[0]
    else:
        base_j = j - MAX_COIN
        meta_j = 1
        output_coin = base_coins[base_j]

    response: Bytes[32] = raw_call(
        input_coin,
        _abi_encode(
            msg.sender, self, _dx, method_id=method_id("transferFrom(address,address,uint256)")
        ),
        max_outsize=32,
    )
    if len(response) > 0:
        assert convert(response, bool)

    dx: uint256 = _dx
    if i == 0 or j == 0:
        if i == 0:
            x = xp[i] + dx * rates[i] / PRECISION
        else:
            # i is from BasePool
            # At first, get the amount of pool tokens
            base_inputs: uint256[BASE_N_COINS] = empty(uint256[BASE_N_COINS])
            base_inputs[base_i] = dx
            coin_i: address = self.coins[MAX_COIN]
            # Deposit and measure delta
            x = ERC20(coin_i).balanceOf(self)
            Curve(BASE_POOL).add_liquidity(base_inputs, 0)
            # Need to convert pool token to "virtual" units using rates
            # dx is also different now
            dx = ERC20(coin_i).balanceOf(self) - x
            x = dx * rates[MAX_COIN] / PRECISION
            # Adding number of pool tokens
            x += xp[MAX_COIN]

        y: uint256 = self.get_y(meta_i, meta_j, x, xp)

        # Either a real coin or token
        dy = xp[meta_j] - y - 1  # -1 just in case there were some rounding errors
        dy_fee: uint256 = dy * self.fee / FEE_DENOMINATOR

        # Convert all to real units
        # Works for both pool coins and real coins
        dy = (dy - dy_fee) * PRECISION / rates[meta_j]

        dy_admin_fee: uint256 = dy_fee * ADMIN_FEE / FEE_DENOMINATOR
        dy_admin_fee = dy_admin_fee * PRECISION / rates[meta_j]

        # Change balances exactly in same way as we change actual ERC20 coin amounts
        self.balances[meta_i] = old_balances[meta_i] + dx
        # When rounding errors happen, we undercharge admin fee in favor of LP
        self.balances[meta_j] = old_balances[meta_j] - dy - dy_admin_fee

        # Withdraw from the base pool if needed
        if j > 0:
            out_amount: uint256 = ERC20(output_coin).balanceOf(self)
            Curve(BASE_POOL).remove_liquidity_one_coin(dy, base_j, 0)
            dy = ERC20(output_coin).balanceOf(self) - out_amount

        assert dy >= _min_dy

    else:
        # If both are from the base pool
        dy = ERC20(output_coin).balanceOf(self)
        Curve(BASE_POOL).exchange(base_i, base_j, dx, _min_dy)
        dy = ERC20(output_coin).balanceOf(self) - dy

    response = raw_call(
        output_coin,
        _abi_encode(_receiver, dy, method_id=method_id("transfer(address,uint256)")),
        max_outsize=32,
    )
    if len(response) > 0:
        assert convert(response, bool)

    log TokenExchangeUnderlying(msg.sender, i, dx, j, dy)

    return dy


@external
@nonreentrant('lock')
def remove_liquidity(
    _burn_amount: uint256,
    _min_amounts: uint256[N_COINS],
    _receiver: address = msg.sender
) -> uint256[N_COINS]:
    """
    @notice Withdraw coins from the pool
    @dev Withdrawal amounts are based on current deposit ratios
    @param _burn_amount Quantity of LP tokens to burn in the withdrawal
    @param _min_amounts Minimum amounts of underlying coins to receive
    @param _receiver Address that receives the withdrawn coins
    @return List of amounts of coins that were withdrawn
    """
    total_supply: uint256 = self.totalSupply
    amounts: uint256[N_COINS] = empty(uint256[N_COINS])

    for i in range(N_COINS):
        old_balance: uint256 = self.balances[i]
        value: uint256 = old_balance * _burn_amount / total_supply
        assert value >= _min_amounts[i]
        self.balances[i] = old_balance - value
        amounts[i] = value
        response: Bytes[32] = raw_call(
            self.coins[i],
            _abi_encode(_receiver, value, method_id=method_id("transfer(address,uint256)")),
            max_outsize=32,
        )
        if len(response) > 0:
            assert convert(response, bool)

    total_supply -= _burn_amount
    self.balanceOf[msg.sender] -= _burn_amount
    self.totalSupply = total_supply
    log Transfer(msg.sender, ZERO_ADDRESS, _burn_amount)

    log RemoveLiquidity(msg.sender, amounts, empty(uint256[N_COINS]), total_supply)

    return amounts


@external
@nonreentrant('lock')
def remove_liquidity_imbalance(
    _amounts: uint256[N_COINS],
    _max_burn_amount: uint256,
    _receiver: address = msg.sender
) -> uint256:
    """
    @notice Withdraw coins from the pool in an imbalanced amount
    @param _amounts List of amounts of underlying coins to withdraw
    @param _max_burn_amount Maximum amount of LP token to burn in the withdrawal
    @param _receiver Address that receives the withdrawn coins
    @return Actual amount of the LP token burned in the withdrawal
    """
    amp: uint256 = self._A()
    rates: uint256[N_COINS] = [self.rate_multiplier, Curve(BASE_POOL).get_virtual_price()]
    old_balances: uint256[N_COINS] = self.balances
    D0: uint256 = self.get_D_mem(rates, old_balances, amp)

    new_balances: uint256[N_COINS] = old_balances
    for i in range(N_COINS):
        amount: uint256 = _amounts[i]
        if amount != 0:
            new_balances[i] -= amount
            response: Bytes[32] = raw_call(
                self.coins[i],
                _abi_encode(_receiver, amount, method_id=method_id("transfer(address,uint256)")),
                max_outsize=32,
            )
            if len(response) > 0:
                assert convert(response, bool)
    D1: uint256 = self.get_D_mem(rates, new_balances, amp)

    fees: uint256[N_COINS] = empty(uint256[N_COINS])
    base_fee: uint256 = self.fee * N_COINS / (4 * (N_COINS - 1))
    for i in range(N_COINS):
        ideal_balance: uint256 = D1 * old_balances[i] / D0
        difference: uint256 = 0
        new_balance: uint256 = new_balances[i]
        if ideal_balance > new_balance:
            difference = ideal_balance - new_balance
        else:
            difference = new_balance - ideal_balance
        fees[i] = base_fee * difference / FEE_DENOMINATOR
        self.balances[i] = new_balance - (fees[i] * ADMIN_FEE / FEE_DENOMINATOR)
        new_balances[i] -= fees[i]
    D2: uint256 = self.get_D_mem(rates, new_balances, amp)

    total_supply: uint256 = self.totalSupply
    burn_amount: uint256 = ((D0 - D2) * total_supply / D0) + 1
    assert burn_amount > 1  # dev: zero tokens burned
    assert burn_amount <= _max_burn_amount

    total_supply -= burn_amount
    self.totalSupply = total_supply
    self.balanceOf[msg.sender] -= burn_amount
    log Transfer(msg.sender, ZERO_ADDRESS, burn_amount)
    log RemoveLiquidityImbalance(msg.sender, _amounts, fees, D1, total_supply)

    return burn_amount


@view
@internal
def get_y_D(A: uint256, i: int128, xp: uint256[N_COINS], D: uint256) -> uint256:
    """
    Calculate x[i] if one reduces D from being calculated for xp to D

    Done by solving quadratic equation iteratively.
    x_1**2 + x1 * (sum' - (A*n**n - 1) * D / (A * n**n)) = D ** (n + 1) / (n ** (2 * n) * prod' * A)
    x_1**2 + b*x_1 = c

    x_1 = (x_1**2 + c) / (2*x_1 + b)
    """
    # x in the input is converted to the same price/precision

    assert i >= 0  # dev: i below zero
    assert i < N_COINS  # dev: i above N_COINS

    S_: uint256 = 0
    _x: uint256 = 0
    y_prev: uint256 = 0
    c: uint256 = D
    Ann: uint256 = A * N_COINS

    for _i in range(N_COINS):
        if _i != i:
            _x = xp[_i]
        else:
            continue
        S_ += _x
        c = c * D / (_x * N_COINS)

    c = c * D * A_PRECISION / (Ann * N_COINS)
    b: uint256 = S_ + D * A_PRECISION / Ann
    y: uint256 = D

    for _i in range(255):
        y_prev = y
        y = (y*y + c) / (2 * y + b - D)
        # Equality with the precision of 1
        if y > y_prev:
            if y - y_prev <= 1:
                return y
        else:
            if y_prev - y <= 1:
                return y
    raise


@view
@internal
def _calc_withdraw_one_coin(_burn_amount: uint256, i: int128) -> uint256[2]:
    # First, need to calculate
    # * Get current D
    # * Solve Eqn against y_i for D - _token_amount
    amp: uint256 = self._A()
    rates: uint256[N_COINS] = [self.rate_multiplier, Curve(BASE_POOL).get_virtual_price()]
    xp: uint256[N_COINS] = self._xp_mem(rates, self.balances)
    D0: uint256 = self.get_D(xp, amp)

    total_supply: uint256 = self.totalSupply
    D1: uint256 = D0 - _burn_amount * D0 / total_supply
    new_y: uint256 = self.get_y_D(amp, i, xp, D1)

    base_fee: uint256 = self.fee * N_COINS / (4 * (N_COINS - 1))
    xp_reduced: uint256[N_COINS] = empty(uint256[N_COINS])

    for j in range(N_COINS):
        dx_expected: uint256 = 0
        xp_j: uint256 = xp[j]
        if j == i:
            dx_expected = xp_j * D1 / D0 - new_y
        else:
            dx_expected = xp_j - xp_j * D1 / D0
        xp_reduced[j] = xp_j - base_fee * dx_expected / FEE_DENOMINATOR

    dy: uint256 = xp_reduced[i] - self.get_y_D(amp, i, xp_reduced, D1)
    dy_0: uint256 = (xp[i] - new_y) * PRECISION / rates[i]  # w/o fees
    dy = (dy - 1) * PRECISION / rates[i]  # Withdraw less to account for rounding errors

    return [dy, dy_0 - dy]


@view
@external
def calc_withdraw_one_coin(_burn_amount: uint256, i: int128) -> uint256:
    """
    @notice Calculate the amount received when withdrawing a single coin
    @param _burn_amount Amount of LP tokens to burn in the withdrawal
    @param i Index value of the coin to withdraw
    @return Amount of coin received
    """
    return self._calc_withdraw_one_coin(_burn_amount, i)[0]


@external
@nonreentrant('lock')
def remove_liquidity_one_coin(
    _burn_amount: uint256,
    i: int128,
    _min_received: uint256,
    _receiver: address = msg.sender,
) -> uint256:
    """
    @notice Withdraw a single coin from the pool
    @param _burn_amount Amount of LP tokens to burn in the withdrawal
    @param i Index value of the coin to withdraw
    @param _min_received Minimum amount of coin to receive
    @param _receiver Address that receives the withdrawn coins
    @return Amount of coin received
    """
    dy: uint256[2] = self._calc_withdraw_one_coin(_burn_amount, i)
    assert dy[0] >= _min_received

    self.balances[i] -= (dy[0] + dy[1] * ADMIN_FEE / FEE_DENOMINATOR)
    total_supply: uint256 = self.totalSupply - _burn_amount
    self.totalSupply = total_supply
    self.balanceOf[msg.sender] -= _burn_amount
    log Transfer(msg.sender, ZERO_ADDRESS, _burn_amount)

    response: Bytes[32] = raw_call(
        self.coins[i],
        _abi_encode(_receiver, dy[0], method_id=method_id("transfer(address,uint256)")),
        max_outsize=32,
    )
    if len(response) > 0:
        assert convert(response, bool)

    log RemoveLiquidityOne(msg.sender, _burn_amount, dy[0], total_supply)

    return dy[0]


@external
def ramp_A(_future_A: uint256, _future_time: uint256):
    assert msg.sender == Factory(self.factory).admin()  # dev: only owner
    assert block.timestamp >= self.initial_A_time + MIN_RAMP_TIME
    assert _future_time >= block.timestamp + MIN_RAMP_TIME  # dev: insufficient time

    _initial_A: uint256 = self._A()
    _future_A_p: uint256 = _future_A * A_PRECISION

    assert _future_A > 0 and _future_A < MAX_A
    if _future_A_p < _initial_A:
        assert _future_A_p * MAX_A_CHANGE >= _initial_A
    else:
        assert _future_A_p <= _initial_A * MAX_A_CHANGE

    self.initial_A = _initial_A
    self.future_A = _future_A_p
    self.initial_A_time = block.timestamp
    self.future_A_time = _future_time

    log RampA(_initial_A, _future_A_p, block.timestamp, _future_time)


@external
def stop_ramp_A():
    assert msg.sender == Factory(self.factory).admin()  # dev: only owner

    current_A: uint256 = self._A()
    self.initial_A = current_A
    self.future_A = current_A
    self.initial_A_time = block.timestamp
    self.future_A_time = block.timestamp
    # now (block.timestamp < t1) is always False, so we return saved A

    log StopRampA(current_A, block.timestamp)


@view
@external
def admin_balances(i: uint256) -> uint256:
    return ERC20(self.coins[i]).balanceOf(self) - self.balances[i]


@external
def withdraw_admin_fees():
    # transfer coin 0 to Factory and call `convert_fees` to swap it for coin 1
    factory: address = self.factory
    coin: address = self.coins[0]
    amount: uint256 = ERC20(coin).balanceOf(self) - self.balances[0]
    if amount > 0:
        response: Bytes[32] = raw_call(
            coin,
            _abi_encode(factory, amount, method_id=method_id("transfer(address,uint256)")),
            max_outsize=32,
        )
        if len(response) > 0:
            assert convert(response, bool)
        Factory(factory).convert_metapool_fees()

    # transfer coin 1 to the receiver
    coin = self.coins[1]
    amount = ERC20(coin).balanceOf(self) - self.balances[1]
    if amount > 0:
        receiver: address = Factory(factory).get_fee_receiver(self)
        response: Bytes[32] = raw_call(
            coin,
            _abi_encode(receiver, amount, method_id=method_id("transfer(address,uint256)")),
            max_outsize=32,
        )
        if len(response) > 0:
            assert convert(response, bool)


@view
@external
def version() -> String[8]:
    """
    @notice Get the version of this token contract
    """
    return VERSION

Contract ABI

[{"name":"Transfer","inputs":[{"name":"sender","type":"address","indexed":true},{"name":"receiver","type":"address","indexed":true},{"name":"value","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"Approval","inputs":[{"name":"owner","type":"address","indexed":true},{"name":"spender","type":"address","indexed":true},{"name":"value","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"TokenExchange","inputs":[{"name":"buyer","type":"address","indexed":true},{"name":"sold_id","type":"int128","indexed":false},{"name":"tokens_sold","type":"uint256","indexed":false},{"name":"bought_id","type":"int128","indexed":false},{"name":"tokens_bought","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"TokenExchangeUnderlying","inputs":[{"name":"buyer","type":"address","indexed":true},{"name":"sold_id","type":"int128","indexed":false},{"name":"tokens_sold","type":"uint256","indexed":false},{"name":"bought_id","type":"int128","indexed":false},{"name":"tokens_bought","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"AddLiquidity","inputs":[{"name":"provider","type":"address","indexed":true},{"name":"token_amounts","type":"uint256[2]","indexed":false},{"name":"fees","type":"uint256[2]","indexed":false},{"name":"invariant","type":"uint256","indexed":false},{"name":"token_supply","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"RemoveLiquidity","inputs":[{"name":"provider","type":"address","indexed":true},{"name":"token_amounts","type":"uint256[2]","indexed":false},{"name":"fees","type":"uint256[2]","indexed":false},{"name":"token_supply","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"RemoveLiquidityOne","inputs":[{"name":"provider","type":"address","indexed":true},{"name":"token_amount","type":"uint256","indexed":false},{"name":"coin_amount","type":"uint256","indexed":false},{"name":"token_supply","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"RemoveLiquidityImbalance","inputs":[{"name":"provider","type":"address","indexed":true},{"name":"token_amounts","type":"uint256[2]","indexed":false},{"name":"fees","type":"uint256[2]","indexed":false},{"name":"invariant","type":"uint256","indexed":false},{"name":"token_supply","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"RampA","inputs":[{"name":"old_A","type":"uint256","indexed":false},{"name":"new_A","type":"uint256","indexed":false},{"name":"initial_time","type":"uint256","indexed":false},{"name":"future_time","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"StopRampA","inputs":[{"name":"A","type":"uint256","indexed":false},{"name":"t","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"stateMutability":"nonpayable","type":"constructor","inputs":[],"outputs":[]},{"stateMutability":"nonpayable","type":"function","name":"initialize","inputs":[{"name":"_name","type":"string"},{"name":"_symbol","type":"string"},{"name":"_coin","type":"address"},{"name":"_rate_multiplier","type":"uint256"},{"name":"_A","type":"uint256"},{"name":"_fee","type":"uint256"}],"outputs":[],"gas":496220},{"stateMutability":"view","type":"function","name":"decimals","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":390},{"stateMutability":"nonpayable","type":"function","name":"transfer","inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"gas":79005},{"stateMutability":"nonpayable","type":"function","name":"transferFrom","inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"gas":116985},{"stateMutability":"nonpayable","type":"function","name":"approve","inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"gas":39211},{"stateMutability":"nonpayable","type":"function","name":"permit","inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"},{"name":"_deadline","type":"uint256"},{"name":"_v","type":"uint8"},{"name":"_r","type":"bytes32"},{"name":"_s","type":"bytes32"}],"outputs":[{"name":"","type":"bool"}],"gas":102281},{"stateMutability":"view","type":"function","name":"admin_fee","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":540},{"stateMutability":"view","type":"function","name":"A","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":10448},{"stateMutability":"view","type":"function","name":"A_precise","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":10448},{"stateMutability":"view","type":"function","name":"get_virtual_price","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":807920},{"stateMutability":"view","type":"function","name":"calc_token_amount","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_is_deposit","type":"bool"}],"outputs":[{"name":"","type":"uint256"}],"gas":1597346},{"stateMutability":"nonpayable","type":"function","name":"add_liquidity","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_min_mint_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":2611832},{"stateMutability":"nonpayable","type":"function","name":"add_liquidity","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_min_mint_amount","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":2611832},{"stateMutability":"view","type":"function","name":"get_dy","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"dx","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":1154525},{"stateMutability":"view","type":"function","name":"get_dy_underlying","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"dx","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":1162796},{"stateMutability":"nonpayable","type":"function","name":"exchange","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"_dx","type":"uint256"},{"name":"_min_dy","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":1300799},{"stateMutability":"nonpayable","type":"function","name":"exchange","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"_dx","type":"uint256"},{"name":"_min_dy","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":1300799},{"stateMutability":"nonpayable","type":"function","name":"exchange_underlying","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"_dx","type":"uint256"},{"name":"_min_dy","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":1323253},{"stateMutability":"nonpayable","type":"function","name":"exchange_underlying","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"_dx","type":"uint256"},{"name":"_min_dy","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":1323253},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"_min_amounts","type":"uint256[2]"}],"outputs":[{"name":"","type":"uint256[2]"}],"gas":229848},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"_min_amounts","type":"uint256[2]"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256[2]"}],"gas":229848},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_imbalance","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_max_burn_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":2612120},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_imbalance","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_max_burn_amount","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":2612120},{"stateMutability":"view","type":"function","name":"calc_withdraw_one_coin","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"i","type":"int128"}],"outputs":[{"name":"","type":"uint256"}],"gas":1259},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_one_coin","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"i","type":"int128"},{"name":"_min_received","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":1688189},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_one_coin","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"i","type":"int128"},{"name":"_min_received","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":1688189},{"stateMutability":"nonpayable","type":"function","name":"ramp_A","inputs":[{"name":"_future_A","type":"uint256"},{"name":"_future_time","type":"uint256"}],"outputs":[],"gas":161164},{"stateMutability":"nonpayable","type":"function","name":"stop_ramp_A","inputs":[],"outputs":[],"gas":157387},{"stateMutability":"view","type":"function","name":"admin_balances","inputs":[{"name":"i","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":7859},{"stateMutability":"nonpayable","type":"function","name":"withdraw_admin_fees","inputs":[],"outputs":[],"gas":31294},{"stateMutability":"view","type":"function","name":"version","inputs":[],"outputs":[{"name":"","type":"string"}],"gas":6707},{"stateMutability":"view","type":"function","name":"coins","inputs":[{"name":"arg0","type":"uint256"}],"outputs":[{"name":"","type":"address"}],"gas":3255},{"stateMutability":"view","type":"function","name":"balances","inputs":[{"name":"arg0","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":3285},{"stateMutability":"view","type":"function","name":"fee","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3270},{"stateMutability":"view","type":"function","name":"initial_A","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3300},{"stateMutability":"view","type":"function","name":"future_A","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3330},{"stateMutability":"view","type":"function","name":"initial_A_time","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3360},{"stateMutability":"view","type":"function","name":"future_A_time","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3390},{"stateMutability":"view","type":"function","name":"name","inputs":[],"outputs":[{"name":"","type":"string"}],"gas":13709},{"stateMutability":"view","type":"function","name":"symbol","inputs":[],"outputs":[{"name":"","type":"string"}],"gas":11468},{"stateMutability":"view","type":"function","name":"balanceOf","inputs":[{"name":"arg0","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":3746},{"stateMutability":"view","type":"function","name":"allowance","inputs":[{"name":"arg0","type":"address"},{"name":"arg1","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":4042},{"stateMutability":"view","type":"function","name":"totalSupply","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3540},{"stateMutability":"view","type":"function","name":"DOMAIN_SEPARATOR","inputs":[],"outputs":[{"name":"","type":"bytes32"}],"gas":3570},{"stateMutability":"view","type":"function","name":"nonces","inputs":[{"name":"arg0","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":3866}]

Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.