Contract 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb1974 1

 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x4c1c991c9d587ad45fc7df45d1acc99b865e60256ad507619b947e3a40625acdExchange129357552022-05-25 14:24:001 day 9 hrs ago0xa8fa0bb37f3a586bd812b847c0b818e1d2abdc93 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000134920422 ETH
0x3f450a76f89a2423cedea0b5f004fed06d81a7573c76c5425f8d2be547c849d7Exchange129354772022-05-25 14:20:021 day 9 hrs ago0xa8fa0bb37f3a586bd812b847c0b818e1d2abdc93 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000133400545 ETH
0x2055c02f712b3c25a6e93beba4b97f814e493c5a1b021538ab42c56bc2b51e94Approve129352442022-05-25 14:16:291 day 9 hrs ago0xa8fa0bb37f3a586bd812b847c0b818e1d2abdc93 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000114885571 ETH
0xad0d38b10e1498573ed1354b32a1ad7543158d391f4fd0583e44cc8dd0da5e45Approve126548872022-05-21 17:44:045 days 6 hrs ago0xf85d965e9fd4607b000110253214f49231f0031a IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000101603725 ETH
0xdbd9bf9c0d673c0b122cdfedbcca17aee7ad262024457cb6acbb1c9de50f124aExchange125602382022-05-20 13:08:506 days 11 hrs ago0xa8fa0bb37f3a586bd812b847c0b818e1d2abdc93 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.00013775149 ETH
0xecb0789368920a8aa72640a6e6d40d907c1efa51991abd89b7171f16bdd03c85Exchange125601312022-05-20 13:06:016 days 11 hrs ago0xa8fa0bb37f3a586bd812b847c0b818e1d2abdc93 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000128767822 ETH
0xfab57aa8920cee23b1044acf88291d929d79768910f7921a38f0312dfdd56903Approve125600342022-05-20 13:05:036 days 11 hrs ago0xa8fa0bb37f3a586bd812b847c0b818e1d2abdc93 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000121259369 ETH
0x9a0264e415e7e3142d453d66b41b3a454d1e53457e42bfd70a8ea0dcd98a3e16Exchange125589722022-05-20 12:50:546 days 11 hrs ago0xeb23ca04ff69044d9fde120a030f3243a453da65 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000128767822 ETH
0x4c5e5e02ff13c1725d1e8c716f8785cf3e86a8a62c9e269110f2aceb1d6d3ac4Exchange125584172022-05-20 12:42:466 days 11 hrs ago0xa8fa0bb37f3a586bd812b847c0b818e1d2abdc93 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000128767822 ETH
0x4dd5420aec536013eeb1065b0e04663ce7b17432e350fd58ebc4aa18cc4d6579Exchange125581102022-05-20 12:37:056 days 11 hrs ago0xa8fa0bb37f3a586bd812b847c0b818e1d2abdc93 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000129060574 ETH
0x4f4a5becda851a7afc0a58d98143eabd4d443f41b91cac80bee6649e1bb47e13Exchange125577462022-05-20 12:32:406 days 11 hrs ago0xa8fa0bb37f3a586bd812b847c0b818e1d2abdc93 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000128767822 ETH
0x1c79db636d3d049bd86b61a8b88748c588ba9d2bb1301fa8ca4b14f54c30181dExchange125412022022-05-20 7:57:046 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112589493 ETH
0x3b957c93fe06a6d6cd835bdf1d63c6880c0ef071e6dd7e5070206e59e8a7c681Exchange125411692022-05-20 7:57:046 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112761375 ETH
0x7e272436b3cfbd77b766a0dc9868d1cedb531a3016e5545fbd09597c1ce8df3dExchange125411342022-05-20 7:57:046 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112387331 ETH
0x3c9b5637252b7825fb3963cce377b707a06502835636031d67b4fee441d20d48Exchange125411122022-05-20 7:56:036 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000113236946 ETH
0x42dcc65e3bc8779e2e52c593858de7e15a1142e8e8688fa14128417ece2ce2a9Exchange125411092022-05-20 7:56:036 days 16 hrs ago0x371f1f2726ea74664adbbf1c03bd18a7bf2e86b1 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000111162114 ETH
0xee2a539c3196e54c5c185263f7b8a16602ff85f852c4120e15ad65645cf276c9Exchange125411052022-05-20 7:56:036 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112178267 ETH
0xa3c737697a23c0dfe8dc1bd2903c3e5172c746b54136b6fe730eea78f93fec14Exchange125410582022-05-20 7:55:396 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112969771 ETH
0x74b214d22134bc96e9f4e68485b86ae0878c4af4b1057a7a2dcc5c5a7407120fExchange125410282022-05-20 7:53:246 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112892736 ETH
0x629d5d5f0c1a6de6192c59fe3518f56a672b40b22725b44dd1d308a853d9de53Exchange125410062022-05-20 7:53:246 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112485518 ETH
0x0324996ff627f82582baa5af664e567adb673669f8ff71f1cb1fd71e75adb7acExchange125409392022-05-20 7:52:576 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112662521 ETH
0x2d3caa21e29085d7a6ba03a1f2ac6c96fbed2c230c9db181cf9a59db4aa50802Exchange125409202022-05-20 7:52:576 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112892736 ETH
0x379e6beb979f8384c4f367968c6da911edf494ed80c9449f23172a66ec713f79Exchange125409132022-05-20 7:52:576 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112589493 ETH
0x7be3ec7aab349b69d039e308095cffd04969a3f4e90763f0b8b11e558f5a5a4dExchange125408742022-05-20 7:52:016 days 16 hrs ago0xd0c44bfe57153fabbdd02c98568ed88925eca578 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.0001128678 ETH
0x54c62ee751c008db9f681cb3e5fd46ece0660a7e58711e7b9041c21f81d43950Exchange125408612022-05-20 7:52:016 days 16 hrs ago0x371f1f2726ea74664adbbf1c03bd18a7bf2e86b1 IN 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH0.000112495759 ETH
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x4c1c991c9d587ad45fc7df45d1acc99b865e60256ad507619b947e3a40625acd129357552022-05-25 14:24:001 day 9 hrs ago 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb1974 0x8d53e5de033078367ad91527c53abfd1eb6bfa860 ETH
0x3f450a76f89a2423cedea0b5f004fed06d81a7573c76c5425f8d2be547c849d7129354772022-05-25 14:20:021 day 9 hrs ago 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb1974 0x8d53e5de033078367ad91527c53abfd1eb6bfa860 ETH
0x2055c02f712b3c25a6e93beba4b97f814e493c5a1b021538ab42c56bc2b51e94129352442022-05-25 14:16:291 day 9 hrs ago 0x1c5ffa4fb4907b681c61b8c82b28c4672ceb1974 0x8d53e5de033078367ad91527c53abfd1eb6bfa860 ETH
0x8fab9bbf39187fd3ccc0fe9bc42b97f252158e6c60933a5e0c9f7cd507218e13126775012022-05-22 4:03:374 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x8fab9bbf39187fd3ccc0fe9bc42b97f252158e6c60933a5e0c9f7cd507218e13126775012022-05-22 4:03:374 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x8fab9bbf39187fd3ccc0fe9bc42b97f252158e6c60933a5e0c9f7cd507218e13126775012022-05-22 4:03:374 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x8fab9bbf39187fd3ccc0fe9bc42b97f252158e6c60933a5e0c9f7cd507218e13126775012022-05-22 4:03:374 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0xf639606c4c14bfb43b132a6ef409e56d14f2e613dd96a71cb56496a8b4e8af86126774812022-05-22 4:03:374 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0xf639606c4c14bfb43b132a6ef409e56d14f2e613dd96a71cb56496a8b4e8af86126774812022-05-22 4:03:374 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0xf639606c4c14bfb43b132a6ef409e56d14f2e613dd96a71cb56496a8b4e8af86126774812022-05-22 4:03:374 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0xf639606c4c14bfb43b132a6ef409e56d14f2e613dd96a71cb56496a8b4e8af86126774812022-05-22 4:03:374 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x33277fff2f2aa5ce6193c85fc4c603e6523585f2d2e24f8fe4c9aab411222876126774332022-05-22 4:02:554 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x33277fff2f2aa5ce6193c85fc4c603e6523585f2d2e24f8fe4c9aab411222876126774332022-05-22 4:02:554 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x33277fff2f2aa5ce6193c85fc4c603e6523585f2d2e24f8fe4c9aab411222876126774332022-05-22 4:02:554 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x33277fff2f2aa5ce6193c85fc4c603e6523585f2d2e24f8fe4c9aab411222876126774332022-05-22 4:02:554 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x677c3f734860b5b3a980f4731f27f911377cd0978df3159502489548106b130d126773932022-05-22 4:01:254 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x677c3f734860b5b3a980f4731f27f911377cd0978df3159502489548106b130d126773932022-05-22 4:01:254 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x677c3f734860b5b3a980f4731f27f911377cd0978df3159502489548106b130d126773932022-05-22 4:01:254 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x677c3f734860b5b3a980f4731f27f911377cd0978df3159502489548106b130d126773932022-05-22 4:01:254 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x8455c6f88e91ceaf0dcb8c0f888e31ef12c7c4c838b51a7e2c5da9b2786b29ab126772342022-05-22 3:59:304 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x8455c6f88e91ceaf0dcb8c0f888e31ef12c7c4c838b51a7e2c5da9b2786b29ab126772342022-05-22 3:59:304 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x8455c6f88e91ceaf0dcb8c0f888e31ef12c7c4c838b51a7e2c5da9b2786b29ab126772342022-05-22 3:59:304 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x8455c6f88e91ceaf0dcb8c0f888e31ef12c7c4c838b51a7e2c5da9b2786b29ab126772342022-05-22 3:59:304 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x1b558e94e28f3111a9f1a3a4b5abe3c73e8693c74dd00f0c605784dcb85096b1126772222022-05-22 3:58:574 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
0x1b558e94e28f3111a9f1a3a4b5abe3c73e8693c74dd00f0c605784dcb85096b1126772222022-05-22 3:58:574 days 20 hrs ago 0x642758d0522a5f8bd49a55dca91e180888f11abd0x1c5ffa4fb4907b681c61b8c82b28c4672ceb19740 ETH
[ Download CSV Export 
Loading

Minimal Proxy Contract for 0x8d53e5de033078367ad91527c53abfd1eb6bfa86

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 4 coin pool implementation with no lending
@dev ERC20 support for return True/revert, return True/False, return None
"""

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) = 4
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

    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 Plain 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
    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()
    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


@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 amount > 0:
            response: Bytes[32] = raw_call(
                self.coins[i],
                concat(
                    method_id("transferFrom(address,address,uint256)"),
                    convert(msg.sender, bytes32),
                    convert(self, bytes32),
                    convert(amount, bytes32),
                ),
                max_outsize=32,
            )
            if len(response) > 0:
                assert convert(response, bool)  # dev: failed transfer
            new_balances[i] += amount
            # end "safeTransferFrom"
        else:
            assert total_supply != 0  # dev: initial deposit requires all coins

    # 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"

    # 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]


@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

    response: Bytes[32] = raw_call(
        self.coins[i],
        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)

    response = raw_call(
        self.coins[j],
        concat(
            method_id("transfer(address,uint256)"),
            convert(_receiver, bytes32),
            convert(dy, bytes32),
        ),
        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 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

        response: Bytes[32] = raw_call(
            self.coins[i],
            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):
        amount: uint256 = _amounts[i]
        if amount != 0:
            new_balances[i] -= amount
            response: Bytes[32] = raw_call(
                self.coins[i],
                concat(
                    method_id("transfer(address,uint256)"),
                    convert(_receiver, bytes32),
                    convert(amount, bytes32),
                ),
                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, "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)
    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)

    response: Bytes[32] = raw_call(
        self.coins[i],
        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:
    return ERC20(self.coins[i]).balanceOf(self) - self.balances[i]


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

    for i in range(N_COINS):
        coin: address = self.coins[i]
        fees: uint256 = ERC20(coin).balanceOf(self) - self.balances[i]
        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[4]","indexed":false},{"name":"fees","type":"uint256[4]","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[4]","indexed":false},{"name":"fees","type":"uint256[4]","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[4]","indexed":false},{"name":"fees","type":"uint256[4]","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":612238},{"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[4]"}],"gas":8943},{"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":1386501},{"stateMutability":"view","type":"function","name":"calc_token_amount","inputs":[{"name":"_amounts","type":"uint256[4]"},{"name":"_is_deposit","type":"bool"}],"outputs":[{"name":"","type":"uint256"}],"gas":5467590},{"stateMutability":"nonpayable","type":"function","name":"add_liquidity","inputs":[{"name":"_amounts","type":"uint256[4]"},{"name":"_min_mint_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"nonpayable","type":"function","name":"add_liquidity","inputs":[{"name":"_amounts","type":"uint256[4]"},{"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":3185773},{"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"}]},{"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"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"_min_amounts","type":"uint256[4]"}],"outputs":[{"name":"","type":"uint256[4]"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"_min_amounts","type":"uint256[4]"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256[4]"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_imbalance","inputs":[{"name":"_amounts","type":"uint256[4]"},{"name":"_max_burn_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_imbalance","inputs":[{"name":"_amounts","type":"uint256[4]"},{"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":7740},{"stateMutability":"nonpayable","type":"function","name":"withdraw_admin_fees","inputs":[],"outputs":[],"gas":60914},{"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
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.