Contract 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7

 
Txn Hash Method
Block
From
To
Value
0x441aff36011a215965562365d2a99edc1f5f746b2bf53744d9d48dddb53f828aRemove_liquidity...469717322022-12-09 3:17:173 hrs 53 mins ago0x8238892095d3bac5322894e84f349bcd52f843d5 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000526846170.001
0xeb7ac7f20bb368a1a6a7f6c2ee2fa99294cd558ce8f3d7d73a92617a1851a78cRemove_liquidity469192142022-12-08 22:42:238 hrs 28 mins ago0x71f12a5b0e60d2ff8a87fd34e7dcff3c10c914b0 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000588772950.001
0x3377517befec27c317172ac4c0e244c8c1d2d6fc7bb10302acae801ec7cb6d6dRemove_liquidity...469138592022-12-08 22:03:579 hrs 7 mins ago0x71f12a5b0e60d2ff8a87fd34e7dcff3c10c914b0 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000552780330.001
0xf2261476a29468eb03b808f0680ef9e7cf984c1e5a02a9b8b2e2dd546cea82faRemove_liquidity...468733582022-12-08 18:19:5412 hrs 51 mins ago0x17677b2ca8c5948cc48d7edec07f7c68c845c023 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000625109360.001
0x0dd418089d01896ebf88b3211dc6c726a3021f99c99a70ee3db90eb5ac5c34f8Remove_liquidity...468657642022-12-08 17:38:2313 hrs 32 mins ago0xf856034e9264f13ac8b5140f43068604c9ae41e8 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000915845580.001
0x3de67f4151667eeb91e6b1318d2cd2130c9f89007007a6b5dc1fdc60652ca3f0Remove_liquidity...467251432022-12-08 10:38:1720 hrs 32 mins ago0xe67c6918fcfd1e5f998eb80de843b71dc0bbd4e3 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000582385450.001
0x76f56c0ff7e2e2d0a1bcd3b71125b7d0503582b1cb5b9914baf8e43dc601212cRemove_liquidity...465639252022-12-08 3:05:461 day 4 hrs ago0x09fa38eba245bb68354b8950fa2fe71f02863393 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000593336830.001
0xaa8a71cbc584b5baa548bd9eac612d30a66db46b797103e927ce5f5a287f62c4Add_liquidity465570712022-12-08 2:47:011 day 4 hrs ago0x0351b0b81fdd1db5dad0617d97c598cd3c37baaf IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000593396860.001
0xd0f13235f243710245c81d145b2aabd476105169df0daf04c13b23eaa2c9d7faApprove465221242022-12-08 0:04:031 day 7 hrs ago0x71f12a5b0e60d2ff8a87fd34e7dcff3c10c914b0 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000690535170.001
0x33886e92fc8b6f61bbb7bbeec2c39640f6b0699856bb7d6b35df7c5c384b37f3Add_liquidity465219822022-12-08 0:03:011 day 7 hrs ago0x71f12a5b0e60d2ff8a87fd34e7dcff3c10c914b0 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000566167120.001
0x3f73b6816cfaa1a188d63ad5d657d9ab9af449289e4f4bb65a8dff304d9a4a54Approve465067932022-12-07 22:10:141 day 9 hrs ago0x17677b2ca8c5948cc48d7edec07f7c68c845c023 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000649309240.001
0x810948708a2d941a4afbd5e78815381a400e10edf40d6bd548b766120f792126Add_liquidity465067432022-12-07 22:09:441 day 9 hrs ago0x17677b2ca8c5948cc48d7edec07f7c68c845c023 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000605101070.001
0x93df4062c0c1d8963071ec5038e976d227cceb81194a3f6e4ccab299841beb09Approve464883472022-12-07 20:13:241 day 10 hrs ago0x8238892095d3bac5322894e84f349bcd52f843d5 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000640133150.001
0x6035ec4de4b432bc56d10e118fa4e20377048d7f179e65244a0338a1e5eaab74Add_liquidity464882832022-12-07 20:12:541 day 10 hrs ago0x8238892095d3bac5322894e84f349bcd52f843d5 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000699855650.001
0x902e7cd3f09f513d996b53d961d7bd2417871bd28ee443c618a0d8fd73fbb933Approve461651402022-12-06 23:08:102 days 8 hrs ago0xed4c4aab2232319481745849f3406397bebaeaa2 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000613942670.001
0xb2a99dcf202af18cb6d01bb182bc07a7ec19dae3ba892b72b1a629959393f099Add_liquidity461644242022-12-06 23:02:062 days 8 hrs ago0xed4c4aab2232319481745849f3406397bebaeaa2 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.000057509590.001
0xeb2b5378fb1e3e2f6288dc00a2c026ced94c64306441741060d5bc8df0c1df5aApprove458985912022-12-06 5:28:363 days 1 hr ago0xe67c6918fcfd1e5f998eb80de843b71dc0bbd4e3 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000590633190.001
0x3dd339196bba0b99bec0cb8b168b1b78a5acfb297a8101fa04a9176733ae2306Add_liquidity458970602022-12-06 5:22:353 days 1 hr ago0xe67c6918fcfd1e5f998eb80de843b71dc0bbd4e3 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000581735580.001
0x361182fc26f3c730e7117e23b431ce24409baee6384e0f516396db0ef405a0fcRemove_liquidity...449973652022-12-03 14:43:225 days 16 hrs ago0xe765c1f860d1d949af634e0cac67bbe161b8eb58 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000465357940.001
0x2f3c1626e65ca2b830791a204ddbe975d3e449935bc053f4e56d55a1022e2493Remove_liquidity...449957672022-12-03 14:37:375 days 16 hrs ago0xed2170462e997b9590f77bf2cd3cd283b877eade IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.000045080320.001
0x5f4d371001a2247cefe50c0f444ef7bf7d64a25b7f167fe9671d92eb5736a242Remove_liquidity...449926622022-12-03 14:26:215 days 16 hrs ago0x8cdd5b195f0b0922ced3a8feafa80ede9ebe0299 IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000449533450.001
0x26f7652a36642c6a5b3054cca1cf839a4fb13862bf6fb9245f49e3b8e53856f5Remove_liquidity...444141792022-12-02 1:04:557 days 6 hrs ago0x0351b0b81fdd1db5dad0617d97c598cd3c37baaf IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000463947410.001
0x517fa24f507f76069503773f8f8d26b54b5862f386540d0f5e30503c66ae169fAdd_liquidity443992182022-12-01 23:11:357 days 7 hrs ago0x64349bc61d02c07e2f6e51be6d2d6bbe9681f32e IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000455720750.001
0xc2dff398961d99419a3085f3b27144fea4355ef960c1f08d2b3529173be49cb8Approve437573132022-11-30 5:42:469 days 1 hr ago0x7f055f4d9035ccc9678c4173856056fd87b2db6d IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000430420190.001
0x6315a0a463c00c6b30970f54bbcce2473ff471f871ce389ef62963ad0ce12d10Approve437551492022-11-30 5:33:299 days 1 hr ago0x7f055f4d9035ccc9678c4173856056fd87b2db6d IN 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether0.0000455302710.001
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0xf9c873ebf106ed3040cb2cdfe6c5cb466bf41a3f0a52afc63f1a3cfb79eca73d470436882022-12-09 7:09:161 min ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0xf9c873ebf106ed3040cb2cdfe6c5cb466bf41a3f0a52afc63f1a3cfb79eca73d470436882022-12-09 7:09:161 min ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0xf9c873ebf106ed3040cb2cdfe6c5cb466bf41a3f0a52afc63f1a3cfb79eca73d470436882022-12-09 7:09:161 min ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0xf9c873ebf106ed3040cb2cdfe6c5cb466bf41a3f0a52afc63f1a3cfb79eca73d470436882022-12-09 7:09:161 min ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x242b577207794cfb466ce544f8003b49a26b875dc5814c847e87af0f0b2de8df470432582022-12-09 7:08:012 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x28993ba49dc7cfaac54074fb92773e7f0c90ea0b8ea5d098b4306ab28e7f2eb2470390012022-12-09 6:54:0016 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x28993ba49dc7cfaac54074fb92773e7f0c90ea0b8ea5d098b4306ab28e7f2eb2470390012022-12-09 6:54:0016 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x28993ba49dc7cfaac54074fb92773e7f0c90ea0b8ea5d098b4306ab28e7f2eb2470390012022-12-09 6:54:0016 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x28993ba49dc7cfaac54074fb92773e7f0c90ea0b8ea5d098b4306ab28e7f2eb2470390012022-12-09 6:54:0016 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x1579803a4ebfdc3fa6cb81d16b5da08d2c72013cd5af78149e8a3a4cebfe8806470386532022-12-09 6:53:0017 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x1579803a4ebfdc3fa6cb81d16b5da08d2c72013cd5af78149e8a3a4cebfe8806470386532022-12-09 6:53:0017 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x1579803a4ebfdc3fa6cb81d16b5da08d2c72013cd5af78149e8a3a4cebfe8806470386532022-12-09 6:53:0017 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x1579803a4ebfdc3fa6cb81d16b5da08d2c72013cd5af78149e8a3a4cebfe8806470386532022-12-09 6:53:0017 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x1579803a4ebfdc3fa6cb81d16b5da08d2c72013cd5af78149e8a3a4cebfe8806470386532022-12-09 6:53:0017 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
0x1579803a4ebfdc3fa6cb81d16b5da08d2c72013cd5af78149e8a3a4cebfe8806470386532022-12-09 6:53:0017 mins ago 0x54dcfe120d608551f9010d3b66620d230fd5c11b0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe70 Ether
0x1579803a4ebfdc3fa6cb81d16b5da08d2c72013cd5af78149e8a3a4cebfe8806470386532022-12-09 6:53:0017 mins ago 0x29a3d66b30bc4ad674a4fdaf27578b64f6afbfe7 0xc2b1df84112619d190193e48148000e3990bf6270 Ether
[ Download CSV Export 
Loading

Minimal Proxy Contract for 0xc2b1df84112619d190193e48148000e3990bf627

Contract Name:
Vyper_contract

Compiler Version
vyper:0.3.1

Optimization Enabled:
N/A

Other Settings:
None license
Decompile ByteCode

Contract Source Code (Vyper language format)

# @version 0.3.1
"""
@title StableSwap
@author Curve.Fi
@license Copyright (c) Curve.Fi, 2020-2021 - all rights reserved
@notice 2 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

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


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

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

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

event 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

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

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


factory: address

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

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

rate_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)

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


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


@external
def initialize(
    _name: String[32],
    _symbol: String[10],
    _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

    name: String[64] = concat("Curve.fi Factory Plain Pool: ", _name)
    self.name = name
    self.symbol = concat(_symbol, "-f")

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

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


### ERC20 Functionality ###

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


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

    log Transfer(_from, _to, _value)


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


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

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

    return True


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

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


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

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

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

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

    log Approval(_owner, _spender, _value)
    return True


### StableSwap Functionality ###

@view
@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


@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)
            )
        )


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

Contract ABI

[{"name":"Transfer","inputs":[{"name":"sender","type":"address","indexed":true},{"name":"receiver","type":"address","indexed":true},{"name":"value","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"Approval","inputs":[{"name":"owner","type":"address","indexed":true},{"name":"spender","type":"address","indexed":true},{"name":"value","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"TokenExchange","inputs":[{"name":"buyer","type":"address","indexed":true},{"name":"sold_id","type":"int128","indexed":false},{"name":"tokens_sold","type":"uint256","indexed":false},{"name":"bought_id","type":"int128","indexed":false},{"name":"tokens_bought","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"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":516829},{"stateMutability":"view","type":"function","name":"decimals","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":390},{"stateMutability":"nonpayable","type":"function","name":"transfer","inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"gas":79005},{"stateMutability":"nonpayable","type":"function","name":"transferFrom","inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"gas":116985},{"stateMutability":"nonpayable","type":"function","name":"approve","inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}],"gas":39211},{"stateMutability":"nonpayable","type":"function","name":"permit","inputs":[{"name":"_owner","type":"address"},{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"},{"name":"_deadline","type":"uint256"},{"name":"_v","type":"uint8"},{"name":"_r","type":"bytes32"},{"name":"_s","type":"bytes32"}],"outputs":[{"name":"","type":"bool"}],"gas":102281},{"stateMutability":"view","type":"function","name":"get_balances","inputs":[],"outputs":[{"name":"","type":"uint256[2]"}],"gas":4782},{"stateMutability":"view","type":"function","name":"admin_fee","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":570},{"stateMutability":"view","type":"function","name":"A","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":10508},{"stateMutability":"view","type":"function","name":"A_precise","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":10508},{"stateMutability":"view","type":"function","name":"get_virtual_price","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":649135},{"stateMutability":"view","type":"function","name":"calc_token_amount","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_is_deposit","type":"bool"}],"outputs":[{"name":"","type":"uint256"}],"gas":1284256},{"stateMutability":"nonpayable","type":"function","name":"add_liquidity","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_min_mint_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":2144257},{"stateMutability":"nonpayable","type":"function","name":"add_liquidity","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_min_mint_amount","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":2144257},{"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":995830},{"stateMutability":"nonpayable","type":"function","name":"exchange","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"_dx","type":"uint256"},{"name":"_min_dy","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":1150187},{"stateMutability":"nonpayable","type":"function","name":"exchange","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"_dx","type":"uint256"},{"name":"_min_dy","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":1150187},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"_min_amounts","type":"uint256[2]"}],"outputs":[{"name":"","type":"uint256[2]"}],"gas":241198},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"_min_amounts","type":"uint256[2]"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256[2]"}],"gas":241198},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_imbalance","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_max_burn_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":2144337},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_imbalance","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_max_burn_amount","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":2144337},{"stateMutability":"view","type":"function","name":"calc_withdraw_one_coin","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"i","type":"int128"}],"outputs":[{"name":"","type":"uint256"}],"gas":1229},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_one_coin","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"i","type":"int128"},{"name":"_min_received","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":1535032},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_one_coin","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"i","type":"int128"},{"name":"_min_received","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":1535032},{"stateMutability":"nonpayable","type":"function","name":"ramp_A","inputs":[{"name":"_future_A","type":"uint256"},{"name":"_future_time","type":"uint256"}],"outputs":[],"gas":161164},{"stateMutability":"nonpayable","type":"function","name":"stop_ramp_A","inputs":[],"outputs":[],"gas":157387},{"stateMutability":"view","type":"function","name":"admin_balances","inputs":[{"name":"i","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":7829},{"stateMutability":"nonpayable","type":"function","name":"withdraw_admin_fees","inputs":[],"outputs":[],"gas":28911},{"stateMutability":"pure","type":"function","name":"version","inputs":[],"outputs":[{"name":"","type":"string"}],"gas":6677},{"stateMutability":"view","type":"function","name":"coins","inputs":[{"name":"arg0","type":"uint256"}],"outputs":[{"name":"","type":"address"}],"gas":3225},{"stateMutability":"view","type":"function","name":"balances","inputs":[{"name":"arg0","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}],"gas":3255},{"stateMutability":"view","type":"function","name":"fee","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3240},{"stateMutability":"view","type":"function","name":"initial_A","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3270},{"stateMutability":"view","type":"function","name":"future_A","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3300},{"stateMutability":"view","type":"function","name":"initial_A_time","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3330},{"stateMutability":"view","type":"function","name":"future_A_time","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3360},{"stateMutability":"view","type":"function","name":"name","inputs":[],"outputs":[{"name":"","type":"string"}],"gas":13679},{"stateMutability":"view","type":"function","name":"symbol","inputs":[],"outputs":[{"name":"","type":"string"}],"gas":11438},{"stateMutability":"view","type":"function","name":"balanceOf","inputs":[{"name":"arg0","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":3716},{"stateMutability":"view","type":"function","name":"allowance","inputs":[{"name":"arg0","type":"address"},{"name":"arg1","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":4012},{"stateMutability":"view","type":"function","name":"totalSupply","inputs":[],"outputs":[{"name":"","type":"uint256"}],"gas":3510},{"stateMutability":"view","type":"function","name":"DOMAIN_SEPARATOR","inputs":[],"outputs":[{"name":"","type":"bytes32"}],"gas":3540},{"stateMutability":"view","type":"function","name":"nonces","inputs":[{"name":"arg0","type":"address"}],"outputs":[{"name":"","type":"uint256"}],"gas":3836}]

Block Transaction Difficulty Gas Used Reward
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.