# Burve Labs **“Embrace the Crypto Witchcraft with Us: Unleash the Magic of Fairness and Originality.”** **Burve Labs** pioneers the research and application of bonding curve theory in blockchain contexts. Our research yields TWO key outcomes: **Burve Protocol**, specializing in the future of DeFi with its unique Bonding Curve DeFi solution, and **SRT Standard** (Soul Resonance Token \[[EIP-7704](https://ethereum-magicians.org/t/eip-7704-soul-resonance-token/20058)]), a derivative of the innovative SBT standard [\[Vitalik Buterin, 2022, "Soulbound"\]](https://vitalik.eth.limo/general/2022/01/26/soulbound.html), preserving SBT's untransferrable feature while enabling trading and pricing. # Burve Protocol **Meet Burve, the DeFi3.0 Protocol**: The Consensus-Driven Bonding Curve DeFi Protocol for Fair Token Generation and Innovative Bonding-curve Liquidity Solutions. It has spawned the creation of the following sub-features: 👉**BLP (Bonding-curve Liquidity Pool)**: liquidity providers offer liquidity for any trading pair, with customizable transaction fees and liquidity distribution curves. * Flexibility to set discrete and individually definable fees. * Customizable liquidity curves. * Customized Liquidity Distribution: The Bonding Curve allows for tailored liquidity configurations, including single-sided, dual-sided, concentrated liquidity, and more. * Dynamic Positioning: Liquidity providers can instantly modify positions, adjusting both liquidity supply and price ranges with a single click. 👉**LaunchDex**: individuals or organizations can efficiently and cost-effectively create their tokens and AMM economic models in a modular fashion. * Launch tokens in 1 minute at 0 cost beyond gas fees * No liquidity pool needed * Two launch modes: HODL Mode & LOL Mode 👉**BSR Bot (Burve Social Reputation Bot)**: Token IDO bot integrated with IM apps like Telegram, Line, and Kakao using in-App reputation systems. 👉**Burve SDK**: crypto projects can enhance their capabilities by integrating the Burve SDK, allowing them to leverage Burve Launchpad and BLP features within their own platforms. 👉**Burve Appchain**: integrated with a dedicated sequencer, it is designed to optimize our Launchpad/DEX operations by minimizing MEV (Miner Extractable Value) issues. By providing a customized blockchain environment, we ensure efficient transaction processing, enhanced security, and fair trading. This innovative approach delivers a seamless and equitable trading experience for all users. For further theoretical insights into the Burve Protocol, please refer to the whitepaper: [Whitepaper\_Burve\_Protocol](/learn-more/whitepaper)
# LaunchDex Individuals or organizations can efficiently and cost-effectively create their tradable tokens and AMM economic models in a modular fashion: * By leveraging front-end parameter configurations, users can swiftly, efficiently, and securely deploy token smart contracts on Burve Protocol-supported chains. This process is code-free, allowing for the seamless creation of AMM engines, tax structures, governance modules and more * Token Holders can seamlessly buy and sell tokens using the *Swap* function, and conveniently monitor their token positions, transaction history, and profit/loss status within the *My Burve* Two launch options are available: 🗣 Fair-Launch (HODL Mode): * Customizable and transparent AMM models tailored to specific purposes * Selective anchor token options 🗣 Meme IDO (LOL Mode): * Total token supply is **100M**, with **100%** in circulation. * Launched under a fixed curve model; when market cap hits **$33K** (**17x** price on Burve Protocol), liquidity transfers to DEX, contract ownership is renounced, and trading begins at **$33K** market cap on DEX with another up to **9x** promised further gains (up to **153x** total). * The launcher can pre-purchase any amount of tokens during the launch, recorded as the first buy order on-chain. * Upon reaching **$33K** market cap, the launcher receives **$1,000** **USDT** and their referrer gets **$500** **USDT** from **Burve treasury**, immediately claimable. [**Learn more ->**](https://burve.medium.com/1-5c4836d1ffe1) # Intra-Ecosystem Definitions **Project:** Encompasses entities—tangible or abstract—that hold value represented through a token, serving as the foundation of the token's purpose and existence. It could encompass Web3.0/Crypto/Meme products, ecosystems, individual creations, such as sentences or images, as well as abstract entities like individual influence or consensus within a community. **Token Owner:** The entity responsible for initiating the **Project**, which could be an organization, team, or individual. **Token Holder**: Refers to the team or individual associated with the wallet address that possesses specific tokens linked to a particular Project.
***Why\*\*\*\* ****Token Holders**** ****trust**** ****Burve Protocol****:*** * **Trading Security**: Each token is backed by reserve assets equivalent to its redemption value. * **Community-Driven Consensus**: The growth of token prices is not influenced by token owners or liquidity providers; rather, it is determined by the token's consensus and real utilities. * **Reliability**: Token owners lack to-be-unlocked or zero-cost tokens, ensuring rewards solely from trading fees, removing financial incentives for unethical practices. * **Authentic Value Representation**: Token price and growth genuinely mirror the project's consensus or token utilities. * **Constant Liquidity**: Buyers and sellers serve as the sole market makers, eliminating the need for users to await a counterparty to initiate trades. * **Elimination of unnecessary Transaction Losses**: Avoiding high slippage resulting from insufficient pool depth in the liquidity pool and reducing the risk of loss from MEV attacks. ***Why\*\*\*\* ****Token Owners**** ****trust**** ****Burve Protocol****:*** * **0 Threshold**: Any individual or organization can swiftly and effortlessly launch tokens **without** the necessity of establishing initial liquidity pools. * **Trustworthy Fundraising** \[HODL only]: As more tokens are traded, more trading fees are generated for the token owners. * **Flexible max. Token Supply Settings** \[HODL only]**:** Enabling token owners to establish either fixed or adaptive maximum token supplies tailored to their project requirements. * **Versatility and Flexibility** \[HODL only]: Configurable key factors of the token growth AMM curve and multiple anchor token options to suit individual token creators' requirements. * **Scalability**: Burve will offer Community bot APIs for token owners to create Telegram or Discord Bots, fostering larger, robust communities. # Key Features **Supported blockchain networks:** * [x] Base * [x] Binance Smart Chain * [ ] Kaia * [ ] TON * [ ] Solana **Supported token assets:** * [x] ERC20 * [ ] ERC1155 (NFT) * [ ] SBT * [ ] SPL * [ ] Rune **Configurable modules for launched ****HODL**** tokens:** * [x] Delayed Trading Module: Select token to be tradable immediately after launch or scheduled tradable until a specific block height * [x] Pre-mint Module: Token owner pre-mint tokens upon token launch * [ ] IDO Module: Ensure fair and balanced initial token distribution with the pre-mint module * [ ] Airdrop Module: Pre-mint tokens for community airdrops * [x] Trading Tax Module: Configurable transaction tax fee is directed to the token owner's treasury address * [ ] Dynamic Tax Module: Adjust tax rates dynamically based on real-time TVL size * [ ] Automatic Buyback or Burning Module: Taxes automatically repurchase tokens or burn them * [ ] Lending & Borrowing Module: Unlock anchor token liquidity in the bonding curve, featuring self-liquidation without third-party intervention * [x] Maximum Supply Module: Fixed or adaptive max. token supply * [ ] Governance Module: Enable project governance implementation * [ ] Vesting Module: Cliff and release periods for tokens pre-minted * [ ] More... **AMM Curve Types** \[HODL only]**:** * [x] Linear * [x] Exponential * [ ] Taylor series + Piecewise function to define any reasonable curves The token economy model established via the **Burve Protocol** encompasses the following Features: 1. **Liquidity Provision:** The Token Owner is not mandated to provide initial liquidity for token launch, pricing, and trading. The Burve protocol autonomously furnishes the project initiator with the requisite liquidity. 2. **Token Acquisition:** All tokens are exclusively obtainable through purchasing. Project initiators have no access to free tokens; they acquire them on par with other community members via purchasing process. 3. **Customizable Parameters** \[HODL only]**:** Token Owners possess the capability to define curve parameters, tailoring the token economic model to suit their project requirements. 4. **Revenue Structure** \[HODL only]**:** Token Owners can solely generate income via consistent and reasonable taxation. Profits arising from token price appreciation are distributed among token holders actively engaged in token trading. 5. **Asset-backed Tokens:** Tokens acquired through purchase are supported by reserve assets corresponding to their redemption value, enhancing their underlying value proposition. # Token Launch **Token Owners** benefit from the ability to swiftly, securely, and equitably launch their tokens by configuring straightforward parameters on the front-end. Every participant, including the Token Owner, enjoys equal access to swap for project tokens at identical costs by utilizing anchored tokens within the trading pair. * **HODL Mode****:** The anchor token can be any on-chain asset supported by burve protocol. * **LOL Mode****:** Only USDT is supported as the anchor token. # HODL **Step One: Connect and Initiate** Begin by clicking *"Launch App"* on [burve.io](https://burve.io/) and then *"Connect"* to connect your wallet in the upper right corner of the Burve dApp. Switch to the chain corresponding to the desired token creation, click *"Launch Token"* and select *"Launch HODL Token"* to access the token creation page.
**Step Two: Enter Token Info** * Provide the Project Name * Specify the Currency Code (Token Symbol) * Upload the Token Logo image * Verify Project Twitter account * Select Anchor Token (Complete the application form if it's not available) * Optionally, fill in More Project Info
**Step Three: Set Market Maker Curve Parameters** * Choose curve type * Set the initial price, the *A value* [Broken mention](broken://pages/4T6vy1R2X2CCmoIsE6Ql), max. supply for exponential curve * Or set the initial token price, final token price and max. supply for linear curve
**Step Four: Transaction Settings** * Set the tax treasury address * Specify the tax ratio for sales and purchases [Broken mention](broken://pages/bboC7ObHMSqvKqqs22u1) * Choose between immediate trade and scheduled trade * Optionally, set the *pre-mint* token amount
**Step Five: Generate and Explore** Generate and view the created tokens on-chain. Explore the token on the Burve dAPP's *Explore* page and access its details. Find comprehensive data in the *Launched Token* section of *My Burve*. Adjust token settings as required, with modifications limited to a single occurrence within a 48-hour window.
# Parameters for Exponential Curve If exponential curve is chosen to establish the relationship between the price of tokens and the supply of tokens, then: $$ p=ae^\frac{s}{b} $$ | Parameter | Meaning | | --------- | ------------ | | p | Token Price | | s | Token Supply | | a | Parameter 1 | | b | Parameter 2 | The function provided allows for the calculation of the correlation between *Anchor Token TVL* and the *Token Supply*: {% hint style="info" %} Anchor tokens pertain to the tokens utilized for minting or purchasing project tokens, such as ETH or USDC. {% endhint %} {% hint style="info" %} Anchored Token TVL denotes the cumulative value of anchored tokens secured within the Bonding Curve contract. {% endhint %} $$ TVL=\int\_{0}^{s}ae^\frac{s}{b}=abe^\frac{s}{b}-ab $$ In the context of defining the curve within Burve protocol, specifying the values of **a** and **b** is essential. When the supply is 0，it follows that **p=a**. In this scenario, the value of **a** represents the initial price of the token： $$ a=p\_0 $$ The parameter **b** in the equation $$p=ae^s$$ signifies the scaling on the **X**-axis for the function, which often lacks practical significance. To address this, the Burve Protocol introduces the parameter **A** as a replacement. The **A**-value is defined as the Anchor Token TVL divided by the increase in token price over the initial price. The specific value of the Anchor Token TVL is already known: $$ TVL=abe^\frac{s}{b}-ab $$ The increase in token price from the initial price is a multiple of: $$ \frac{p}{p\_0}=\frac{ae^\frac{s}{b}}{a}=e^\frac{s}{b} $$ Thus **A**-value is： $$ A=ab-\frac{ab}{e^\frac{s}{b}}=ab-\frac{ab}{\frac{TVL}{ab}+1} $$ When TVL is relatively large: $$ A\approx{ab} $$ Then **b**-value is calculated with the Parameter **A**: $$ b=\frac{A}{a} $$ **Parameter Setting Example:** If the project aims for an Initial Token Price of 0.01USDC and plans for the token price to surge by 100 times when the TVL reaches 1,000,000USDC, the following settings can be implemented: * Initial Token Price: 0.01 USDC * A-value: 100,000 (derived from A = 1,000,000 / 100) In this configuration, the relationship between the supply of tokens, price, and TVL would adhere to the specified conditions: | Supply | Price(USD) | TVL(USD) | | --------- | ------------- | ------------- | | 100,000 | 0.01105159459 | 1,051.594593 | | 200,000 | 0.0122137743 | 2,213.774304 | | 300,000 | 0.0134981682 | 3,498.168205 | | 400,000 | 0.01491762827 | 4,917.628274 | | 500,000 | 0.016486358 | 6,486.357997 | | 600,000 | 0.01822005449 | 8,220.054489 | | 700,000 | 0.02013606557 | 10,136.06557 | | 800,000 | 0.02225356333 | 12,253.56333 | | 900,000 | 0.02459373602 | 14,593.73602 | | 1,000,000 | 0.02718 | 17,180 | | 1,100,000 | 0.0300382341 | 20,038.2341 | | 1,200,000 | 0.03319703856 | 23,197.03856 | | 1,300,000 | 0.03668802118 | 26,688.02118 | | 1,400,000 | 0.04054611365 | 30,546.11365 | | 1,500,000 | 0.04480992104 | 34,809.92104 | | 1,600,000 | 0.0495221081 | 39,522.1081 | | 1,700,000 | 0.05472982621 | 44,729.82621 | | 1,800,000 | 0.06048518514 | 50,485.18514 | | 1,900,000 | 0.0668457745 | 56,845.7745 | | 2,000,000 | 0.07387524 | 63,875.24 | | 2,100,000 | 0.08164392029 | 71,643.92029 | | 2,200,000 | 0.0902295508 | 80,229.5508 | | 2,300,000 | 0.09971804157 | 89,718.04157 | | 2,400,000 | 0.1102043369 | 100,204.3369 | | 2,500,000 | 0.1217933654 | 111,793.3654 | | 2,600,000 | 0.1346010898 | 124,601.0898 | | 2,700,000 | 0.1487556676 | 138,755.6676 | | 2,800,000 | 0.1643987332 | 154,398.7332 | | 2,900,000 | 0.1816868151 | 171,686.8151 | | 3,000,000 | 0.2007929023 | 190,792.9023 | | 3,100,000 | 0.2219081753 | 211,908.1753 | | 3,200,000 | 0.2452439191 | 235,243.9191 | | 3,300,000 | 0.271033637 | 261,033.637 | | 3,400,000 | 0.2995353877 | 289,535.3877 | | 3,500,000 | 0.3310343671 | 321,034.3671 | | 3,600,000 | 0.3658457621 | 355,845.7621 | | 3,700,000 | 0.4043179046 | 394,317.9046 | | 3,800,000 | 0.4468357569 | 436,835.7569 | | 3,900,000 | 0.4938247634 | 483,824.7634 | | 4,000,000 | 0.5457551085 | 535,755.1085 | | 4,100,000 | 0.6031464206 | 593,146.4206 | | 4,200,000 | 0.666572972 | 656,572.972 | | 4,300,000 | 0.7366694253 | 726,669.4253 | | 4,400,000 | 0.8141371837 | 804,137.1837 | | 4,500,000 | 0.8997514097 | 889,751.4097 | | 4,600,000 | 0.9943687815 | 984,368.7815 | | 4,700,000 | 1.098936065 | 1,088,936.065 | | 4,800,000 | 1.214499587 | 1,204,499.587 | | 4,900,000 | 1.342215707 | 1,332,215.707 | | 5,000,000 | 1.483362385 | 1,473,362.385 | | 5,100,000 | 1.639351971 | 1,629,351.971 | | 5,200,000 | 1.811745338 | 1,801,745.338 | # LOL **Step One: Connect and Initiate** Begin by clicking *"Launch App"* on [burve.io](https://burve.io/) and then *"Connect"* to connect your wallet in the upper right corner of the Burve dApp. Switch to the chain corresponding to the desired token creation, click *"Launch Token"* and select *"Launch LOL Token"* to access the token creation page.
**Step Two: Enter Token Info** * Provide the Project Name * Specify the Currency Code (Token Symbol) * Upload the Token Logo image * Optionally, fill in More Project Info and choose whether to purchase upon creation
**Step Three: Generate and Explore** Generate and view the created tokens on-chain. Explore the token on the Burve dAPP's *Explore* page and access its details. Find comprehensive data in the *Launched Token* section of *My Burve*. Adjust token settings as required, with modifications limited to a single occurrence within a 48-hour window.
# Token Trading Tokens can be traded on either the Token Detail or Swap page. Transactions involve invoking functions like *mint() & burn()* or *deposit() & Redeem()*. When buying, users must submit a specific quantity of anchored tokens to the contract to complete the minting or depositing process. Conversely, when selling tokens, an equivalent amount of anchored tokens is automatically acquired from the contract. \ **Step One: Establish Connection** Initiate the process by connecting your wallet and selecting the chain where the targeted token resides.
**Step Two: Token Selection** Choose the specific token you intend to buy or sell (upcoming tokens will only be tradable after their official trading time) and verify the information displayed.
**Step Three: Trading Slippage Setting (Optional)** Optionally, set the trading slippage tolerance to customize your trading preferences.
**Step Four: Confirm Transaction** Review the transaction summary, then approve and confirm the transaction within your wallet for seamless execution.
You can check your holdings in *Holding token* in *My Burve*
# Trading Taxes \[HODL only] The Token Owner can define transaction taxes, including buy tax and sex tax rates. The allowable range for trading taxes spans from **0%** to **50%**. Tax rate adjustments are irreversible once set, with decreases allowed thereafter. Modifications are limited to a single occurrence within a 48-hour window. # Typical Use Cases **Social/DAO project:** Communities represent a prevalent organizational structure within social or DAO projects, often necessitating one or multiple pass tokens to designate the identity and authority of diverse users. These token(s) can manifest as either SBTs (Soul Bound Tokens) or NFTs, tailored to different segmentation scenarios and requirements. * Vitalik's proposed SBT, due to its non-transferable attribute, lacks compatibility with the exchange mechanisms prevalent in order books or LPs AMMs. However, the unique Bonding Curve AMM mechanism introduced by the Burve Protocol effectively addresses this limitation, facilitating SBT trading while preserving its inherent attributes. * The conventional NFT trading marketplace is frequently hampered by liquidity challenges and limited trading volumes. The Burve Protocol offers a compelling solution to overcome these deficiencies. Similar to how DEX (e.g., Uniswap) forms the cornerstone of DeFi, the Burve protocol serves as a crucial component for the advancement of SocialFi or DAO projects, filling a critical gap in the ecosystem's infrastructure. **Creator Economy Project:** In the Creator Economy realm, individual influence and creative works can be tokenized, liberating them from the confines of traditional centralized Web2.0 platforms and fostering a new self-contained loop within Web3.0. Leveraging the Burve Protocol, any individual or entity can initiate token launches representing virtual personal influence or tangible creations. This facilitates transactions without the necessity of establishing LP pools, empowering participants to generate relevant revenues. **RWA Project:** Similar to the Creator Economy Project, real-world assets can be mirrored onto the blockchain, enabling seamless automated transactions. Contrasted with the traditional LP and order book model, the Burve Protocol streamlines the entire process, significantly reducing the barriers to entry for RWA projects. **GameFi Project:** Numerous GameFi projects involve diverse digital assets within the gaming ecosystem, many of which are not intended for circulation outside the game environment. Previously, game developers faced limitations, often restricted to creating in-game marketplaces (where token swaps relied on the simultaneous presence of both buyers and sellers) or depended on external liquidity from CEX/DEX platforms. However, with the Burve Protocol, multiple digital assets can be more conveniently exchanged within the gaming environment without necessitating project-provided liquidity (avoiding additional issuance). This enhances the gaming experience by facilitating easier conversions between digital assets, ultimately improving user engagement. **Bitcoin Ecosystem Projects:** The Bitcoin ecosystem encounters limitations in implementing LP due to the UTXO (Unspent Transaction Output) framework within both Bitcoin Layer1 and Layer2s, which lacks the LP concept. Consequently, DEX's AMM mechanism finds no application within Bitcoin's ecosystem. However, the Burve Protocol seamlessly integrates with the Bitcoin ecosystem's infrastructure, offering a natural fit and delivering fair launch capabilities along with an AMM infrastructure for Bitcoin ecosystem projects. **Meme and other Crypto projects:** Token valuations in Meme and various Crypto projects find support through community consensus or token utilities. Project owners prioritize community building, product development, and operational endeavors rather than focusing solely on market capitalization gains. This emphasis drives a larger trading volume and more transaction fees, serving as an incentive for sustained, stable project development in the long term. **More...**
# Burve BLP **What is BLP?**\ BLP stands for Bonding-Curve Liquidity Pool, a concept introduced by Burve Labs in their academic paper. **Why BLP is an Innovative and Revolutionary DeFi (AMM) Theory:**\ BLP offers greater flexibility and scalability, making it a significant advancement in DeFi. **AMM History:**\ Order Book -> Liquidity Pool (Uniswap V2) -> Specific Interval Liquidity Pool (Uniswap V3) -> BLP **Comparison:** ***Order Book:***\ Transactions are matched through bids and asks, with users acting as counterparties to each other. The downside is that during periods of low liquidity, trade execution can be slow and subject to high slippage. ***Liquidity Pool (Uniswap V2):***\ Liquidity pools use a constant product formula (Price Token A \* Price Token B = C) to create a decentralized automated market maker (AMM). In this model, users trade against the liquidity pool itself, and liquidity providers (LPs) earn transaction fees. However, the liquidity utilization is low as liquidity outside the current price range is wasted, and there's a high risk of impermanent loss. ***Specific Interval Liquidity Pool (Uniswap V3):***\ Concentrated liquidity allows LPs to allocate liquidity within a specific price range, improving liquidity utilization within that range. However, liquidity becomes fragmented, creating arbitrage opportunities between different liquidity pools. For project teams, adding liquidity is complex, requiring multiple positions to achieve optimal distribution. For LPs, adjusting price ranges is cumbersome, as they must remove and recreate positions instead of flexibly adjusting a fixed position. ***BLP (Bonding-Curve Liquidity Pool):***\ In BLP, liquidity providers can set any liquidity distribution using a bonding curve and define rules for their liquidity through parameters and hooks. This allows for the automated market making of various asset types and expands the functionality of liquidity pools to more application scenarios. * Customizable Transaction Fees: LPs can set individual fee parameters for different strategies. * Customizable Bonding Curves: LPs can design the liquidity curve to suit their needs. **How BLP Solves Problems in Uniswap V2 and V3:** In BLP, liquidity providers can create flexible liquidity distributions (e.g., across the entire price range, single-sided ranges, or concentrated liquidity) using different curve parameters. They can adjust the liquidity price range without the need to recreate positions. Additionally, LPs can set independent fee parameters for their positions, catering to various LP strategies. *Example: ETH/USDT Pair* 1. ***Bonding Curve Liquidity Pool Simulating Uniswap V2’s Liquidity Distribution:***\ The BLP can mimic Uniswap V2's distribution, offering familiar liquidity behavior with added flexibility.
2. ***How Trading Works When an ETH Buy Order is Initiated:***\ When a buy order for ETH is placed, the price of ETH increases from the initial to the current price. The buyer receives ETH, while USDT is sold into the contract.
3. Adjusting Liquidity with Simplicity and the Concept of Virtual Liquidity:\ The amount of ETH and USDT in the BLP determines the ceiling and floor prices, defining the tradable ETH price range on the curve. Both sides of the curve represent virtual liquidity. LPs can adjust their ETH or USDT holdings in their BLP at any time without burning the liquidity pool.
Handling Orders with Multiple BLP Providers Covering the Same Range:\ When multiple LPs provide liquidity for the same range, orders are executed in a manner that optimizes liquidity utilization and minimizes slippage.
**Additional Info:** ***1, Scalability:***\ BLP can be applied to various scenarios such as IDOs, Fair Launches, and trading, by setting different types of BLPs. ***2, Support for More Asset Types:***\ BLP also supports a wider range of asset types, including NFTs and SBTs, enabling decentralized trading for these non-standard assets. *More* c*ontent update forthcoming...*
# BSR Bot Burve Social Reputation Bot is the token IDO bot integrated with IM apps like Telegram, Line, and Kakao using in-App reputation systems... *More* c*ontent update forthcoming...* # Burve SDK Burve SDK enables project teams and individual developers to leverage the features of Burve Launchpad and Burve DEX without the need for development from scratch. *More* c*ontent update forthcoming...* # Burve Appchain *More* c*ontent update forthcoming...* # Learn More Explore further project details and introduction # AMM **Automated Market Makers** (AMMs) serve a pivotal function in token price representation and trading mechanisms. Currently, the prevalent AMM systems primarily consist of Liquidity Pools (LPs) and Order Books, yet each harbors its own set of drawbacks: **Liquidity Pool (LP):** Initiators of a project must offer initial liquidity, which exposes them to the potential risk of the project's pool being withdrawn unexpectedly. **Order Book:** This system necessitates a substantial token trading volume to minimize matchmaking durations. However, in scenarios of lower volume, the prolonged matchmaking times become a concern. Additionally, there exists a risk of malicious market manipulation orchestrated by vested individuals or entities. Amidst the burgeoning growth of Bitcoin Inscriptions and the ongoing evolution of SocialFi, Creator Economy, GameFi, and related ecosystems, there's an imperative need for a token launch protocol and market maker mechanism that embodies fairness, transparency, and freedom. Simultaneously, this mechanism should cater to the profitability of project initiators, encouraging them to enhance and refine their products. **Burve Protocol** stands as an ideal solution perfectly aligned with these requirements. # Bonding Curve British economist **John Maynard Keynes** proposed the Bancor Plan at the United Nations Monetary and Financial Conference in Bretton Woods, New Hampshire, USA, in 1944. The plan suggested that the International Settlements Union issue a unified world currency, known as the Bancor Coin, to serve as a global economic reserve currency. In homage to Keynes, the **Bancor protocol** was introduced in 2017, bringing the concept of collateral to the blockchain. Presently, numerous tokens with relatively small market capitalization face challenges in being traded on centralized exchanges. The **Bancor protocol** addresses this issue by enabling free trading of tokens with certain collateral. This innovative approach reduces the threshold for token trading and fosters a long-tail effect within the token economy [\[Hertzog, E., Benartzi, G., & Benartzi, G., 2018, "Bancor Protocol Whitepaper: Continuous Liquidity and Asynchronous Price Discovery for Tokens through their Smart Contracts; aka “Smart Tokens”\]](https://api-new.whitepaper.io/documents/pdf?id=ryWFBhWCf). Whether functioning as a reserve currency or collateral, both concepts serve as what many consider to be a **"more valuable anchor"** in the realm of decentralized finance. The **bonding curve**, a mathematical function connecting the supply of a digital asset to its price, serves as the backbone of token valuation, utilizing the concept of **"more valuable anchor"**. This passive market maker mechanism, driven by the bonding curve formula, ensures that the token's price dynamically adjusts with changes in its supply [\[ S.D.L. Rouvière, 2017, “Tokens 2.0: Curved Token Bonding in Curation Markets”\]](https://medium.com/@simondlr/tokens-2-0-curved-token-bonding-in-curation-markets-1764a2e0bee5). It is **an automatic mechanism of market-making and liquidity provision** in token economies, mentioned by [\[Zargham, M., Shorish, J., & Paruch, K., 2019, "From curved bonding to configuration spaces"\]](https://research.wu.ac.at/en/publications/from-curved-bonding-to-configuration-spaces-6). Various forms of joint curves, such as exponential curves, convex function curves, straight lines, and aggregations of functions expressed through Taylor series expansions, fall under the umbrella of bonding curves, each with its unique characteristics. Typically, as the token supply increases, so does its price. This design mimics real-world scenarios, like purchasing a limited asset such as Ethereum, where subsequent buyers pay a higher price. This not only embodies the passive market maker mechanism but also guarantees that every acquired token is underpinned by an anchor token, providing it with intrinsic value support. However, in specific cases, a horizontal line as a bonding curve results in a constant token price despite changes in supply. This approach finds utility in scenarios like equal-price Initial DEX Offerings (IDO) or uniform-priced concert ticket sales. The **Burve Protocol** asserts that the bonding curve can yield a more "Turing complete" automated market maker (AMM) model compared to traditional order book and liquidity pool AMMs. Through extensive exploration of bonding curve theory and its application in the blockchain and DeFi sectors, Burve Protocol has unearthed innovative theoretical findings, unlocking new potential within decentralized finance. For further theoretical insights into the Burve Protocol, please refer to the [whitepaper](/learn-more/whitepaper).
# Whitepaper **Burve Protocol**'s **whitepaper** systematically and comprehensively presents research results on Automated Market Makers (AMM), establishing its theoretical foundation: {% file src="/files/dmKk2o0kRIFrqShTa9cA" %} *By BurveLabs, presented at the EBES Conference, April 18-20, 2024, Berlin, Germany.* # Contracts All the Burve Protocol contracts are open sourced ### BNB Smart Chain (56)
Contract NameContract Address
FactoryProxy0xedc1bf1993b635478c66ddfd1a5a01c81a38551b
Factory0x8a29530ac93cf5522f454d494b27e4beb76d45f3
Exponential_BondingCurve0x25814d4f654249bb78baf058488633c44961bacc
Linear_BondingCurve0xf5c6c014d674cff83fa02eb83e1379fb835129fe
Route0x9896315200d9bc240817a779f2a2d11e1c4c6358
### Base (8453)
Contract NameContract Address
FactoryProxy0xedc1bf1993b635478c66ddfd1a5a01c81a38551b
Factory0x447729f5810c8723e612627436f79d97de7523a9
Exponential_BondingCurve0xcc75c40c32bfa2299b4dce0cfcea3b0fa90cf935
Linear_BondingCurve0xcd7a56ec2cc0eb169c2373daffbcdb51b1941d07
Route0xffd1617942b8f5d02fc94651ea37e53ec083f258
### ZKFair (42766)
Contract NameContract Address
FactoryProxy0xEdc1Bf1993B635478c66DDfD1A5A01c81a38551b
Factory0x5cA96345e0F98c8D051d557e660DFDdE8C378Ce4
Exponential_BondingCurve0xcc75c40c32bfa2299b4dce0cfcea3b0fa90cf935
Linear_BondingCurve0x8a29530ac93cf5522f454d494b27e4beb76d45f3
Route0x1f83ca081840ebb67a830b640fe6d3c912a4f713
# API 🧙‍ We use the flexible and powerful graphql to provide API services ### BNB Smart Chain (56) * API: * Playground: * Tickers: [http://api.burve.io/tickers ]() ### Base (8453) * API: * Playground: ### ZKFair (42766) * API: * Playground:
# API Examples 🧙‍ Some plain and simple examples ### Query `FactoryProxy` contract address [Try Online](https://api.burve.io/graph/bsc/graphql?query=query+QueryFactoryProxyAddress+%7B%0A++platformEntities+%7B%0A++++addr%0A++%7D%0A%7D) 
query QueryFactoryProxyAddress {
  platformEntities {
    addr
  }
}
### Query number of launch tokens [Try Online](https://api.burve.io/graph/bsc/graphql?query=query+QueryLaunchCount+%7B%0A++counterEntities%28where%3A+%7Btype_contains%3A+%22DaoCount%22%7D%29+%7B%0A++++count%0A++%7D%0A%7D) 
query QueryLaunchCount {
  counterEntities(where: {type_contains: "DaoCount"}) {
    count
  }
}
### Query multiple entities at once [Try Online](https://api.burve.io/graph/bsc/graphql?query=query+QueryPlatformInfo+%7B%0A++platformEntities+%7B%0A++++addr%0A++%7D%0A++counterEntities%28where%3A+%7Btype_contains%3A+%22DaoCount%22%7D%29+%7B%0A++++count%0A++%7D%0A%7D) ```graphql query QueryPlatformInfo { platformEntities { addr } counterEntities(where: {type_contains: "DaoCount"}) { count } } ``` # Scalars Data types in Burve API | Type | Description | | ---------- | ---------------------- | | BigDecimal | | | BigInt | | | Boolean | | | Bytes | | | Float | | | ID | | | Int | 4 bytes signed integer | | Int8 | 8 bytes signed integer | | String | | # Objects Data entity types in Burve API ### BondingCurveType | Field | Type | | ----- | ------- | | id | ID! | | name | String! | | impl | Bytes! | ### CounterEntity | Field | Type | | --------- | ----------- | | id | ID! | | count | BigDecimal! | | type | String! | | timestamp | BigInt! | ### Hook | Field | Type | | ------- | ------------ | | id | ID! | | token | TokenEntity! | | data | Bytes! | | encoder | String! | | name | String! | | addr | Bytes! | ### HookEntity | Field | Type | | ------- | ------- | | id | ID! | | name | String! | | addr | Bytes! | | encoder | String! | ### Member | Field | Type | | ------- | ------------ | | id | ID! | | token | TokenEntity! | | user | User! | | ids | \[BigInt!] | | balance | BigDecimal | ### MintBurnEntity | Field | Type | | ------------ | ------------ | | id | ID! | | hash | Bytes! | | blockNum | BigInt! | | timestamp | BigInt! | | direction | Int! | | from | Bytes! | | to | Bytes! | | erc20Amount | BigDecimal! | | nativeAmount | BigDecimal! | | platformFee | BigDecimal! | | projectFee | BigDecimal! | | price | BigDecimal! | | tvl | BigDecimal! | | tradeVolumes | BigDecimal! | | token | TokenEntity! | ### PlatformEntity | Field | Type | | -------- | ---------- | | id | ID! | | net | String! | | addr | Bytes! | | admin | Bytes! | | treasury | Bytes! | | route | Bytes! | | mintTax | BigInt! | | burnTax | BigInt! | | klines | \[String!] | ### Price | Field | Type | | ---------- | ------------ | | id | ID! | | type | String! | | minPrice | BigDecimal! | | maxPrice | BigDecimal! | | openPrice | BigDecimal! | | closePrice | BigDecimal! | | tokenTvl | BigDecimal! | | timestamp | BigInt! | | token | TokenEntity! | | volume | BigDecimal! | ### TokenEntity | Field | Type | | ---------------- | ----------------------- | | id | ID! | | index | BigInt! | | net | String! | | addr | Bytes! | | factory | Bytes! | | name | String! | | symbol | String! | | metaUri | String! | | supply | BigDecimal! | | tokenType | String! | | bondingCurveType | String! | | raisingToken | Bytes! | | params | String! | | mintTax | BigInt! | | burnTax | BigInt! | | paused | Boolean! | | doomsDays | Boolean! | | destoryed | Boolean! | | treasury | Bytes! | | admin | Bytes! | | creator | Bytes! | | marketCap | BigDecimal! | | currentPrice | BigDecimal! | | lockValue | BigDecimal! | | treasuryFee | BigDecimal! | | memberCount | BigInt! | | decimal | Int8! | | baseDecimal | Int8! | | txCount | BigInt! | | createTimestamp | BigInt! | | prices | \[Price!] | | skip | Int | | first | Int | | orderBy | Price\_orderBy | | orderDirection | OrderDirection | | where | Price\_filter | | hooks | \[Hook!] | | skip | Int | | first | Int | | orderBy | Hook\_orderBy | | orderDirection | OrderDirection | | where | Hook\_filter | | mintBurnTxs | \[MintBurnEntity!] | | skip | Int | | first | Int | | orderBy | MintBurnEntity\_orderBy | | orderDirection | OrderDirection | | where | MintBurnEntity\_filter | | members | \[Member!] | | skip | Int | | first | Int | | orderBy | Member\_orderBy | | orderDirection | OrderDirection | | where | Member\_filter | ### TokenType | Field | Type | | ----- | ------- | | id | ID! | | name | String! | | impl | Bytes! | ### TokenUpgradeHistory | Field | Type | | --------- | ------------ | | id | ID! | | token | TokenEntity! | | upgradeTo | Bytes! | | data | String! | | timestamp | BigInt! | | operator | Bytes! | | tx | Bytes! | | type | String! | ### User | Field | Type | | -------------- | --------------- | | id | ID! | | members | \[Member!] | | skip | Int | | first | Int | | orderBy | Member\_orderBy | | orderDirection | OrderDirection | | where | Member\_filter | ### Block | Field | Argument | | --------- | -------- | | hash | Bytes | | number | Int! | | timestamp | Int | ### Meta The type for the top-level \_meta field | Field | Type | | ----------------- | ---------- | | block | \_Block\_! | | deployment | String! | | hasIndexingErrors | Boolean! | # Inputs 🧙‍ Filtering of all entities available ### BlockChangedFilter | Field | Type | | ----------- | ---- | | number\_gte | Int! | ### Block\_height | Field | Type | | ----------- | ----- | | hash | Bytes | | number | Int | | number\_gte | Int | ### BondingCurveType\_filter | Field | Type | | ------------------------------- | --------------------------- | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | name | String | | name\_not | String | | name\_gt | String | | name\_lt | String | | name\_gte | String | | name\_lte | String | | name\_in | \[String!] | | name\_not\_in | \[String!] | | name\_contains | String | | name\_contains\_nocase | String | | name\_not\_contains | String | | name\_not\_contains\_nocase | String | | name\_starts\_with | String | | name\_starts\_with\_nocase | String | | name\_not\_starts\_with | String | | name\_not\_starts\_with\_nocase | String | | name\_ends\_with | String | | name\_ends\_with\_nocase | String | | name\_not\_ends\_with | String | | name\_not\_ends\_with\_nocase | String | | impl | Bytes | | impl\_not | Bytes | | impl\_gt | Bytes | | impl\_lt | Bytes | | impl\_gte | Bytes | | impl\_lte | Bytes | | impl\_in | \[Bytes!] | | impl\_not\_in | \[Bytes!] | | impl\_contains | Bytes | | impl\_not\_contains | Bytes | | \_change\_block | BlockChangedFilter | | and | \[BondingCurveType\_filter] | | or | \[BondingCurveType\_filter] | ### CounterEntity\_filter | Field | Type | | ------------------------------- | ------------------------ | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | count | BigDecimal | | count\_not | BigDecimal | | count\_gt | BigDecimal | | count\_lt | BigDecimal | | count\_gte | BigDecimal | | count\_lte | BigDecimal | | count\_in | \[BigDecimal!] | | count\_not\_in | \[BigDecimal!] | | type | String | | type\_not | String | | type\_gt | String | | type\_lt | String | | type\_gte | String | | type\_lte | String | | type\_in | \[String!] | | type\_not\_in | \[String!] | | type\_contains | String | | type\_contains\_nocase | String | | type\_not\_contains | String | | type\_not\_contains\_nocase | String | | type\_starts\_with | String | | type\_starts\_with\_nocase | String | | type\_not\_starts\_with | String | | type\_not\_starts\_with\_nocase | String | | type\_ends\_with | String | | type\_ends\_with\_nocase | String | | type\_not\_ends\_with | String | | type\_not\_ends\_with\_nocase | String | | timestamp | BigInt | | timestamp\_not | BigInt | | timestamp\_gt | BigInt | | timestamp\_lt | BigInt | | timestamp\_gte | BigInt | | timestamp\_lte | BigInt | | timestamp\_in | \[BigInt!] | | timestamp\_not\_in | \[BigInt!] | | \_change\_block | BlockChangedFilter | | and | \[CounterEntity\_filter] | | or | \[CounterEntity\_filter] | ### HookEntity\_filter | Field | Type | | ---------------------------------- | --------------------- | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | name | String | | name\_not | String | | name\_gt | String | | name\_lt | String | | name\_gte | String | | name\_lte | String | | name\_in | \[String!] | | name\_not\_in | \[String!] | | name\_contains | String | | name\_contains\_nocase | String | | name\_not\_contains | String | | name\_not\_contains\_nocase | String | | name\_starts\_with | String | | name\_starts\_with\_nocase | String | | name\_not\_starts\_with | String | | name\_not\_starts\_with\_nocase | String | | name\_ends\_with | String | | name\_ends\_with\_nocase | String | | name\_not\_ends\_with | String | | name\_not\_ends\_with\_nocase | String | | addr | Bytes | | addr\_not | Bytes | | addr\_gt | Bytes | | addr\_lt | Bytes | | addr\_gte | Bytes | | addr\_lte | Bytes | | addr\_in | \[Bytes!] | | addr\_not\_in | \[Bytes!] | | addr\_contains | Bytes | | addr\_not\_contains | Bytes | | encoder | String | | encoder\_not | String | | encoder\_gt | String | | encoder\_lt | String | | encoder\_gte | String | | encoder\_lte | String | | encoder\_in | \[String!] | | encoder\_not\_in | \[String!] | | encoder\_contains | String | | encoder\_contains\_nocase | String | | encoder\_not\_contains | String | | encoder\_not\_contains\_nocase | String | | encoder\_starts\_with | String | | encoder\_starts\_with\_nocase | String | | encoder\_not\_starts\_with | String | | encoder\_not\_starts\_with\_nocase | String | | encoder\_ends\_with | String | | encoder\_ends\_with\_nocase | String | | encoder\_not\_ends\_with | String | | encoder\_not\_ends\_with\_nocase | String | | \_change\_block | BlockChangedFilter | | and | \[HookEntity\_filter] | | or | \[HookEntity\_filter] | ### Hook\_filter | Field | Type | | ---------------------------------- | ------------------- | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | token | String | | token\_not | String | | token\_gt | String | | token\_lt | String | | token\_gte | String | | token\_lte | String | | token\_in | \[String!] | | token\_not\_in | \[String!] | | token\_contains | String | | token\_contains\_nocase | String | | token\_not\_contains | String | | token\_not\_contains\_nocase | String | | token\_starts\_with | String | | token\_starts\_with\_nocase | String | | token\_not\_starts\_with | String | | token\_not\_starts\_with\_nocase | String | | token\_ends\_with | String | | token\_ends\_with\_nocase | String | | token\_not\_ends\_with | String | | token\_not\_ends\_with\_nocase | String | | token\_ | TokenEntity\_filter | | data | Bytes | | data\_not | Bytes | | data\_gt | Bytes | | data\_lt | Bytes | | data\_gte | Bytes | | data\_lte | Bytes | | data\_in | \[Bytes!] | | data\_not\_in | \[Bytes!] | | data\_contains | Bytes | | data\_not\_contains | Bytes | | encoder | String | | encoder\_not | String | | encoder\_gt | String | | encoder\_lt | String | | encoder\_gte | String | | encoder\_lte | String | | encoder\_in | \[String!] | | encoder\_not\_in | \[String!] | | encoder\_contains | String | | encoder\_contains\_nocase | String | | encoder\_not\_contains | String | | encoder\_not\_contains\_nocase | String | | encoder\_starts\_with | String | | encoder\_starts\_with\_nocase | String | | encoder\_not\_starts\_with | String | | encoder\_not\_starts\_with\_nocase | String | | encoder\_ends\_with | String | | encoder\_ends\_with\_nocase | String | | encoder\_not\_ends\_with | String | | encoder\_not\_ends\_with\_nocase | String | | name | String | | name\_not | String | | name\_gt | String | | name\_lt | String | | name\_gte | String | | name\_lte | String | | name\_in | \[String!] | | name\_not\_in | \[String!] | | name\_contains | String | | name\_contains\_nocase | String | | name\_not\_contains | String | | name\_not\_contains\_nocase | String | | name\_starts\_with | String | | name\_starts\_with\_nocase | String | | name\_not\_starts\_with | String | | name\_not\_starts\_with\_nocase | String | | name\_ends\_with | String | | name\_ends\_with\_nocase | String | | name\_not\_ends\_with | String | | name\_not\_ends\_with\_nocase | String | | addr | Bytes | | addr\_not | Bytes | | addr\_gt | Bytes | | addr\_lt | Bytes | | addr\_gte | Bytes | | addr\_lte | Bytes | | addr\_in | \[Bytes!] | | addr\_not\_in | \[Bytes!] | | addr\_contains | Bytes | | addr\_not\_contains | Bytes | | \_change\_block | BlockChangedFilter | | and | \[Hook\_filter] | | or | \[Hook\_filter] | ### Member\_filter | Field | Type | | -------------------------------- | ------------------- | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | token | String | | token\_not | String | | token\_gt | String | | token\_lt | String | | token\_gte | String | | token\_lte | String | | token\_in | \[String!] | | token\_not\_in | \[String!] | | token\_contains | String | | token\_contains\_nocase | String | | token\_not\_contains | String | | token\_not\_contains\_nocase | String | | token\_starts\_with | String | | token\_starts\_with\_nocase | String | | token\_not\_starts\_with | String | | token\_not\_starts\_with\_nocase | String | | token\_ends\_with | String | | token\_ends\_with\_nocase | String | | token\_not\_ends\_with | String | | token\_not\_ends\_with\_nocase | String | | token\_ | TokenEntity\_filter | | user | String | | user\_not | String | | user\_gt | String | | user\_lt | String | | user\_gte | String | | user\_lte | String | | user\_in | \[String!] | | user\_not\_in | \[String!] | | user\_contains | String | | user\_contains\_nocase | String | | user\_not\_contains | String | | user\_not\_contains\_nocase | String | | user\_starts\_with | String | | user\_starts\_with\_nocase | String | | user\_not\_starts\_with | String | | user\_not\_starts\_with\_nocase | String | | user\_ends\_with | String | | user\_ends\_with\_nocase | String | | user\_not\_ends\_with | String | | user\_not\_ends\_with\_nocase | String | | user\_ | User\_filter | | ids | \[BigInt!] | | ids\_not | \[BigInt!] | | ids\_contains | \[BigInt!] | | ids\_contains\_nocase | \[BigInt!] | | ids\_not\_contains | \[BigInt!] | | ids\_not\_contains\_nocase | \[BigInt!] | | balance | BigDecimal | | balance\_not | BigDecimal | | balance\_gt | BigDecimal | | balance\_lt | BigDecimal | | balance\_gte | BigDecimal | | balance\_lte | BigDecimal | | balance\_in | \[BigDecimal!] | | balance\_not\_in | \[BigDecimal!] | | \_change\_block | BlockChangedFilter | | and | \[Member\_filter] | | or | \[Member\_filter] | ### MintBurnEntity\_filter | Field | Type | | -------------------------------- | ------------------------- | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | hash | Bytes | | hash\_not | Bytes | | hash\_gt | Bytes | | hash\_lt | Bytes | | hash\_gte | Bytes | | hash\_lte | Bytes | | hash\_in | \[Bytes!] | | hash\_not\_in | \[Bytes!] | | hash\_contains | Bytes | | hash\_not\_contains | Bytes | | blockNum | BigInt | | blockNum\_not | BigInt | | blockNum\_gt | BigInt | | blockNum\_lt | BigInt | | blockNum\_gte | BigInt | | blockNum\_lte | BigInt | | blockNum\_in | \[BigInt!] | | blockNum\_not\_in | \[BigInt!] | | timestamp | BigInt | | timestamp\_not | BigInt | | timestamp\_gt | BigInt | | timestamp\_lt | BigInt | | timestamp\_gte | BigInt | | timestamp\_lte | BigInt | | timestamp\_in | \[BigInt!] | | timestamp\_not\_in | \[BigInt!] | | direction | Int | | direction\_not | Int | | direction\_gt | Int | | direction\_lt | Int | | direction\_gte | Int | | direction\_lte | Int | | direction\_in | \[Int!] | | direction\_not\_in | \[Int!] | | from | Bytes | | from\_not | Bytes | | from\_gt | Bytes | | from\_lt | Bytes | | from\_gte | Bytes | | from\_lte | Bytes | | from\_in | \[Bytes!] | | from\_not\_in | \[Bytes!] | | from\_contains | Bytes | | from\_not\_contains | Bytes | | to | Bytes | | to\_not | Bytes | | to\_gt | Bytes | | to\_lt | Bytes | | to\_gte | Bytes | | to\_lte | Bytes | | to\_in | \[Bytes!] | | to\_not\_in | \[Bytes!] | | to\_contains | Bytes | | to\_not\_contains | Bytes | | erc20Amount | BigDecimal | | erc20Amount\_not | BigDecimal | | erc20Amount\_gt | BigDecimal | | erc20Amount\_lt | BigDecimal | | erc20Amount\_gte | BigDecimal | | erc20Amount\_lte | BigDecimal | | erc20Amount\_in | \[BigDecimal!] | | erc20Amount\_not\_in | \[BigDecimal!] | | nativeAmount | BigDecimal | | nativeAmount\_not | BigDecimal | | nativeAmount\_gt | BigDecimal | | nativeAmount\_lt | BigDecimal | | nativeAmount\_gte | BigDecimal | | nativeAmount\_lte | BigDecimal | | nativeAmount\_in | \[BigDecimal!] | | nativeAmount\_not\_in | \[BigDecimal!] | | platformFee | BigDecimal | | platformFee\_not | BigDecimal | | platformFee\_gt | BigDecimal | | platformFee\_lt | BigDecimal | | platformFee\_gte | BigDecimal | | platformFee\_lte | BigDecimal | | platformFee\_in | \[BigDecimal!] | | platformFee\_not\_in | \[BigDecimal!] | | projectFee | BigDecimal | | projectFee\_not | BigDecimal | | projectFee\_gt | BigDecimal | | projectFee\_lt | BigDecimal | | projectFee\_gte | BigDecimal | | projectFee\_lte | BigDecimal | | projectFee\_in | \[BigDecimal!] | | projectFee\_not\_in | \[BigDecimal!] | | price | BigDecimal | | price\_not | BigDecimal | | price\_gt | BigDecimal | | price\_lt | BigDecimal | | price\_gte | BigDecimal | | price\_lte | BigDecimal | | price\_in | \[BigDecimal!] | | price\_not\_in | \[BigDecimal!] | | tvl | BigDecimal | | tvl\_not | BigDecimal | | tvl\_gt | BigDecimal | | tvl\_lt | BigDecimal | | tvl\_gte | BigDecimal | | tvl\_lte | BigDecimal | | tvl\_in | \[BigDecimal!] | | tvl\_not\_in | \[BigDecimal!] | | tradeVolumes | BigDecimal | | tradeVolumes\_not | BigDecimal | | tradeVolumes\_gt | BigDecimal | | tradeVolumes\_lt | BigDecimal | | tradeVolumes\_gte | BigDecimal | | tradeVolumes\_lte | BigDecimal | | tradeVolumes\_in | \[BigDecimal!] | | tradeVolumes\_not\_in | \[BigDecimal!] | | token | String | | token\_not | String | | token\_gt | String | | token\_lt | String | | token\_gte | String | | token\_lte | String | | token\_in | \[String!] | | token\_not\_in | \[String!] | | token\_contains | String | | token\_contains\_nocase | String | | token\_not\_contains | String | | token\_not\_contains\_nocase | String | | token\_starts\_with | String | | token\_starts\_with\_nocase | String | | token\_not\_starts\_with | String | | token\_not\_starts\_with\_nocase | String | | token\_ends\_with | String | | token\_ends\_with\_nocase | String | | token\_not\_ends\_with | String | | token\_not\_ends\_with\_nocase | String | | token\_ | TokenEntity\_filter | | \_change\_block | BlockChangedFilter | | and | \[MintBurnEntity\_filter] | | or | \[MintBurnEntity\_filter] | ### PlatformEntity\_filter | Field | Type | | ------------------------------ | ------------------------- | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | net | String | | net\_not | String | | net\_gt | String | | net\_lt | String | | net\_gte | String | | net\_lte | String | | net\_in | \[String!] | | net\_not\_in | \[String!] | | net\_contains | String | | net\_contains\_nocase | String | | net\_not\_contains | String | | net\_not\_contains\_nocase | String | | net\_starts\_with | String | | net\_starts\_with\_nocase | String | | net\_not\_starts\_with | String | | net\_not\_starts\_with\_nocase | String | | net\_ends\_with | String | | net\_ends\_with\_nocase | String | | net\_not\_ends\_with | String | | net\_not\_ends\_with\_nocase | String | | addr | Bytes | | addr\_not | Bytes | | addr\_gt | Bytes | | addr\_lt | Bytes | | addr\_gte | Bytes | | addr\_lte | Bytes | | addr\_in | \[Bytes!] | | addr\_not\_in | \[Bytes!] | | addr\_contains | Bytes | | addr\_not\_contains | Bytes | | admin | Bytes | | admin\_not | Bytes | | admin\_gt | Bytes | | admin\_lt | Bytes | | admin\_gte | Bytes | | admin\_lte | Bytes | | admin\_in | \[Bytes!] | | admin\_not\_in | \[Bytes!] | | admin\_contains | Bytes | | admin\_not\_contains | Bytes | | treasury | Bytes | | treasury\_not | Bytes | | treasury\_gt | Bytes | | treasury\_lt | Bytes | | treasury\_gte | Bytes | | treasury\_lte | Bytes | | treasury\_in | \[Bytes!] | | treasury\_not\_in | \[Bytes!] | | treasury\_contains | Bytes | | treasury\_not\_contains | Bytes | | route | Bytes | | route\_not | Bytes | | route\_gt | Bytes | | route\_lt | Bytes | | route\_gte | Bytes | | route\_lte | Bytes | | route\_in | \[Bytes!] | | route\_not\_in | \[Bytes!] | | route\_contains | Bytes | | route\_not\_contains | Bytes | | mintTax | BigInt | | mintTax\_not | BigInt | | mintTax\_gt | BigInt | | mintTax\_lt | BigInt | | mintTax\_gte | BigInt | | mintTax\_lte | BigInt | | mintTax\_in | \[BigInt!] | | mintTax\_not\_in | \[BigInt!] | | burnTax | BigInt | | burnTax\_not | BigInt | | burnTax\_gt | BigInt | | burnTax\_lt | BigInt | | burnTax\_gte | BigInt | | burnTax\_lte | BigInt | | burnTax\_in | \[BigInt!] | | burnTax\_not\_in | \[BigInt!] | | klines | \[String!] | | klines\_not | \[String!] | | klines\_contains | \[String!] | | klines\_contains\_nocase | \[String!] | | klines\_not\_contains | \[String!] | | klines\_not\_contains\_nocase | \[String!] | | \_change\_block | BlockChangedFilter | | and | \[PlatformEntity\_filter] | | or | \[PlatformEntity\_filter] | ### Price\_filter | Field | Type | | -------------------------------- | ------------------- | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | type | String | | type\_not | String | | type\_gt | String | | type\_lt | String | | type\_gte | String | | type\_lte | String | | type\_in | \[String!] | | type\_not\_in | \[String!] | | type\_contains | String | | type\_contains\_nocase | String | | type\_not\_contains | String | | type\_not\_contains\_nocase | String | | type\_starts\_with | String | | type\_starts\_with\_nocase | String | | type\_not\_starts\_with | String | | type\_not\_starts\_with\_nocase | String | | type\_ends\_with | String | | type\_ends\_with\_nocase | String | | type\_not\_ends\_with | String | | type\_not\_ends\_with\_nocase | String | | minPrice | BigDecimal | | minPrice\_not | BigDecimal | | minPrice\_gt | BigDecimal | | minPrice\_lt | BigDecimal | | minPrice\_gte | BigDecimal | | minPrice\_lte | BigDecimal | | minPrice\_in | \[BigDecimal!] | | minPrice\_not\_in | \[BigDecimal!] | | maxPrice | BigDecimal | | maxPrice\_not | BigDecimal | | maxPrice\_gt | BigDecimal | | maxPrice\_lt | BigDecimal | | maxPrice\_gte | BigDecimal | | maxPrice\_lte | BigDecimal | | maxPrice\_in | \[BigDecimal!] | | maxPrice\_not\_in | \[BigDecimal!] | | openPrice | BigDecimal | | openPrice\_not | BigDecimal | | openPrice\_gt | BigDecimal | | openPrice\_lt | BigDecimal | | openPrice\_gte | BigDecimal | | openPrice\_lte | BigDecimal | | openPrice\_in | \[BigDecimal!] | | openPrice\_not\_in | \[BigDecimal!] | | closePrice | BigDecimal | | closePrice\_not | BigDecimal | | closePrice\_gt | BigDecimal | | closePrice\_lt | BigDecimal | | closePrice\_gte | BigDecimal | | closePrice\_lte | BigDecimal | | closePrice\_in | \[BigDecimal!] | | closePrice\_not\_in | \[BigDecimal!] | | tokenTvl | BigDecimal | | tokenTvl\_not | BigDecimal | | tokenTvl\_gt | BigDecimal | | tokenTvl\_lt | BigDecimal | | tokenTvl\_gte | BigDecimal | | tokenTvl\_lte | BigDecimal | | tokenTvl\_in | \[BigDecimal!] | | tokenTvl\_not\_in | \[BigDecimal!] | | timestamp | BigInt | | timestamp\_not | BigInt | | timestamp\_gt | BigInt | | timestamp\_lt | BigInt | | timestamp\_gte | BigInt | | timestamp\_lte | BigInt | | timestamp\_in | \[BigInt!] | | timestamp\_not\_in | \[BigInt!] | | token | String | | token\_not | String | | token\_gt | String | | token\_lt | String | | token\_gte | String | | token\_lte | String | | token\_in | \[String!] | | token\_not\_in | \[String!] | | token\_contains | String | | token\_contains\_nocase | String | | token\_not\_contains | String | | token\_not\_contains\_nocase | String | | token\_starts\_with | String | | token\_starts\_with\_nocase | String | | token\_not\_starts\_with | String | | token\_not\_starts\_with\_nocase | String | | token\_ends\_with | String | | token\_ends\_with\_nocase | String | | token\_not\_ends\_with | String | | token\_not\_ends\_with\_nocase | String | | token\_ | TokenEntity\_filter | | volume | BigDecimal | | volume\_not | BigDecimal | | volume\_gt | BigDecimal | | volume\_lt | BigDecimal | | volume\_gte | BigDecimal | | volume\_lte | BigDecimal | | volume\_in | \[BigDecimal!] | | volume\_not\_in | \[BigDecimal!] | | \_change\_block | BlockChangedFilter | | and | \[Price\_filter] | | or | \[Price\_filter] | ### TokenEntity\_filter | Field | Type | | ------------------------------------------- | ---------------------- | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | index | BigInt | | index\_not | BigInt | | index\_gt | BigInt | | index\_lt | BigInt | | index\_gte | BigInt | | index\_lte | BigInt | | index\_in | \[BigInt!] | | index\_not\_in | \[BigInt!] | | net | String | | net\_not | String | | net\_gt | String | | net\_lt | String | | net\_gte | String | | net\_lte | String | | net\_in | \[String!] | | net\_not\_in | \[String!] | | net\_contains | String | | net\_contains\_nocase | String | | net\_not\_contains | String | | net\_not\_contains\_nocase | String | | net\_starts\_with | String | | net\_starts\_with\_nocase | String | | net\_not\_starts\_with | String | | net\_not\_starts\_with\_nocase | String | | net\_ends\_with | String | | net\_ends\_with\_nocase | String | | net\_not\_ends\_with | String | | net\_not\_ends\_with\_nocase | String | | addr | Bytes | | addr\_not | Bytes | | addr\_gt | Bytes | | addr\_lt | Bytes | | addr\_gte | Bytes | | addr\_lte | Bytes | | addr\_in | \[Bytes!] | | addr\_not\_in | \[Bytes!] | | addr\_contains | Bytes | | addr\_not\_contains | Bytes | | factory | Bytes | | factory\_not | Bytes | | factory\_gt | Bytes | | factory\_lt | Bytes | | factory\_gte | Bytes | | factory\_lte | Bytes | | factory\_in | \[Bytes!] | | factory\_not\_in | \[Bytes!] | | factory\_contains | Bytes | | factory\_not\_contains | Bytes | | name | String | | name\_not | String | | name\_gt | String | | name\_lt | String | | name\_gte | String | | name\_lte | String | | name\_in | \[String!] | | name\_not\_in | \[String!] | | name\_contains | String | | name\_contains\_nocase | String | | name\_not\_contains | String | | name\_not\_contains\_nocase | String | | name\_starts\_with | String | | name\_starts\_with\_nocase | String | | name\_not\_starts\_with | String | | name\_not\_starts\_with\_nocase | String | | name\_ends\_with | String | | name\_ends\_with\_nocase | String | | name\_not\_ends\_with | String | | name\_not\_ends\_with\_nocase | String | | symbol | String | | symbol\_not | String | | symbol\_gt | String | | symbol\_lt | String | | symbol\_gte | String | | symbol\_lte | String | | symbol\_in | \[String!] | | symbol\_not\_in | \[String!] | | symbol\_contains | String | | symbol\_contains\_nocase | String | | symbol\_not\_contains | String | | symbol\_not\_contains\_nocase | String | | symbol\_starts\_with | String | | symbol\_starts\_with\_nocase | String | | symbol\_not\_starts\_with | String | | symbol\_not\_starts\_with\_nocase | String | | symbol\_ends\_with | String | | symbol\_ends\_with\_nocase | String | | symbol\_not\_ends\_with | String | | symbol\_not\_ends\_with\_nocase | String | | metaUri | String | | metaUri\_not | String | | metaUri\_gt | String | | metaUri\_lt | String | | metaUri\_gte | String | | metaUri\_lte | String | | metaUri\_in | \[String!] | | metaUri\_not\_in | \[String!] | | metaUri\_contains | String | | metaUri\_contains\_nocase | String | | metaUri\_not\_contains | String | | metaUri\_not\_contains\_nocase | String | | metaUri\_starts\_with | String | | metaUri\_starts\_with\_nocase | String | | metaUri\_not\_starts\_with | String | | metaUri\_not\_starts\_with\_nocase | String | | metaUri\_ends\_with | String | | metaUri\_ends\_with\_nocase | String | | metaUri\_not\_ends\_with | String | | metaUri\_not\_ends\_with\_nocase | String | | supply | BigDecimal | | supply\_not | BigDecimal | | supply\_gt | BigDecimal | | supply\_lt | BigDecimal | | supply\_gte | BigDecimal | | supply\_lte | BigDecimal | | supply\_in | \[BigDecimal!] | | supply\_not\_in | \[BigDecimal!] | | tokenType | String | | tokenType\_not | String | | tokenType\_gt | String | | tokenType\_lt | String | | tokenType\_gte | String | | tokenType\_lte | String | | tokenType\_in | \[String!] | | tokenType\_not\_in | \[String!] | | tokenType\_contains | String | | tokenType\_contains\_nocase | String | | tokenType\_not\_contains | String | | tokenType\_not\_contains\_nocase | String | | tokenType\_starts\_with | String | | tokenType\_starts\_with\_nocase | String | | tokenType\_not\_starts\_with | String | | tokenType\_not\_starts\_with\_nocase | String | | tokenType\_ends\_with | String | | tokenType\_ends\_with\_nocase | String | | tokenType\_not\_ends\_with | String | | tokenType\_not\_ends\_with\_nocase | String | | bondingCurveType | String | | bondingCurveType\_not | String | | bondingCurveType\_gt | String | | bondingCurveType\_lt | String | | bondingCurveType\_gte | String | | bondingCurveType\_lte | String | | bondingCurveType\_in | \[String!] | | bondingCurveType\_not\_in | \[String!] | | bondingCurveType\_contains | String | | bondingCurveType\_contains\_nocase | String | | bondingCurveType\_not\_contains | String | | bondingCurveType\_not\_contains\_nocase | String | | bondingCurveType\_starts\_with | String | | bondingCurveType\_starts\_with\_nocase | String | | bondingCurveType\_not\_starts\_with | String | | bondingCurveType\_not\_starts\_with\_nocase | String | | bondingCurveType\_ends\_with | String | | bondingCurveType\_ends\_with\_nocase | String | | bondingCurveType\_not\_ends\_with | String | | bondingCurveType\_not\_ends\_with\_nocase | String | | raisingToken | Bytes | | raisingToken\_not | Bytes | | raisingToken\_gt | Bytes | | raisingToken\_lt | Bytes | | raisingToken\_gte | Bytes | | raisingToken\_lte | Bytes | | raisingToken\_in | \[Bytes!] | | raisingToken\_not\_in | \[Bytes!] | | raisingToken\_contains | Bytes | | raisingToken\_not\_contains | Bytes | | params | String | | params\_not | String | | params\_gt | String | | params\_lt | String | | params\_gte | String | | params\_lte | String | | params\_in | \[String!] | | params\_not\_in | \[String!] | | params\_contains | String | | params\_contains\_nocase | String | | params\_not\_contains | String | | params\_not\_contains\_nocase | String | | params\_starts\_with | String | | params\_starts\_with\_nocase | String | | params\_not\_starts\_with | String | | params\_not\_starts\_with\_nocase | String | | params\_ends\_with | String | | params\_ends\_with\_nocase | String | | params\_not\_ends\_with | String | | params\_not\_ends\_with\_nocase | String | | mintTax | BigInt | | mintTax\_not | BigInt | | mintTax\_gt | BigInt | | mintTax\_lt | BigInt | | mintTax\_gte | BigInt | | mintTax\_lte | BigInt | | mintTax\_in | \[BigInt!] | | mintTax\_not\_in | \[BigInt!] | | burnTax | BigInt | | burnTax\_not | BigInt | | burnTax\_gt | BigInt | | burnTax\_lt | BigInt | | burnTax\_gte | BigInt | | burnTax\_lte | BigInt | | burnTax\_in | \[BigInt!] | | burnTax\_not\_in | \[BigInt!] | | paused | Boolean | | paused\_not | Boolean | | paused\_in | \[Boolean!] | | paused\_not\_in | \[Boolean!] | | doomsDays | Boolean | | doomsDays\_not | Boolean | | doomsDays\_in | \[Boolean!] | | doomsDays\_not\_in | \[Boolean!] | | destoryed | Boolean | | destoryed\_not | Boolean | | destoryed\_in | \[Boolean!] | | destoryed\_not\_in | \[Boolean!] | | treasury | Bytes | | treasury\_not | Bytes | | treasury\_gt | Bytes | | treasury\_lt | Bytes | | treasury\_gte | Bytes | | treasury\_lte | Bytes | | treasury\_in | \[Bytes!] | | treasury\_not\_in | \[Bytes!] | | treasury\_contains | Bytes | | treasury\_not\_contains | Bytes | | admin | Bytes | | admin\_not | Bytes | | admin\_gt | Bytes | | admin\_lt | Bytes | | admin\_gte | Bytes | | admin\_lte | Bytes | | admin\_in | \[Bytes!] | | admin\_not\_in | \[Bytes!] | | admin\_contains | Bytes | | admin\_not\_contains | Bytes | | creator | Bytes | | creator\_not | Bytes | | creator\_gt | Bytes | | creator\_lt | Bytes | | creator\_gte | Bytes | | creator\_lte | Bytes | | creator\_in | \[Bytes!] | | creator\_not\_in | \[Bytes!] | | creator\_contains | Bytes | | creator\_not\_contains | Bytes | | marketCap | BigDecimal | | marketCap\_not | BigDecimal | | marketCap\_gt | BigDecimal | | marketCap\_lt | BigDecimal | | marketCap\_gte | BigDecimal | | marketCap\_lte | BigDecimal | | marketCap\_in | \[BigDecimal!] | | marketCap\_not\_in | \[BigDecimal!] | | currentPrice | BigDecimal | | currentPrice\_not | BigDecimal | | currentPrice\_gt | BigDecimal | | currentPrice\_lt | BigDecimal | | currentPrice\_gte | BigDecimal | | currentPrice\_lte | BigDecimal | | currentPrice\_in | \[BigDecimal!] | | currentPrice\_not\_in | \[BigDecimal!] | | lockValue | BigDecimal | | lockValue\_not | BigDecimal | | lockValue\_gt | BigDecimal | | lockValue\_lt | BigDecimal | | lockValue\_gte | BigDecimal | | lockValue\_lte | BigDecimal | | lockValue\_in | \[BigDecimal!] | | lockValue\_not\_in | \[BigDecimal!] | | treasuryFee | BigDecimal | | treasuryFee\_not | BigDecimal | | treasuryFee\_gt | BigDecimal | | treasuryFee\_lt | BigDecimal | | treasuryFee\_gte | BigDecimal | | treasuryFee\_lte | BigDecimal | | treasuryFee\_in | \[BigDecimal!] | | treasuryFee\_not\_in | \[BigDecimal!] | | memberCount | BigInt | | memberCount\_not | BigInt | | memberCount\_gt | BigInt | | memberCount\_lt | BigInt | | memberCount\_gte | BigInt | | memberCount\_lte | BigInt | | memberCount\_in | \[BigInt!] | | memberCount\_not\_in | \[BigInt!] | | decimal | Int8 | | decimal\_not | Int8 | | decimal\_gt | Int8 | | decimal\_lt | Int8 | | decimal\_gte | Int8 | | decimal\_lte | Int8 | | decimal\_in | \[Int8!] | | decimal\_not\_in | \[Int8!] | | baseDecimal | Int8 | | baseDecimal\_not | Int8 | | baseDecimal\_gt | Int8 | | baseDecimal\_lt | Int8 | | baseDecimal\_gte | Int8 | | baseDecimal\_lte | Int8 | | baseDecimal\_in | \[Int8!] | | baseDecimal\_not\_in | \[Int8!] | | txCount | BigInt | | txCount\_not | BigInt | | txCount\_gt | BigInt | | txCount\_lt | BigInt | | txCount\_gte | BigInt | | txCount\_lte | BigInt | | txCount\_in | \[BigInt!] | | txCount\_not\_in | \[BigInt!] | | createTimestamp | BigInt | | createTimestamp\_not | BigInt | | createTimestamp\_gt | BigInt | | createTimestamp\_lt | BigInt | | createTimestamp\_gte | BigInt | | createTimestamp\_lte | BigInt | | createTimestamp\_in | \[BigInt!] | | createTimestamp\_not\_in | \[BigInt!] | | prices\_ | Price\_filter | | hooks\_ | Hook\_filter | | mintBurnTxs\_ | MintBurnEntity\_filter | | members\_ | Member\_filter | | \_change\_block | BlockChangedFilter | | and | \[TokenEntity\_filter] | | or | \[TokenEntity\_filter] | ### TokenType\_filter | Field | Type | | ------------------------------- | -------------------- | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | name | String | | name\_not | String | | name\_gt | String | | name\_lt | String | | name\_gte | String | | name\_lte | String | | name\_in | \[String!] | | name\_not\_in | \[String!] | | name\_contains | String | | name\_contains\_nocase | String | | name\_not\_contains | String | | name\_not\_contains\_nocase | String | | name\_starts\_with | String | | name\_starts\_with\_nocase | String | | name\_not\_starts\_with | String | | name\_not\_starts\_with\_nocase | String | | name\_ends\_with | String | | name\_ends\_with\_nocase | String | | name\_not\_ends\_with | String | | name\_not\_ends\_with\_nocase | String | | impl | Bytes | | impl\_not | Bytes | | impl\_gt | Bytes | | impl\_lt | Bytes | | impl\_gte | Bytes | | impl\_lte | Bytes | | impl\_in | \[Bytes!] | | impl\_not\_in | \[Bytes!] | | impl\_contains | Bytes | | impl\_not\_contains | Bytes | | \_change\_block | BlockChangedFilter | | and | \[TokenType\_filter] | | or | \[TokenType\_filter] | ### TokenUpgradeHistory\_filter | Field | Type | | -------------------------------- | ------------------------------ | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | token | String | | token\_not | String | | token\_gt | String | | token\_lt | String | | token\_gte | String | | token\_lte | String | | token\_in | \[String!] | | token\_not\_in | \[String!] | | token\_contains | String | | token\_contains\_nocase | String | | token\_not\_contains | String | | token\_not\_contains\_nocase | String | | token\_starts\_with | String | | token\_starts\_with\_nocase | String | | token\_not\_starts\_with | String | | token\_not\_starts\_with\_nocase | String | | token\_ends\_with | String | | token\_ends\_with\_nocase | String | | token\_not\_ends\_with | String | | token\_not\_ends\_with\_nocase | String | | token\_ | TokenEntity\_filter | | upgradeTo | Bytes | | upgradeTo\_not | Bytes | | upgradeTo\_gt | Bytes | | upgradeTo\_lt | Bytes | | upgradeTo\_gte | Bytes | | upgradeTo\_lte | Bytes | | upgradeTo\_in | \[Bytes!] | | upgradeTo\_not\_in | \[Bytes!] | | upgradeTo\_contains | Bytes | | upgradeTo\_not\_contains | Bytes | | data | String | | data\_not | String | | data\_gt | String | | data\_lt | String | | data\_gte | String | | data\_lte | String | | data\_in | \[String!] | | data\_not\_in | \[String!] | | data\_contains | String | | data\_contains\_nocase | String | | data\_not\_contains | String | | data\_not\_contains\_nocase | String | | data\_starts\_with | String | | data\_starts\_with\_nocase | String | | data\_not\_starts\_with | String | | data\_not\_starts\_with\_nocase | String | | data\_ends\_with | String | | data\_ends\_with\_nocase | String | | data\_not\_ends\_with | String | | data\_not\_ends\_with\_nocase | String | | timestamp | BigInt | | timestamp\_not | BigInt | | timestamp\_gt | BigInt | | timestamp\_lt | BigInt | | timestamp\_gte | BigInt | | timestamp\_lte | BigInt | | timestamp\_in | \[BigInt!] | | timestamp\_not\_in | \[BigInt!] | | operator | Bytes | | operator\_not | Bytes | | operator\_gt | Bytes | | operator\_lt | Bytes | | operator\_gte | Bytes | | operator\_lte | Bytes | | operator\_in | \[Bytes!] | | operator\_not\_in | \[Bytes!] | | operator\_contains | Bytes | | operator\_not\_contains | Bytes | | tx | Bytes | | tx\_not | Bytes | | tx\_gt | Bytes | | tx\_lt | Bytes | | tx\_gte | Bytes | | tx\_lte | Bytes | | tx\_in | \[Bytes!] | | tx\_not\_in | \[Bytes!] | | tx\_contains | Bytes | | tx\_not\_contains | Bytes | | type | String | | type\_not | String | | type\_gt | String | | type\_lt | String | | type\_gte | String | | type\_lte | String | | type\_in | \[String!] | | type\_not\_in | \[String!] | | type\_contains | String | | type\_contains\_nocase | String | | type\_not\_contains | String | | type\_not\_contains\_nocase | String | | type\_starts\_with | String | | type\_starts\_with\_nocase | String | | type\_not\_starts\_with | String | | type\_not\_starts\_with\_nocase | String | | type\_ends\_with | String | | type\_ends\_with\_nocase | String | | type\_not\_ends\_with | String | | type\_not\_ends\_with\_nocase | String | | \_change\_block | BlockChangedFilter | | and | \[TokenUpgradeHistory\_filter] | | or | \[TokenUpgradeHistory\_filter] | ### User\_filter | Field | Type | | --------------- | ------------------ | | id | ID | | id\_not | ID | | id\_gt | ID | | id\_lt | ID | | id\_gte | ID | | id\_lte | ID | | id\_in | \[ID!] | | id\_not\_in | \[ID!] | | members\_ | Member\_filter | | \_change\_block | BlockChangedFilter | | and | \[User\_filter] | | or | \[User\_filter] | # Enums 🧙‍ All entities sorted ### BondingCurveType\_orderBy | Value | | ----- | | id | | name | | impl | ### CounterEntity\_orderBy | Value | | --------- | | id | | count | | type | | timestamp | ### HookEntity\_orderBy | Value | | ------- | | id | | name | | addr | | encoder | ### Hook\_orderBy | Value | | ------------------------- | | id | | token | | token\_\_id | | token\_\_index | | token\_\_net | | token\_\_addr | | token\_\_factory | | token\_\_name | | token\_\_symbol | | token\_\_metaUri | | token\_\_supply | | token\_\_tokenType | | token\_\_bondingCurveType | | token\_\_raisingToken | | token\_\_params | | token\_\_mintTax | | token\_\_burnTax | | token\_\_paused | | token\_\_doomsDays | | token\_\_destoryed | | token\_\_treasury | | token\_\_admin | | token\_\_creator | | token\_\_marketCap | | token\_\_currentPrice | | token\_\_lockValue | | token\_\_treasuryFee | | token\_\_memberCount | | token\_\_decimal | | token\_\_baseDecimal | | token\_\_txCount | | token\_\_createTimestamp | | data | | encoder | | name | | addr | ### Member\_orderBy | Value | | ------------------------- | | id | | token | | token\_\_id | | token\_\_index | | token\_\_net | | token\_\_addr | | token\_\_factory | | token\_\_name | | token\_\_symbol | | token\_\_metaUri | | token\_\_supply | | token\_\_tokenType | | token\_\_bondingCurveType | | token\_\_raisingToken | | token\_\_params | | token\_\_mintTax | | token\_\_burnTax | | token\_\_paused | | token\_\_doomsDays | | token\_\_destoryed | | token\_\_treasury | | token\_\_admin | | token\_\_creator | | token\_\_marketCap | | token\_\_currentPrice | | token\_\_lockValue | | token\_\_treasuryFee | | token\_\_memberCount | | token\_\_decimal | | token\_\_baseDecimal | | token\_\_txCount | | token\_\_createTimestamp | | user | | user\_\_id | | ids | | balance | ### MintBurnEntity\_orderBy | Value | | ------------------------- | | id | | hash | | blockNum | | timestamp | | direction | | from | | to | | erc20Amount | | nativeAmount | | platformFee | | projectFee | | price | | tvl | | tradeVolumes | | token | | token\_\_id | | token\_\_index | | token\_\_net | | token\_\_addr | | token\_\_factory | | token\_\_name | | token\_\_symbol | | token\_\_metaUri | | token\_\_supply | | token\_\_tokenType | | token\_\_bondingCurveType | | token\_\_raisingToken | | token\_\_params | | token\_\_mintTax | | token\_\_burnTax | | token\_\_paused | | token\_\_doomsDays | | token\_\_destoryed | | token\_\_treasury | | token\_\_admin | | token\_\_creator | | token\_\_marketCap | | token\_\_currentPrice | | token\_\_lockValue | | token\_\_treasuryFee | | token\_\_memberCount | | token\_\_decimal | | token\_\_baseDecimal | | token\_\_txCount | | token\_\_createTimestamp | ### PlatformEntity\_orderBy | Value | | -------- | | id | | net | | addr | | admin | | treasury | | route | | mintTax | | burnTax | | klines | ### Price\_orderBy | Value | | ------------------------- | | id | | type | | minPrice | | maxPrice | | openPrice | | closePrice | | tokenTvl | | timestamp | | token | | token\_\_id | | token\_\_index | | token\_\_net | | token\_\_addr | | token\_\_factory | | token\_\_name | | token\_\_symbol | | token\_\_metaUri | | token\_\_supply | | token\_\_tokenType | | token\_\_bondingCurveType | | token\_\_raisingToken | | token\_\_params | | token\_\_mintTax | | token\_\_burnTax | | token\_\_paused | | token\_\_doomsDays | | token\_\_destoryed | | token\_\_treasury | | token\_\_admin | | token\_\_creator | | token\_\_marketCap | | token\_\_currentPrice | | token\_\_lockValue | | token\_\_treasuryFee | | token\_\_memberCount | | token\_\_decimal | | token\_\_baseDecimal | | token\_\_txCount | | token\_\_createTimestamp | | volume | ### TokenEntity\_orderBy | Value | | ---------------- | | id | | index | | net | | addr | | factory | | name | | symbol | | metaUri | | supply | | tokenType | | bondingCurveType | | raisingToken | | params | | mintTax | | burnTax | | paused | | doomsDays | | destoryed | | treasury | | admin | | creator | | marketCap | | currentPrice | | lockValue | | treasuryFee | | memberCount | | decimal | | baseDecimal | | txCount | | createTimestamp | | prices | | hooks | | mintBurnTxs | | members | ### TokenType\_orderBy | Value | | ----- | | id | | name | | impl | ### TokenUpgradeHistory\_orderBy | Value | | ------------------------- | | id | | token | | token\_\_id | | token\_\_index | | token\_\_net | | token\_\_addr | | token\_\_factory | | token\_\_name | | token\_\_symbol | | token\_\_metaUri | | token\_\_supply | | token\_\_tokenType | | token\_\_bondingCurveType | | token\_\_raisingToken | | token\_\_params | | token\_\_mintTax | | token\_\_burnTax | | token\_\_paused | | token\_\_doomsDays | | token\_\_destoryed | | token\_\_treasury | | token\_\_admin | | token\_\_creator | | token\_\_marketCap | | token\_\_currentPrice | | token\_\_lockValue | | token\_\_treasuryFee | | token\_\_memberCount | | token\_\_decimal | | token\_\_baseDecimal | | token\_\_txCount | | token\_\_createTimestamp | | upgradeTo | | data | | timestamp | | operator | | tx | | type | ### User\_orderBy | Value | | ------- | | id | | members | ### OrderDirection Defines the order direction, either ascending or descending | Value | | ----- | | asc | | desc | ### SubgraphErrorPolicy | Value | Description | | ----- | ----------------------------------------------------------------------- | | allow | Data will be returned even if the subgraph has indexing errors | | deny | If the subgraph has indexing errors, data will be omitted. The default. | # Query Query entity parameters ### Entity Arguments | Field | Type | | ------------- | ------------------- | | id | ID! | | block | Block\_height | | subgraphError | SubgraphErrorPolicy | ### Entities Arguments | Field | Type | | -------------- | ------------------- | | skip | Int = 0 | | first | Int = 100 | | orderBy | \*\*Entity\_orderBy | | orderDirection | OrderDirection | | where | \*\*Entity\_filter | | block | Block\_height | | subgraphError | SubgraphErrorPolicy | # Burve Referral Program To thank the community for your tight support, Burve Protocol will continue rolling out its Referral Programs. Please refer to [this link](https://burve.medium.com/1-5c4836d1ffe1) for details on [Referral Program Season 1.](https://burve.medium.com/1-5c4836d1ffe1) # Burve Blazers NFT Burve Blazers NFT is the genesis NFT launched by Burve Protocol, illustrated by French artist Ms. Durand. **Chain**: Ethereum Mainnet **Benefits**: 1. NFTs can be freely traded in various marketplaces to generate financial benefits. 2. NFT holders during the snapshot will receive $BRV token airdrop. For specific distribution rules, please refer to [$BRV Tokenomics](/token-economy). **How it works**: Before all cards are distributed, users hold NFTs in the style shown in the figure below. Once 100% cards are minted, the smart contract will unveil the true appearance of the NFT for all holders.

Burve Blazers NFT

**How to get**: The first 3,000 Burve Blazers NFTs will be awarded to those who successfully launch an LOL (when the LOL market cap reaches $33K). The remaining distribution rules will be announced later. # Security Audit Audit Report 1 (**Certik**: ):
Audit Report 2 (**Beosin**: ): {% file src="/files/sYtGV2ltX8Sqy7rQewhI" %} Audit Report 3 (**QuillAudits**: ):
Audit Report 4 (**Scalebit**: ): {% file src="/files/7ChMVOAm0Rn2qUubdgBT" %} Version 1.0 {% endfile %} {% file src="/files/6HgmAlSxwJRJqrpQJu4B" %} Version 2.0 for LOL Feature {% endfile %} # Roadmap **Q2. 2024** * [x] Launch Burve Protocol Version 1.0 \[HODL LaunchDex] * [x] Integrating Base & BSC Chains in Launchpad 1.0 * [x] Support ERC20, Trading Tax Module, Delayed Trading Module and Pre-mint Module in Launchpad 1.0 * [x] The BNB Chain Q1.2024 [Global Hackathon Prize](https://twitter.com/BNBCHAIN/status/1770566766499959100) * [x] Total Market Cap reaches $30M * [x] Number of on-chain Active Users reaches 10K **Q3. 2024** * [x] Launch Burve Protocol Version 1.1 and Version 2.0 * [x] Support Maximum Supply Module, Lending & Borrowing Module, Linear Curve AMM and more in LaunchDex * [x] Support LOL Mode (Meme IDO) * [ ] Launch SRT Standard and the ultimate innovative SRT product (Project details to be revealed ) * [x] Base Chain on-chain Summer Hackathon Winner * [x] Base Grant * [x] Number of on-chain Active Users reaches 200K * [x] Pre-seed Round Fundraising **Q4.2024** * [ ] Launch Burve Protocol Version 2.1 & 2.2 * [ ] Burve BLP * [ ] BSR Bot * [ ] Burve SDK * [ ] Number of on-chain Active Users reaches 1M * [ ] Total Transaction Volume reaches $1B * [ ] TVL reaches $100M **2025** * [ ] Space Race * [ ] TGE * [ ] Burve Appchain (Application-Specific Blockchain) * [ ] The off-chain transaction sequencer and aggregation engine enhance transaction throughput, providing users with an almost zero gas fee experience, and effectively mitigating MEV risks **Reveal more...** # Token Economy *Content update forthcoming...* # Links :house\_with\_garden: Home: [www.burve.io](http://www.burve.io) 🌊 dApp: :heavy\_multiplication\_x: X/Twitter (Burve Protocol): :heavy\_multiplication\_x: X/Twitter (Burve Labs): :space\_invader: Discord: :blue\_book: Medium: :video\_camera: YouTube: :sound: MediaKit:
# Get Started ### Introduction he Burve Protocol SDK is designed to facilitate seamless interaction with Burve Protocol smart contracts in TypeScript/JavaScript environments, such as web applications and server-side scripts. By utilizing the Core SDK, it provides powerful abstractions and tools tailored to the unique features of the Buve Protocol. **Key Features:** * **Data Handling**: Efficiently manage and manipulate data retrieved from the EVM. * **Precision Tools**: Ensure accuracy with libraries that prevent rounding errors and enforce strict typing at compile time. * **Comprehensive Integration**: Simplify the integration process with our extensive set of utilities and helper functions. ### Installation[​](https://docs.uniswap.org/sdk/v3/overview#installation) To interact with the SDK, you can install the package with If you have any questions or concerns, please don't hesitate to reach out to us through any available [method.](/burve-sdk/links) # Fetching data Our SDK simplifies the process of fetching data for different tokens. Below is a step-by-step guide on how you can use the SDK to retrieve data for LOL and HODL tokens: ## LOL Tokens ### Identifying Data[​](https://docs.uniswap.org/sdk/v2/guides/fetching-data#identifying-data) ### Required Data[​](https://docs.uniswap.org/sdk/v2/guides/fetching-data#required-data) ### Optional Data[​](https://docs.uniswap.org/sdk/v2/guides/fetching-data#optional-data) ## HODL Pairs ### Identifying Data[​](https://docs.uniswap.org/sdk/v2/guides/fetching-data#identifying-data-1) ### Required Data[​](https://docs.uniswap.org/sdk/v2/guides/fetching-data#required-data-1) #### Provided by the User[​](https://docs.uniswap.org/sdk/v2/guides/fetching-data#provided-by-the-user-1) # Launch LOL token In this section, we will guide you through the process of creating LOL tokens using the SDK. **Set Up Wallet and Provider** **Define Token Parameters** **Deploy the Token Contract** # Launch HODL token In this section, we will cover the necessary steps to create HODL tokens using the SDK. **Set Up Wallet and Provider** **Define Token Parameters** **Deploy the Token Contract** # Swap This guide will cover how to get the current quotes for any token pair on the Burve Protocol # Getting a Quote # Executing a Trade # Routing a Swap # Links :house\_with\_garden: Home: [www.burve.io](http://www.burve.io) 🌊 dApp: :heavy\_multiplication\_x: X/Twitter (Burve Protocol): :heavy\_multiplication\_x: X/Twitter (Burve Labs): :space\_invader: Discord: :blue\_book: Medium: :video\_camera: YouTube: :sound: MediaKit: