Contract 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e0 2

 

Contract Overview

Balance:
36.185262619065275421 ETH

ETH Value:
$46,258.52 (@ $1,278.38/ETH)

Token:
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xabfbd38ba0428b0bad61eaa0f647b9237eb390c7b90346d58605fdb5b9e1460fRemove_liquidity...419532712022-11-28 18:47:243 days 4 hrs ago0xcb15649d7b7a1eb01fb1acd14809de6cf82aa1a0 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00 ETH0.00003667
0x84b4ecf05f4e938a3df6f88514500920e9cf322a310af5a03c83371876b326e6Add_liquidity407912262022-11-24 10:04:207 days 12 hrs ago0x882c8e57cf50ea8563182d331a3ecf8c99e953cf IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.0001 ETH0.00078776
0x3a3c9d9fee1d86bcfcfa33a6cab6d5703b3f27b24cee9c4261ef3ef989ee9e6bRemove_liquidity...406572462022-11-23 21:34:578 days 1 hr ago0x77646fc673215d5d5482f25e74194b39bcf97402 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00 ETH0.0008384
0xd86559d1662d1eff7b853c4a6c29c2319d74573533856879721b9e501358da8eRemove_liquidity...403641052022-11-22 21:24:549 days 1 hr ago0xfd47bae98581b759aaf0ef477a42bfd363a15a19 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00 ETH0.00120212
0xa85d10df1308d0528aebfa105ba1e222763e4bbdb696590205f076112c27ff44Exchange384209802022-11-16 0:53:3615 days 22 hrs ago0xb70a29b4334952358902917ba4b0b7d5682ae8e1 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.0001 ETH0.00003823
0xca3657b9d1a7a2564f735893d56ccad559c6f7aaad239ed9e63df7a06b602e19Add_liquidity381207722022-11-14 21:04:0717 days 1 hr ago0xc2461b6d4cf835bf11b91a8a8de3ad7fdd4d8521 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.05 ETH0.00135667
0xd0835c3255be8f4a70e863233e0a80378700f41a673be458d86ed6c6b5652b3fAdd_liquidity380765042022-11-14 17:00:3317 days 5 hrs ago0x7b7aa48d192c31894b1cadacd6338dbeb2ea6259 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.04 ETH0.00005014
0xed97ab948a5044f78d4d3db6c0759fd68eaf0fbb4897227eaa3538b791577d75Add_liquidity375338202022-11-12 15:25:4819 days 7 hrs ago0x72f2a5698e949e67b7f41526f581f59b90713322 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.019 ETH0.00003801
0x7447158f601062a26665fd626731fa068334c80ec18f37b46565a6f458e9a6dfAdd_liquidity371371672022-11-11 7:04:0220 days 15 hrs ago0x7fc5d510a35af4c5a6544cb63c04584dfd650c11 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.1 ETH0.00003585
0xf8c47552f12949907486de349e6c8379ab5ae7d9c31c6d6e75671580539ce37dAdd_liquidity370787032022-11-11 2:23:2320 days 20 hrs ago0x1f7bde66819058393461bbee98c9a146a85ea791 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.23 ETH0.0000391
0x40cc0962a49f736d5813ba24ec30740b0cdfe50dde656911384ee12aef475b0cAdd_liquidity370165992022-11-10 20:52:1021 days 2 hrs ago0x0fd6199c0f5bf6a80cba9a20964fb40dfb61537c IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.05 ETH0.00005183
0x05ead0edd1e39667f3b215642b70485541a32231a5b60271d1b050a39f6a56d1Exchange368624632022-11-10 8:32:2821 days 14 hrs ago0x95e97a414d86ed850bf9ff37dfaa9aa4a1b77635 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.009 ETH0.00005315
0x5e0a2b9140ca0dcb1bebad139835888329779780749fc2876c6f2dfbd257443eAdd_liquidity368405792022-11-10 6:51:1921 days 16 hrs ago0x7ffc8e6d2909ece25bda984fe31c52ac93156f92 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.1 ETH0.00003556
0x90afe67b6bad71b50a06b80ef0b16806e9787d960eb4995ba9cf64384d567a70Add_liquidity365506122022-11-09 7:53:5022 days 15 hrs ago0xbd0adb70b0b2b8c82eb45074e646394cea55a400 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.05 ETH0.00003525
0x37d7ffdb34abc950e79628e00e088eaba22d002c6b416bdd06e55527c7fce605Add_liquidity365468462022-11-09 7:37:1522 days 15 hrs ago0xf156675aaac71048b3708702fad7181a7bfe000d IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.12 ETH0.00004534
0x64dc1303520cd574cf24c1746c81163919fac02f679236f9512d5aaf9255340eAdd_liquidity365006292022-11-09 3:54:3122 days 18 hrs ago0xd32a9a3ea2ca6d7c0d340b771218622a458d930e IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.05 ETH0.00003012
0x2e8f1a58ece67bea192ca035833a5ef55f4a2d34df1d4b302d2b76aaf6c9b6ffAdd_liquidity364900132022-11-09 3:03:5722 days 19 hrs ago0xb3831791a0300aaef86cba90703d4d000013c98b IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.05 ETH0.00002591
0x6c0d38f89f24e2da778bd47c1e3b3862ac35b1a37be8a5fd55697898cff76125Add_liquidity364858672022-11-09 2:45:1222 days 20 hrs ago0xafa7f1c822981c7a60651ad60040d81d38bec692 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.05 ETH0.00002549
0x9fad12750cfdf2fdf39f95d79ab94a540d2a8d70a34654846e0df6951e376e9bAdd_liquidity364641422022-11-09 0:53:4422 days 22 hrs ago0xb4400d07a73a4d375dcb2d5c3b5501dee9592761 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.19 ETH0.00003698
0x18d9bab40d93cd115cca3a33141b46148d230a5285af0ac604629bb3295fb7d2Add_liquidity364551572022-11-09 0:04:0222 days 22 hrs ago0x2a098e77572a7d9911af527ce9e19c90c3addf26 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.1 ETH0.00004584
0x98572e812167ba038b7f7078052558ea29908f8ed70f208d6273a06b2df6d643Add_liquidity363783972022-11-08 17:49:4323 days 5 hrs ago0xca4d7fc782622d023bdfa10bd56e9b5dbcd5c73d IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.0001 ETH0.00016211
0xfef36b76a893788468dfe0881e3bdd078d19f4981e5b34d1310feee7b7900801Exchange363681232022-11-08 17:03:2323 days 5 hrs ago0xca4d7fc782622d023bdfa10bd56e9b5dbcd5c73d IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.0001 ETH0.00016971
0x0b2f050218c7647b64b4b63ebc641248b9c30ef3a9d5e6dae65356834c49bcbeAdd_liquidity362190582022-11-08 5:56:4523 days 16 hrs ago0xcea8a975a2e2d5868671f84bb535ec90f456c057 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.1 ETH0.00005083
0x384aa22ec3e0575de94c29bae212191174befb71aff9ae2f39382f517bbe02d8Remove_liquidity...361405772022-11-07 23:11:5923 days 23 hrs ago0x4c9f98b5c780fad0187eeefe4f1905ef7cd92649 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00 ETH0.00101355
0x77d3ac42db92b1d985919e0cef6e715c5d11c64407f48615956d9a95d8c886c2Add_liquidity361314852022-11-07 22:27:0624 days 27 mins ago0x8a91695a45606e132bd211f65cdc76998bf9aae5 IN 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.05 ETH0.00003646
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0xc1cad5a2efd7ad94296d0a92f13c31ac2329be2c23c94b55a24df207adea1c20426130092022-12-01 4:47:4118 hrs 6 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xc1cad5a2efd7ad94296d0a92f13c31ac2329be2c23c94b55a24df207adea1c20426130092022-12-01 4:47:4118 hrs 6 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00xcab86f6fb6d1c2cbeeb97854a0c023446a075fe30 ETH
0xc1cad5a2efd7ad94296d0a92f13c31ac2329be2c23c94b55a24df207adea1c20426130092022-12-01 4:47:4118 hrs 6 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xc1cad5a2efd7ad94296d0a92f13c31ac2329be2c23c94b55a24df207adea1c20426130092022-12-01 4:47:4118 hrs 6 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xc1cad5a2efd7ad94296d0a92f13c31ac2329be2c23c94b55a24df207adea1c20426130092022-12-01 4:47:4118 hrs 6 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e0 0x7da64233fefb352f8f501b357c018158ed8aa4550 ETH
0xc1cad5a2efd7ad94296d0a92f13c31ac2329be2c23c94b55a24df207adea1c20426130092022-12-01 4:47:4118 hrs 6 mins ago 0x521709b3cd7f07e29722be0ba28a8ce0e806dbc30x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00.14 ETH
0xf6f3da2ff70a9ab38ff0391f8be95abe62d87e51249c24af113c61959e0f840f425789872022-12-01 1:04:0321 hrs 50 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e0 0x521709b3cd7f07e29722be0ba28a8ce0e806dbc30.009674111286649255 ETH
0xf6f3da2ff70a9ab38ff0391f8be95abe62d87e51249c24af113c61959e0f840f425789872022-12-01 1:04:0321 hrs 50 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xf6f3da2ff70a9ab38ff0391f8be95abe62d87e51249c24af113c61959e0f840f425789872022-12-01 1:04:0321 hrs 50 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xf6f3da2ff70a9ab38ff0391f8be95abe62d87e51249c24af113c61959e0f840f425789872022-12-01 1:04:0321 hrs 50 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00xcab86f6fb6d1c2cbeeb97854a0c023446a075fe30 ETH
0xf6f3da2ff70a9ab38ff0391f8be95abe62d87e51249c24af113c61959e0f840f425789872022-12-01 1:04:0321 hrs 50 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xf6f3da2ff70a9ab38ff0391f8be95abe62d87e51249c24af113c61959e0f840f425789872022-12-01 1:04:0321 hrs 50 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xf6f3da2ff70a9ab38ff0391f8be95abe62d87e51249c24af113c61959e0f840f425789872022-12-01 1:04:0321 hrs 50 mins ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e0 0x7da64233fefb352f8f501b357c018158ed8aa4550 ETH
0xf6f3da2ff70a9ab38ff0391f8be95abe62d87e51249c24af113c61959e0f840f425789872022-12-01 1:04:0321 hrs 50 mins ago 0x521709b3cd7f07e29722be0ba28a8ce0e806dbc30x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00 ETH
0xaf4a80eba8e32cabac29cd0f20afdd543a6c84f3eb2b31ae18a65bccc8a04610425378262022-11-30 20:40:581 day 2 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e0 0x521709b3cd7f07e29722be0ba28a8ce0e806dbc30.104589726747870327 ETH
0xaf4a80eba8e32cabac29cd0f20afdd543a6c84f3eb2b31ae18a65bccc8a04610425378262022-11-30 20:40:581 day 2 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xaf4a80eba8e32cabac29cd0f20afdd543a6c84f3eb2b31ae18a65bccc8a04610425378262022-11-30 20:40:581 day 2 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xaf4a80eba8e32cabac29cd0f20afdd543a6c84f3eb2b31ae18a65bccc8a04610425378262022-11-30 20:40:581 day 2 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00xcab86f6fb6d1c2cbeeb97854a0c023446a075fe30 ETH
0xaf4a80eba8e32cabac29cd0f20afdd543a6c84f3eb2b31ae18a65bccc8a04610425378262022-11-30 20:40:581 day 2 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xaf4a80eba8e32cabac29cd0f20afdd543a6c84f3eb2b31ae18a65bccc8a04610425378262022-11-30 20:40:581 day 2 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xaf4a80eba8e32cabac29cd0f20afdd543a6c84f3eb2b31ae18a65bccc8a04610425378262022-11-30 20:40:581 day 2 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e0 0x7da64233fefb352f8f501b357c018158ed8aa4550 ETH
0xaf4a80eba8e32cabac29cd0f20afdd543a6c84f3eb2b31ae18a65bccc8a04610425378262022-11-30 20:40:581 day 2 hrs ago 0x521709b3cd7f07e29722be0ba28a8ce0e806dbc30x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00 ETH
0xa5752a1798cdc554b16cfb883e92982d13e79f58aa54c6e58054ad8aa3ad508b425035372022-11-30 17:45:361 day 5 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
0xa5752a1798cdc554b16cfb883e92982d13e79f58aa54c6e58054ad8aa3ad508b425035372022-11-30 17:45:361 day 5 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00xcab86f6fb6d1c2cbeeb97854a0c023446a075fe30 ETH
0xa5752a1798cdc554b16cfb883e92982d13e79f58aa54c6e58054ad8aa3ad508b425035372022-11-30 17:45:361 day 5 hrs ago 0x0a824b5d4c96ea0ec46306efbd34bf88fe1277e00x00000000000000000000000000000000000000040 ETH
[ Download CSV Export 
Loading

Minimal Proxy Contract for 0x7da64233fefb352f8f501b357c018158ed8aa455

Contract Name:
Vyper_contract

Compiler Version
vyper:0.2.15

Optimization Enabled:
N/A

Other Settings:
, None license
Decompile ByteCode

Contract Source Code (Vyper language format)

# @version 0.2.15
"""
@title StableSwap
@author Curve.Fi
@license Copyright (c) Curve.Fi, 2020-2021 - all rights reserved
@notice 2 coin pool implementation with no lending
@dev ERC20 support for return True/revert, return True/False, return None
     Uses native Ether as coins[0]
"""

from vyper.interfaces import ERC20

interface Factory:
    def convert_fees() -> bool: nonpayable
    def get_fee_receiver(_pool: address) -> address: view
    def admin() -> address: 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 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


N_COINS: constant(int128) = 2
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

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_multipliers: uint256[N_COINS]

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

balanceOf: public(HashMap[address, uint256])
allowance: public(HashMap[address, HashMap[address, uint256]])
totalSupply: public(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],
    _coins: address[4],
    _rate_multipliers: uint256[4],
    _A: uint256,
    _fee: uint256,
):
    """
    @notice Contract constructor
    @param _name Name of the new pool
    @param _symbol Token symbol
    @param _coins List of all ERC20 conract addresses of coins
    @param _rate_multipliers List of number of decimals in coins
    @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

    # additional sanity checks for ETH configuration
    assert _coins[0] == 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE
    assert _rate_multipliers[0] == 10**18

    for i in range(N_COINS):
        coin: address = _coins[i]
        if coin == ZERO_ADDRESS:
            break
        self.coins[i] = coin
        self.rate_multipliers[i] = _rate_multipliers[i]

    A: uint256 = _A * A_PRECISION
    self.initial_A = A
    self.future_A = A
    self.fee = _fee
    self.factory = msg.sender

    self.name = concat("Curve.fi Factory Pool: ", _name)
    self.symbol = concat(_symbol, "-f")

    # 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


### StableSwap Functionality ###

@view
@external
def get_balances() -> uint256[N_COINS]:
    return self.balances


@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
    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 * D / _xp[0] * D / _xp[1] / (N_COINS)**2
        Dprev: uint256 = 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()
    xp: uint256[N_COINS] = self._xp_mem(self.rate_multipliers, 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()
    balances: uint256[N_COINS] = self.balances

    D0: uint256 = self.get_D_mem(self.rate_multipliers, 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(self.rate_multipliers, balances, amp)
    diff: uint256 = 0
    if _is_deposit:
        diff = D1 - D0
    else:
        diff = D0 - D1
    return diff * self.totalSupply / D0


@payable
@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()
    old_balances: uint256[N_COINS] = self.balances
    rates: uint256[N_COINS] = self.rate_multipliers

    # Initial invariant
    D0: uint256 = self.get_D_mem(rates, old_balances, amp)

    total_supply: uint256 = self.totalSupply
    new_balances: uint256[N_COINS] = old_balances
    for i in range(N_COINS):
        amount: uint256 = _amounts[i]
        if total_supply == 0:
            assert amount > 0  # dev: initial deposit requires all coins
        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, "Slippage screwed you"

    # Take coins from the sender
    assert msg.value == _amounts[0]
    if _amounts[1] > 0:
        response: Bytes[32] = raw_call(
            self.coins[1],
            concat(
                method_id("transferFrom(address,address,uint256)"),
                convert(msg.sender, bytes32),
                convert(self, bytes32),
                convert(_amounts[1], bytes32),
            ),
            max_outsize=32,
        )
        if len(response) > 0:
            assert convert(response, bool)  # dev: failed transfer
        # end "safeTransferFrom"

    # 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:
    """
    Calculate x[j] if one makes x[i] = x

    Done by solving quadratic equation iteratively.
    x_1**2 + x_1 * (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 != 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_multipliers
    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]


@payable
@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
    @return Actual amount of `j` received
    """
    rates: uint256[N_COINS] = self.rate_multipliers
    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, "Exchange resulted in fewer coins than expected"

    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

    coin: address = self.coins[1]
    if i == 0:
        assert msg.value == _dx
        response: Bytes[32] = raw_call(
            coin,
            concat(
                method_id("transfer(address,uint256)"),
                convert(_receiver, bytes32),
                convert(dy, bytes32),
            ),
            max_outsize=32,
        )
        if len(response) > 0:
            assert convert(response, bool)
    else:
        assert msg.value == 0
        response: Bytes[32] = raw_call(
            coin,
            concat(
                method_id("transferFrom(address,address,uint256)"),
                convert(msg.sender, bytes32),
                convert(self, bytes32),
                convert(_dx, bytes32),
            ),
            max_outsize=32,
        )
        if len(response) > 0:
            assert convert(response, bool)
        raw_call(_receiver, b"", value=dy)

    log TokenExchange(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], "Withdrawal resulted in fewer coins than expected"
        self.balances[i] = old_balance - value
        amounts[i] = value

        if i == 0:
            raw_call(_receiver, b"", value=value)
        else:
            response: Bytes[32] = raw_call(
                self.coins[1],
                concat(
                    method_id("transfer(address,uint256)"),
                    convert(_receiver, bytes32),
                    convert(value, bytes32),
                ),
                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_multipliers
    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):
        new_balances[i] -= _amounts[i]
    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, "Slippage screwed you"

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

    if _amounts[0] != 0:
        raw_call(_receiver, b"", value=_amounts[0])
    if _amounts[1] != 0:
        response: Bytes[32] = raw_call(
            self.coins[1],
            concat(
                method_id("transfer(address,uint256)"),
                convert(_receiver, bytes32),
                convert(_amounts[1], bytes32),
            ),
            max_outsize=32,
        )
        if len(response) > 0:
            assert convert(response, bool)

    log RemoveLiquidityImbalance(msg.sender, _amounts, fees, D1, total_supply)

    return burn_amount


@pure
@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 + x_1 * (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_multipliers
    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, "Not enough coins removed"

    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)

    if i == 0:
        raw_call(_receiver, b"", value=dy[0])
    else:
        response: Bytes[32] = raw_call(
            self.coins[1],
            concat(
                method_id("transfer(address,uint256)"),
                convert(_receiver, bytes32),
                convert(dy[0], bytes32),
            ),
            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:
    if i == 0:
        return self.balance - self.balances[0]
    else:
        return ERC20(self.coins[i]).balanceOf(self) - self.balances[i]


@external
def withdraw_admin_fees():
    receiver: address = Factory(self.factory).get_fee_receiver(self)

    fees: uint256 = self.balance - self.balances[0]
    raw_call(receiver, b"", value=fees)

    coin: address = self.coins[1]
    fees = ERC20(coin).balanceOf(self) - self.balances[1]
    raw_call(
    coin,
    concat(
        method_id("transfer(address,uint256)"),
        convert(receiver, bytes32),
        convert(fees, bytes32)
    )
)

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":"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":"_coins","type":"address[4]"},{"name":"_rate_multipliers","type":"uint256[4]"},{"name":"_A","type":"uint256"},{"name":"_fee","type":"uint256"}],"outputs":[],"gas":471696},{"stateMutability":"view","type":"function","name":"decimals","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":318},{"stateMutability":"nonpayable","type":"function","name":"transfer","inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"gas":77977},{"stateMutability":"nonpayable","type":"function","name":"transferFrom","inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"gas":115912},{"stateMutability":"nonpayable","type":"function","name":"approve","inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"gas":37851},{"stateMutability":"view","type":"function","name":"get_balances","inputs":[],"outputs":[{"name":"","type":"uint256[2]"}],"gas":4707},{"stateMutability":"view","type":"function","name":"admin_fee","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":468},{"stateMutability":"view","type":"function","name":"A","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":10764},{"stateMutability":"view","type":"function","name":"A_precise","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":10726},{"stateMutability":"view","type":"function","name":"get_virtual_price","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":848656},{"stateMutability":"view","type":"function","name":"calc_token_amount","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_is_deposit","type":"bool"}],"outputs":[{"name":"","type":"uint256"}],"gas":3336308},{"stateMutability":"payable","type":"function","name":"add_liquidity","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_min_mint_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"payable","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"}]},{"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":2117591},{"stateMutability":"payable","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"}]},{"stateMutability":"payable","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"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"_min_amounts","type":"uint256[2]"}],"outputs":[{"name":"","type":"uint256[2]"}]},{"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]"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_imbalance","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_max_burn_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"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"}]},{"stateMutability":"view","type":"function","name":"calc_withdraw_one_coin","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"i","type":"int128"}],"outputs":[{"name":"","type":"uint256"}],"gas":1100},{"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"}]},{"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"}]},{"stateMutability":"nonpayable","type":"function","name":"ramp_A","inputs":[{"name":"_future_A","type":"uint256"},{"name":"_future_time","type":"uint256"}],"outputs":[],"gas":162101},{"stateMutability":"nonpayable","type":"function","name":"stop_ramp_A","inputs":[],"outputs":[],"gas":157565},{"stateMutability":"view","type":"function","name":"admin_balances","inputs":[{"name":"i","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":7784},{"stateMutability":"nonpayable","type":"function","name":"withdraw_admin_fees","inputs":[],"outputs":[],"gas":59903},{"stateMutability":"view","type":"function","name":"coins","inputs":[{"name":"arg0","type":"uint256"}],"outputs":[{"name":"","type":"address"}],"gas":3093},{"stateMutability":"view","type":"function","name":"balances","inputs":[{"name":"arg0","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":3123},{"stateMutability":"view","type":"function","name":"fee","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3108},{"stateMutability":"view","type":"function","name":"initial_A","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3138},{"stateMutability":"view","type":"function","name":"future_A","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3168},{"stateMutability":"view","type":"function","name":"initial_A_time","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3198},{"stateMutability":"view","type":"function","name":"future_A_time","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3228},{"stateMutability":"view","type":"function","name":"name","inputs":[],"outputs":[{"name":"","type":"string"}],"gas":13488},{"stateMutability":"view","type":"function","name":"symbol","inputs":[],"outputs":[{"name":"","type":"string"}],"gas":11241},{"stateMutability":"view","type":"function","name":"balanceOf","inputs":[{"name":"arg0","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":3533},{"stateMutability":"view","type":"function","name":"allowance","inputs":[{"name":"arg0","type":"address"},{"name":"arg1","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":3778},{"stateMutability":"view","type":"function","name":"totalSupply","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3378}]

Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.