![ads](/images/gen/moonpay_20.png)
15M+ users trust MoonPay. Checkout with your preferred payment method.
![ads](/images/gen/cons_20.png)
Ready to onboard to Ethereum? With MetaMask Portfolio, you're in control.
![ads](/images/gen/nexo.png)
Collect points for eligible actions and use multipliers to win big.
![ads](/images/gen/cons_20.png)
Ready to simplify your web3 experience? Try the all-in-one web3 app trusted by millions worldwide.
Opt-in, make your first trade on Exchange Plus & receive random crypto rewards from 10,000 SHIB, to 0.01 BTC.
![ads](/images/gen/zeedex_20.png?v2)
You will earn $Zdex as rewards by any trade or stake on ZeeDex exchange.
![ads](/images/gen/coinsgame_20a.png)
Everyday giveaways up to 100 ETH, Lucky Spins. Deposit BONUS 300% and Cashbacks!
![ads](/images/gen/megadice_20.png)
Play all your favorite Slots & Live Games, including Plinko, Aviator and Crash! Truly anonymous casino.
![ads](/images/gen/bcgames_20.png)
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
![ads](/images/gen/bcgames_20.png)
5000+ Slots & Live Casino Games, 50+cryptos. Register with Etherscan and get 760% deposit bonus. Win Big$, withdraw it fast.
![ads](/images/gen/cw_20.png)
Play 100s of games anonymously with all major cryptos. Join CryptoWins & start winning!
![ads](/images/gen/cryptoslots.png)
Anonymous play on awesome games - sign up now for 25 free jackpot spins - worth $100s!
Overview
ETH Balance
Eth Value
$32,684,061.91 (@ $3,478.43/ETH)Token Holdings
Could not find any matches!
- ERC-20 Tokens (26)15,384.33111742 stETHstETH (stETH)$53,436,243.39@3,473.4250,000 $+ $50 000 FO... ($)381.594 BGBGBigMouthFrog970.225 CHIPSBLUE CHIPS (CHIPS)0.14 OPTethopt.io$0.01@0.0453100 ICGInvest Club ... (ICG)69 ZHDZettahash (ZHD)1 HQG环球股 (HQG)5.7 TokenERC-20 TOKEN*[Suspicious]200 TokenERC-20 TOKEN*[Suspicious]1.7 TokenERC-20 TOKEN*[Suspicious]1 TokenERC-20 TOKEN*[Suspicious]329,562 TokenERC-20 TOKEN*[Suspicious]9,283 TokenERC-20 TOKEN*[Suspicious]98,127 TokenERC-20 TOKEN*[Suspicious]1 TokenERC-20 TOKEN*[Suspicious]9,283 TokenERC-20 TOKEN*[Spam]1.4 TokenERC-20 TOKEN*[Spam]1.4 TokenERC-20 TOKEN*[Spam]1.4 TokenERC-20 TOKEN*[Spam]100 TokenERC-20 TOKEN*[Spam]3,999.99 TokenERC-20 TOKEN*[Spam]7,600 TokenERC-20 TOKEN*[Spam]1,675.2 TokenERC-20 TOKEN*[Spam]1,049 TokenERC-20 TOKEN*[Spam]3,999.99 TokenERC-20 TOKEN*[Spam]NFT Tokens (27)Official Authorize credential$5 stETH VoucherERC-1155ETH-EventAirdrop.com$5O OOO FOR FREEERC-1155Event+ $50 000 FOR FREE (ETH-AirdropsEvent.com)ERC-1155ETH-BONUS.NET+ $50 000 FOR FREE (ETH-AirdropsEvent.com)ERC-1155Airdropapyether.orgERC-1155originethers.comoriginethers.comERC-1155nft-steth.comstETH Mysterybox NFTERC-1155Let's Go!🎁ERC-1155Let's Go!🎁ERC-1155
ERC-1155 TOKEN*
[Suspicious]ERC-1155 TOKEN*
[Suspicious]ERC-1155 TOKEN*
[Suspicious]ERC-1155 TOKEN*
[Suspicious]ERC-1155 TOKEN*
[Suspicious]ERC-1155 TOKEN*
[Suspicious]ERC-1155 TOKEN*
[Suspicious]ERC-1155 TOKEN*
[Suspicious]ERC-1155 TOKEN*
[Suspicious]ERC-1155 TOKEN*
[Suspicious]More Info
Private Name Tags
ContractCreator
TokenTracker
- Transactions
- Internal Transactions
- Token Transfers (ERC-20)
- NFT Transfers
- Contract
- Events
- Analytics
- Multichain Portfolio
- Cards New
Advanced Filter- Filter by Tx Type:
- Tx
- Internal Tx
- ERC-20
- NFTs
Latest 25 from a total of 1,152 transactions
Transaction Hash MethodBlockFromToValue Remove_liquidity... 20207368 2024-06-30 22:03:35 20 hrs ago 1719785015 IN 0 ETH 0.00043861 3.02878864 Approve 20148290 2024-06-22 15:59:23 9 days ago 1719071963 IN 0 ETH 0.00018168 3.73142437 Remove_liquidity... 20148288 2024-06-22 15:58:59 9 days ago 1719071939 IN 0 ETH 0.00046932 3.22186413 Remove_liquidity... 20148275 2024-06-22 15:56:11 9 days ago 1719071771 IN 0 ETH 0.00046214 3.17360504 Remove_liquidity... 20148204 2024-06-22 15:41:59 9 days ago 1719070919 IN 0 ETH 0.00050322 3.45572743 Remove_liquidity 20144343 2024-06-22 2:43:35 9 days ago 1719024215 IN 0 ETH 0.00030748 2.41410126 Remove_liquidity 20127041 2024-06-19 16:40:47 12 days ago 1718815247 IN 0 ETH 0.0014192 12.87292039 Remove_liquidity... 20110844 2024-06-17 10:15:11 14 days ago 1718619311 IN 0 ETH 0.00077619 5.93242174 Approve 20104884 2024-06-16 14:14:35 15 days ago 1718547275 IN 0 ETH 0.00022698 4.63547808 Add_liquidity 20104837 2024-06-16 14:05:11 15 days ago 1718546711 IN 16 ETH 0.00075233 5.09558194 Approve 20082708 2024-06-13 11:49:35 18 days ago 1718279375 IN 0 ETH 0.00028448 10.66213398 Remove_liquidity 20073280 2024-06-12 4:11:47 19 days ago 1718165507 IN 0 ETH 0.00069308 6.28733433 Approve 20032208 2024-06-06 10:31:47 25 days ago 1717669907 IN 0 ETH 0.00070765 14.45203995 Add_liquidity 20032201 2024-06-06 10:30:23 25 days ago 1717669823 IN 0.2 ETH 0.00235455 13.70316104 Remove_liquidity 20023499 2024-06-05 5:20:59 26 days ago 1717564859 IN 0 ETH 0.00071457 6.48017803 Exchange 20002481 2024-06-02 6:55:35 29 days ago 1717311335 IN 0 ETH 0.0006277 4.42315515 Remove_liquidity 20002479 2024-06-02 6:55:11 29 days ago 1717311311 IN 0 ETH 0.00049208 4.46395101 Remove_liquidity 19999784 2024-06-01 21:53:35 29 days ago 1717278815 IN 0 ETH 0.0006739 6.11335229 Remove_liquidity... 19987890 2024-05-31 6:01:11 31 days ago 1717135271 IN 0 ETH 0.00101492 6.9672599 Remove_liquidity... 19986773 2024-05-31 2:16:23 31 days ago 1717121783 IN 0 ETH 0.00117347 8.9608514 Remove_liquidity... 19952609 2024-05-26 7:38:23 36 days ago 1716709103 IN 0 ETH 0.00054803 4.04111292 Remove_liquidity... 19917093 2024-05-21 8:28:47 41 days ago 1716280127 IN 0 ETH 0.00096749 7.3892926 Add_liquidity 19893708 2024-05-18 1:58:23 44 days ago 1715997503 IN 0.0007 ETH 0.00054121 3.66592764 Remove_liquidity... 19889918 2024-05-17 13:13:59 45 days ago 1715951639 IN 0 ETH 0.00103932 6.39526649 Remove_liquidity... 19888179 2024-05-17 7:22:47 45 days ago 1715930567 IN 0 ETH 0.00071157 5.43748845 Latest 25 internal transactions (View All)
Advanced mode:Parent Transaction Hash Block From To Value 20213472 2024-07-01 18:30:47 23 mins ago 1719858647 2.22273912 ETH 20193578 2024-06-28 23:50:23 2 days ago 1719618623 0.01774842 ETH 20190793 2024-06-28 14:30:11 3 days ago 1719585011 0.1729992 ETH 20190793 2024-06-28 14:30:11 3 days ago 1719585011 16.12746097 ETH 20186481 2024-06-28 0:03:47 3 days ago 1719533027 3.53403625 ETH 20177225 2024-06-26 17:02:11 5 days ago 1719421331 7.66284854 ETH 20176300 2024-06-26 13:55:47 5 days ago 1719410147 1.9593272 ETH 20172359 2024-06-26 0:44:11 5 days ago 1719362651 9.07453424 ETH 20171278 2024-06-25 21:07:35 5 days ago 1719349655 0.03177603 ETH 20159540 2024-06-24 5:45:11 7 days ago 1719207911 9.58344856 ETH 20150580 2024-06-22 23:40:35 8 days ago 1719099635 0.0660616 ETH 20144343 2024-06-22 2:43:35 9 days ago 1719024215 798.89849731 ETH 20140112 2024-06-21 12:31:11 10 days ago 1718973071 0.26280219 ETH 20132842 2024-06-20 12:08:59 11 days ago 1718885339 1.59873465 ETH 20132388 2024-06-20 10:37:23 11 days ago 1718879843 1.62272915 ETH 20130825 2024-06-20 5:22:23 11 days ago 1718860943 3.88575208 ETH 20129124 2024-06-19 23:39:47 11 days ago 1718840387 1.66629386 ETH 20127041 2024-06-19 16:40:47 12 days ago 1718815247 153.34018494 ETH 20124732 2024-06-19 8:56:23 12 days ago 1718787383 0.00260581 ETH 20118464 2024-06-18 11:52:47 13 days ago 1718711567 96 ETH 20115490 2024-06-18 1:50:47 13 days ago 1718675447 4.59727608 ETH 20115486 2024-06-18 1:49:59 13 days ago 1718675399 4.5950008 ETH 20110844 2024-06-17 10:15:11 14 days ago 1718619311 4.93694344 ETH 20107641 2024-06-16 23:30:23 14 days ago 1718580623 0.02233199 ETH 20106984 2024-06-16 21:17:23 14 days ago 1718572643 0.39245429 ETH Loading...LoadingMinimal Proxy Contract for 0x847ee1227a9900b73aeeb3a47fac92c52fd54ed9
Contract Name:Vyper_contract
Compiler Versionvyper:0.3.7
Contract Source Code (Vyper language format)
# @version 0.3.7 """ @title StableSwap @author Curve.Fi @license Copyright (c) Curve.Fi, 2020-2023 - all rights reserved @notice 2 coin pool implementation with no lending @dev ERC20 support for return True/revert, return True/False, return None Uses native Ether as coins[0] and can rebase ERC20 """ 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 event CommitNewFee: new_fee: uint256 event ApplyNewFee: fee: uint256 N_COINS_128: constant(int128) = 2 N_COINS: constant(uint256) = 2 PRECISION: constant(uint256) = 10 ** 18 ADMIN_ACTIONS_DEADLINE_DT: constant(uint256) = 86400 * 3 FEE_DENOMINATOR: constant(uint256) = 10 ** 10 ADMIN_FEE: constant(uint256) = 5000000000 A_PRECISION: constant(uint256) = 100 MAX_FEE: constant(uint256) = 5 * 10 ** 9 MAX_A: constant(uint256) = 10 ** 6 MAX_A_CHANGE: constant(uint256) = 10 MIN_RAMP_TIME: constant(uint256) = 86400 ETH_ADDR: constant(address) = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE 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: public(constant(String[8])) = "v6.0.1" factory: address coins: public(address[N_COINS]) admin_balances: public(uint256[N_COINS]) fee: public(uint256) # fee * 1e10 future_fee: public(uint256) admin_action_deadline: public(uint256) initial_A: public(uint256) future_A: public(uint256) initial_A_time: public(uint256) future_A_time: public(uint256) # [bytes4 method_id][bytes8 <empty>][bytes20 oracle] oracle_method: public(uint256) # Only for one coin which is not ETH originator: address # Creator of the pool who can set the oracle method RATE_MULTIPLIERS: constant(uint256[2]) = [10**18, 10**18] # shift(2**32 - 1, 224) ORACLE_BIT_MASK: constant(uint256) = (2**32 - 1) * 256**28 name: public(String[64]) symbol: public(String[32]) balanceOf: public(HashMap[address, uint256]) allowance: public(HashMap[address, HashMap[address, uint256]]) totalSupply: public(uint256) decimals: public(constant(uint256)) = 18 DOMAIN_SEPARATOR: public(bytes32) nonces: public(HashMap[address, uint256]) last_prices_packed: uint256 # [last_price, ma_price] ma_exp_time: public(uint256) ma_last_time: public(uint256) @external def __init__(): # we do this to prevent the implementation contract from being used as a pool self.factory = 0x0000000000000000000000000000000000000001 assert N_COINS == 2 @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 factory was already set to prevent initializing contract twice assert self.factory == empty(address) # tx.origin will have the ability to set oracles for coins self.originator = tx.origin # additional sanity checks for ETH configuration assert _coins[0] == ETH_ADDR for i in range(N_COINS): assert _rate_multipliers[i] == 10**18 self.coins[i] = _coins[i] A: uint256 = _A * A_PRECISION self.initial_A = A self.future_A = A self.fee = _fee self.factory = msg.sender self.ma_exp_time = 866 # = 600 / ln(2) self.last_prices_packed = self.pack_prices(10**18, 10**18) self.ma_last_time = block.timestamp name: String[64] = concat("Curve.fi Factory 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(empty(address), self, 0) ### ERC20 Functionality ### @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_value(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 != empty(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 ### @pure @internal def pack_prices(p1: uint256, p2: uint256) -> uint256: assert p1 < 2**128 assert p2 < 2**128 return p1 | shift(p2, 128) @view @external def last_price() -> uint256: return self.last_prices_packed & (2**128 - 1) @view @external def ema_price() -> uint256: return shift(self.last_prices_packed, -128) @view @internal def _stored_rates() -> uint256[N_COINS]: assert self.originator == empty(address), "Set oracle" rates: uint256[N_COINS] = RATE_MULTIPLIERS oracle: uint256 = self.oracle_method if oracle != 0: # NOTE: assumed that response is of precision 10**18 response: Bytes[32] = raw_call( convert(oracle % 2**160, address), _abi_encode(oracle & ORACLE_BIT_MASK), max_outsize=32, is_static_call=True, ) assert len(response) != 0 rates[1] = rates[1] * convert(response, uint256) / PRECISION return rates @view @external def stored_rates() -> uint256[N_COINS]: return self._stored_rates() @view @internal def _balances(_value: uint256 = 0) -> uint256[N_COINS]: return [ self.balance - self.admin_balances[0] - _value, ERC20(self.coins[1]).balanceOf(self) - self.admin_balances[1] ] @view @external def balances(i: uint256) -> uint256: """ @notice Get the current balance of a coin within the pool, less the accrued admin fees @param i Index value for the coin to query balance of @return Token balance """ return self._balances()[i] @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) @internal @view def _get_p(xp: uint256[N_COINS], amp: uint256, D: uint256) -> uint256: # dx_0 / dx_1 only, however can have any number of coins in pool ANN: uint256 = amp * N_COINS Dr: uint256 = D / (N_COINS**N_COINS) for i in range(N_COINS): Dr = Dr * D / xp[i] return 10**18 * (ANN * xp[0] / A_PRECISION + Dr * xp[0] / xp[1]) / (ANN * xp[0] / A_PRECISION + Dr) @external @view def get_p() -> uint256: amp: uint256 = self._A() xp: uint256[N_COINS] = self._xp_mem(self._stored_rates(), self._balances()) D: uint256 = self.get_D(xp, amp) return self._get_p(xp, amp, D) @internal @view def exp(power: int256) -> uint256: if power <= -42139678854452767551: return 0 if power >= 135305999368893231589: raise "exp overflow" x: int256 = unsafe_div(unsafe_mul(power, 2**96), 10**18) k: int256 = unsafe_div( unsafe_add( unsafe_div(unsafe_mul(x, 2**96), 54916777467707473351141471128), 2**95), 2**96) x = unsafe_sub(x, unsafe_mul(k, 54916777467707473351141471128)) y: int256 = unsafe_add(x, 1346386616545796478920950773328) y = unsafe_add(unsafe_div(unsafe_mul(y, x), 2**96), 57155421227552351082224309758442) p: int256 = unsafe_sub(unsafe_add(y, x), 94201549194550492254356042504812) p = unsafe_add(unsafe_div(unsafe_mul(p, y), 2**96), 28719021644029726153956944680412240) p = unsafe_add(unsafe_mul(p, x), (4385272521454847904659076985693276 * 2**96)) q: int256 = x - 2855989394907223263936484059900 q = unsafe_add(unsafe_div(unsafe_mul(q, x), 2**96), 50020603652535783019961831881945) q = unsafe_sub(unsafe_div(unsafe_mul(q, x), 2**96), 533845033583426703283633433725380) q = unsafe_add(unsafe_div(unsafe_mul(q, x), 2**96), 3604857256930695427073651918091429) q = unsafe_sub(unsafe_div(unsafe_mul(q, x), 2**96), 14423608567350463180887372962807573) q = unsafe_add(unsafe_div(unsafe_mul(q, x), 2**96), 26449188498355588339934803723976023) return shift( unsafe_mul(convert(unsafe_div(p, q), uint256), 3822833074963236453042738258902158003155416615667), unsafe_sub(k, 195)) @internal @view def _ma_price() -> uint256: ma_last_time: uint256 = self.ma_last_time pp: uint256 = self.last_prices_packed last_price: uint256 = min(pp & (2**128 - 1), 2 * 10**18) # Limit the price going into EMA to not be more than 2.0 last_ema_price: uint256 = shift(pp, -128) if ma_last_time < block.timestamp: alpha: uint256 = self.exp(- convert((block.timestamp - ma_last_time) * 10**18 / self.ma_exp_time, int256)) return (last_price * (10**18 - alpha) + last_ema_price * alpha) / 10**18 else: return last_ema_price @external @view @nonreentrant('lock') def price_oracle() -> uint256: """ @notice EMA price oracle based on the last state prices Prices are taken after rate multiplier is applied (if it is set) """ return self._ma_price() @internal def save_p_from_price(last_price: uint256): """ Saves current price and its EMA """ if last_price != 0: self.last_prices_packed = self.pack_prices(last_price, self._ma_price()) if self.ma_last_time < block.timestamp: self.ma_last_time = block.timestamp @internal def save_p(xp: uint256[N_COINS], amp: uint256, D: uint256): """ Saves current price and its EMA """ self.save_p_from_price(self._get_p(xp, amp, D)) @view @external @nonreentrant('lock') 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._stored_rates(), self._balances()) D: uint256 = self.get_D(xp, amp) # D is in the units similar to DAI (e.g. converted to precision 1e18) # When balanced, D = n * x_u - total virtual value of the portfolio return D * PRECISION / self.totalSupply @view @external def calc_token_amount(_amounts: uint256[N_COINS], _is_deposit: bool) -> uint256: """ @notice Calculate addition or reduction in token supply from a deposit or withdrawal @dev This calculation accounts for slippage, but not fees. Needed to prevent front-running, not for precise calculations! @param _amounts Amount of each coin being deposited @param _is_deposit set True for deposits, False for withdrawals @return Expected amount of LP tokens received """ amp: uint256 = self._A() balances: uint256[N_COINS] = self._balances() rates: uint256[N_COINS] = self._stored_rates() D0: uint256 = self.get_D_mem(rates, balances, amp) for i in range(N_COINS): amount: uint256 = _amounts[i] if _is_deposit: balances[i] += amount else: balances[i] -= amount D1: uint256 = self.get_D_mem(rates, balances, amp) diff: uint256 = 0 if _is_deposit: diff = D1 - D0 else: diff = D0 - D1 return diff * self.totalSupply / D0 @payable @external @nonreentrant('lock') def add_liquidity( _amounts: uint256[N_COINS], _min_mint_amount: uint256, _receiver: address = msg.sender ) -> uint256: """ @notice Deposit coins into the pool @param _amounts List of amounts of coins to deposit @param _min_mint_amount Minimum amount of LP tokens to mint from the deposit @param _receiver Address that owns the minted LP tokens @return Amount of LP tokens received by depositing """ amp: uint256 = self._A() old_balances: uint256[N_COINS] = self._balances(msg.value) rates: uint256[N_COINS] = self._stored_rates() # Initial invariant D0: uint256 = self.get_D_mem(rates, old_balances, amp) total_supply: uint256 = self.totalSupply new_balances: uint256[N_COINS] = old_balances for i in range(N_COINS): amount: uint256 = _amounts[i] if total_supply == 0: assert amount > 0 # dev: initial deposit requires all coins new_balances[i] += amount # Invariant after change D1: uint256 = self.get_D_mem(rates, new_balances, amp) assert D1 > D0 # We need to recalculate the invariant accounting for fees # to calculate fair user's share fees: uint256[N_COINS] = empty(uint256[N_COINS]) mint_amount: uint256 = 0 if total_supply > 0: # Only account for fees if we are not the first to deposit base_fee: uint256 = self.fee * N_COINS / (4 * (N_COINS - 1)) for i in range(N_COINS): ideal_balance: uint256 = D1 * old_balances[i] / D0 difference: uint256 = 0 new_balance: uint256 = new_balances[i] if ideal_balance > new_balance: difference = ideal_balance - new_balance else: difference = new_balance - ideal_balance fees[i] = base_fee * difference / FEE_DENOMINATOR self.admin_balances[i] += fees[i] * ADMIN_FEE / FEE_DENOMINATOR new_balances[i] -= fees[i] xp: uint256[N_COINS] = self._xp_mem(rates, new_balances) D2: uint256 = self.get_D(xp, amp) mint_amount = total_supply * (D2 - D0) / D0 self.save_p(xp, amp, D2) else: mint_amount = D1 # Take the dust if there was any assert mint_amount >= _min_mint_amount, "Slippage screwed you" # Take coins from the sender assert msg.value == _amounts[0] if _amounts[1] > 0: assert ERC20(self.coins[1]).transferFrom(msg.sender, self, _amounts[1], default_return_value=True) # dev: failed transfer # Mint pool tokens total_supply += mint_amount self.balanceOf[_receiver] += mint_amount self.totalSupply = total_supply log Transfer(empty(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], _amp: uint256, _D: uint256) -> 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_128 # dev: j above N_COINS # should be unreachable, but good for safety assert i >= 0 assert i < N_COINS_128 amp: uint256 = _amp D: uint256 = _D if _D == 0: amp = self._A() D = 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_128): 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 value of the coin to recieve @param dx Amount of `i` being exchanged @return Amount of `j` predicted """ rates: uint256[N_COINS] = self._stored_rates() 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, 0, 0) dy: uint256 = xp[j] - y - 1 fee: uint256 = self.fee * dy / FEE_DENOMINATOR return (dy - fee) * PRECISION / rates[j] @payable @external @nonreentrant('lock') def exchange( i: int128, j: int128, _dx: uint256, _min_dy: uint256, _receiver: address = msg.sender, ) -> uint256: """ @notice Perform an exchange between two coins @dev Index values can be found via the `coins` public getter method @param i Index value for the coin to send @param j Index valie of the coin to recieve @param _dx Amount of `i` being exchanged @param _min_dy Minimum amount of `j` to receive @return Actual amount of `j` received """ rates: uint256[N_COINS] = self._stored_rates() old_balances: uint256[N_COINS] = self._balances(msg.value) xp: uint256[N_COINS] = self._xp_mem(rates, old_balances) x: uint256 = xp[i] + _dx * rates[i] / PRECISION amp: uint256 = self._A() D: uint256 = self.get_D(xp, amp) y: uint256 = self.get_y(i, j, x, xp, amp, D) 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" # xp is not used anymore, so we reuse it for price calc xp[i] = x xp[j] = y # D is not changed because we did not apply a fee self.save_p(xp, amp, D) dy_admin_fee: uint256 = dy_fee * ADMIN_FEE / FEE_DENOMINATOR * PRECISION / rates[j] if dy_admin_fee != 0: self.admin_balances[j] += dy_admin_fee coin: address = self.coins[1] if i == 0: assert msg.value == _dx assert ERC20(coin).transfer(_receiver, dy, default_return_value=True) else: assert msg.value == 0 assert ERC20(coin).transferFrom(msg.sender, self, _dx, default_return_value=True) raw_call(_receiver, b"", value=dy) log TokenExchange(msg.sender, i, _dx, j, dy) return dy @external @nonreentrant('lock') def remove_liquidity( _burn_amount: uint256, _min_amounts: uint256[N_COINS], _receiver: address = msg.sender ) -> uint256[N_COINS]: """ @notice Withdraw coins from the pool @dev Withdrawal amounts are based on current deposit ratios @param _burn_amount Quantity of LP tokens to burn in the withdrawal @param _min_amounts Minimum amounts of underlying coins to receive @param _receiver Address that receives the withdrawn coins @return List of amounts of coins that were withdrawn """ total_supply: uint256 = self.totalSupply amounts: uint256[N_COINS] = self._balances() for i in range(N_COINS): value: uint256 = amounts[i] * _burn_amount / total_supply assert value >= _min_amounts[i], "Withdrawal resulted in fewer coins than expected" amounts[i] = value if i == 0: raw_call(_receiver, b"", value=value) else: assert ERC20(self.coins[1]).transfer(_receiver, value, default_return_value=True) total_supply -= _burn_amount self.balanceOf[msg.sender] -= _burn_amount self.totalSupply = total_supply log Transfer(msg.sender, empty(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._stored_rates() old_balances: uint256[N_COINS] = self._balances() D0: uint256 = self.get_D_mem(rates, old_balances, amp) new_balances: uint256[N_COINS] = old_balances for i in range(N_COINS): new_balances[i] -= _amounts[i] D1: uint256 = self.get_D_mem(rates, new_balances, amp) fees: uint256[N_COINS] = empty(uint256[N_COINS]) base_fee: uint256 = self.fee * N_COINS / (4 * (N_COINS - 1)) for i in range(N_COINS): ideal_balance: uint256 = D1 * old_balances[i] / D0 difference: uint256 = 0 new_balance: uint256 = new_balances[i] if ideal_balance > new_balance: difference = ideal_balance - new_balance else: difference = new_balance - ideal_balance fees[i] = base_fee * difference / FEE_DENOMINATOR self.admin_balances[i] += fees[i] * ADMIN_FEE / FEE_DENOMINATOR new_balances[i] -= fees[i] new_balances = self._xp_mem(rates, new_balances) D2: uint256 = self.get_D(new_balances, amp) self.save_p(new_balances, amp, D2) 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, empty(address), burn_amount) if _amounts[0] != 0: raw_call(_receiver, b"", value=_amounts[0]) if _amounts[1] != 0: assert ERC20(self.coins[1]).transfer(_receiver, _amounts[1], default_return_value=True) 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_128 # 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_128): 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[3]: # 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._stored_rates() 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_128): 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 xp[i] = new_y last_p: uint256 = 0 if new_y > 0: last_p = self._get_p(xp, amp, D1) return [dy, dy_0 - dy, last_p] @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[3] = self._calc_withdraw_one_coin(_burn_amount, i) assert dy[0] >= _min_received, "Not enough coins removed" self.admin_balances[i] += 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, empty(address), _burn_amount) if i == 0: raw_call(_receiver, b"", value=dy[0]) else: assert ERC20(self.coins[1]).transfer(_receiver, dy[0], default_return_value=True) log RemoveLiquidityOne(msg.sender, _burn_amount, dy[0], total_supply) self.save_p_from_price(dy[2]) 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) @external def withdraw_admin_fees(): receiver: address = Factory(self.factory).get_fee_receiver(self) amount: uint256 = self.admin_balances[0] if amount != 0: raw_call(receiver, b"", value=amount) amount = self.admin_balances[1] if amount != 0: assert ERC20(self.coins[1]).transfer(receiver, amount, default_return_value=True) self.admin_balances = empty(uint256[N_COINS]) @external def commit_new_fee(_new_fee: uint256): assert msg.sender == Factory(self.factory).admin() assert _new_fee <= MAX_FEE assert self.admin_action_deadline == 0 self.future_fee = _new_fee self.admin_action_deadline = block.timestamp + ADMIN_ACTIONS_DEADLINE_DT log CommitNewFee(_new_fee) @external def apply_new_fee(): assert msg.sender == Factory(self.factory).admin() deadline: uint256 = self.admin_action_deadline assert deadline != 0 and block.timestamp >= deadline fee: uint256 = self.future_fee self.fee = fee self.admin_action_deadline = 0 log ApplyNewFee(fee) @external def set_ma_exp_time(_ma_exp_time: uint256): assert msg.sender == Factory(self.factory).admin() # dev: only owner assert _ma_exp_time != 0 self.ma_exp_time = _ma_exp_time @external def set_oracle(_method_id: bytes4, _oracle: address): """ @notice Set the oracles used for calculating rates @dev if any value is empty, rate will fallback to value provided on initialize, one time use. The precision of the rate returned by the oracle MUST be 18. @param _method_id method_id needed to call on `_oracle` to fetch rate @param _oracle oracle address """ assert msg.sender == self.originator self.oracle_method = convert(_method_id, uint256) * 2**224 | convert(_oracle, uint256) self.originator = empty(address)
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"},{"name":"CommitNewFee","inputs":[{"name":"new_fee","type":"uint256","indexed":false}],"anonymous":false,"type":"event"},{"name":"ApplyNewFee","inputs":[{"name":"fee","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":[]},{"stateMutability":"nonpayable","type":"function","name":"transfer","inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}]},{"stateMutability":"nonpayable","type":"function","name":"transferFrom","inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}]},{"stateMutability":"nonpayable","type":"function","name":"approve","inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"outputs":[{"name":"","type":"bool"}]},{"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"}]},{"stateMutability":"view","type":"function","name":"last_price","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"ema_price","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"stored_rates","inputs":[],"outputs":[{"name":"","type":"uint256[2]"}]},{"stateMutability":"view","type":"function","name":"balances","inputs":[{"name":"i","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"admin_fee","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"A","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"A_precise","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"get_p","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"price_oracle","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"get_virtual_price","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"calc_token_amount","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_is_deposit","type":"bool"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"payable","type":"function","name":"add_liquidity","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_min_mint_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"payable","type":"function","name":"add_liquidity","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_min_mint_amount","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"get_dy","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"dx","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"payable","type":"function","name":"exchange","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"_dx","type":"uint256"},{"name":"_min_dy","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"payable","type":"function","name":"exchange","inputs":[{"name":"i","type":"int128"},{"name":"j","type":"int128"},{"name":"_dx","type":"uint256"},{"name":"_min_dy","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"_min_amounts","type":"uint256[2]"}],"outputs":[{"name":"","type":"uint256[2]"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"_min_amounts","type":"uint256[2]"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256[2]"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_imbalance","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_max_burn_amount","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"nonpayable","type":"function","name":"remove_liquidity_imbalance","inputs":[{"name":"_amounts","type":"uint256[2]"},{"name":"_max_burn_amount","type":"uint256"},{"name":"_receiver","type":"address"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"calc_withdraw_one_coin","inputs":[{"name":"_burn_amount","type":"uint256"},{"name":"i","type":"int128"}],"outputs":[{"name":"","type":"uint256"}]},{"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":[]},{"stateMutability":"nonpayable","type":"function","name":"stop_ramp_A","inputs":[],"outputs":[]},{"stateMutability":"nonpayable","type":"function","name":"withdraw_admin_fees","inputs":[],"outputs":[]},{"stateMutability":"nonpayable","type":"function","name":"commit_new_fee","inputs":[{"name":"_new_fee","type":"uint256"}],"outputs":[]},{"stateMutability":"nonpayable","type":"function","name":"apply_new_fee","inputs":[],"outputs":[]},{"stateMutability":"nonpayable","type":"function","name":"set_ma_exp_time","inputs":[{"name":"_ma_exp_time","type":"uint256"}],"outputs":[]},{"stateMutability":"nonpayable","type":"function","name":"set_oracle","inputs":[{"name":"_method_id","type":"bytes4"},{"name":"_oracle","type":"address"}],"outputs":[]},{"stateMutability":"view","type":"function","name":"version","inputs":[],"outputs":[{"name":"","type":"string"}]},{"stateMutability":"view","type":"function","name":"coins","inputs":[{"name":"arg0","type":"uint256"}],"outputs":[{"name":"","type":"address"}]},{"stateMutability":"view","type":"function","name":"admin_balances","inputs":[{"name":"arg0","type":"uint256"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"fee","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"future_fee","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"admin_action_deadline","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"initial_A","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"future_A","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"initial_A_time","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"future_A_time","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"oracle_method","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"name","inputs":[],"outputs":[{"name":"","type":"string"}]},{"stateMutability":"view","type":"function","name":"symbol","inputs":[],"outputs":[{"name":"","type":"string"}]},{"stateMutability":"view","type":"function","name":"balanceOf","inputs":[{"name":"arg0","type":"address"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"allowance","inputs":[{"name":"arg0","type":"address"},{"name":"arg1","type":"address"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"totalSupply","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"decimals","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"DOMAIN_SEPARATOR","inputs":[],"outputs":[{"name":"","type":"bytes32"}]},{"stateMutability":"view","type":"function","name":"nonces","inputs":[{"name":"arg0","type":"address"}],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"ma_exp_time","inputs":[],"outputs":[{"name":"","type":"uint256"}]},{"stateMutability":"view","type":"function","name":"ma_last_time","inputs":[],"outputs":[{"name":"","type":"uint256"}]}]
Loading...LoadingLoading...Loading
Loading...Loading
Loading...LoadingLoading...LoadingLoading...LoadingLoading...LoadingLoading...LoadingLoading...Loading[ Download: CSV Export ][ Download: CSV Export ]A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.
Address QR Code
My Address - Private Name Tag or Note
My Name Tag:
Private Name Tags (up to 35 characters) can be used for easy identification of addressesPrivate Note:
A private note (up to 500 characters) can be attached to this address.
Please DO NOT store any passwords or private keys here.Connect a Wallet
Connecting wallet for read function is optional, useful if you want to call certain functions or simply use your wallet's node.Connect a Wallet
Connecting wallet for read function is optional, useful if you want to call certain functions or simply use your wallet's node.Connect a Wallet
Connecting wallet for read function is optional, useful if you want to call certain functions or simply use your wallet's node.Before You Copy
This website uses cookies to improve your experience. By continuing to use this website, you agree to its Terms and Privacy Policy.