We are happy to share the details of the IDO with our community.

The sale will happen in three phases with the increasing amount of $AURORA tokens available for sale. The three chosen platforms (SmartPad, BocaChica, Skyward) are on the NEAR blockchain to develop its ecosystem. All tokens are distributed to the users only at Token Generation Event (TGE), which will happen one day after the Skyward sale. No tokens will be locked.

## IDO Process

### Basic information

- Total amount of sale: **1,000,000 $AURORA**
- Platforms for sale:
   - SmartPad (Aurora);
   - BocaChica (NEAR);
   - Skyward (NEAR).
- TGE: November 18, 13:00 UTC

### Sale Schedule

#### SmartPad Sale

Date: **November 4, 2021**
Amount: 50,000 $AURORA
Price: $1 
Accepted tokens: ETH

SmartPad sale would happen on Aurora with the price of the token $1-worth of ETH at the moment of the sale. The sale is open to everyone. The size of the check for a single user ranges from $50 to $200. The platform is working on the first come – first served basis.

#### BocaChica Sale

Date: **November 11, 2021**
Amount: 300,000 $AURORA
Price: $1 
Accepted tokens: NEAR

BocaChica sale would happen on NEAR with the price of the token $1-worth of $NEAR at the moment of the sale. The sale is open to the users who are staking at least 50 $NEAR. The size of the check for a single user ranges from $50 to $250. The platform is working on the first come – first served basis.

#### Skyward Sale

Date: November 17, 2021 
Amount: 650,000 $fAURORA 
Price: non-fixed 
Accepted tokens: NEAR

Skyward sale would happen on NEAR blockchain. The sale on Skyward will be open for 12 hours. Due to the specifics of the Skyward platform (continuous token distribution), during the sale we will sell $fAURORA – the future $AURORA token that will be automatically swapped to the $AURORA token at the TGE.

$fAURORA is a non-transferrable token, so once users get it on the Skyward sale, they are unable to do anything with it until it is swapped to $AURORA.

### Post-sale activity

All the collected proceedings of $AURORA sale will be put into liquidity pools. Aurora Labs will explore the opportunities to incentivize the pools.

Due to the nature of the blockchain and constant changes in prices, transaction queues etc., the actual implemented scenario may have minor changes.

AuroraDAO have voted to approve the process of $AURORA IDO.

Aurora DAO Approves $AURORA IDO

In line with the multichain future vision, DODO is expanding the list of networks it is available on. DODO is officially launching on the NEAR Protocol, using Aurora as the Ethereum-compatible scaling solution! Not only that, but DODO have reached an agreement with the NEAR team to have DODO as the **‘blue chip’ decentralized exchange (DEX)** on their platform. This unprecedented deal will ensure that DODO has ‘first mover’ advantage in this new and exciting space.

The NEAR Protocol is a Proof-of-Stake (PoS) blockchain that’s intended as a community-run platform to host decentralized applications (dApps), but with unique sharding technology designed to make it much **cheaper and more scalable** than some popular competitors like Ethereum. Does this mean the hardworking developer community has to reprogram the whole DEX from scratch? Not at all! Using Aurora as the Layer 2 go-between, DODO is able to seamlessly deploy onto the NEAR Protocol, despite having been developed to be compatible with the EVM.

“We’re excited to see big Ethereum players coming to Aurora to expand their businesses,” Alex Shevchenko, CEO of Aurora, said, “I’m glad that in such a short timeframe we were able to satisfy all the technical requirements of DODO: RPC methods, The Graph integration, and others. And now on Aurora we see **one of the most influential decentralized trading protocols** being fully operational.”

## Why DODO On NEAR?

You might be wondering, “Ok, yet another chain DODO’s integrating with. Why should I care?” You might also be surprised to learn that Aurora currently has **an average block time of one second and zero transaction costs** (you read that right)! The NEAR Protocol and Aurora are fast, low-cost, easy to use, secure, and meet all of our technical requirements. The NEAR Protocol is also climate neutral, so you can save the environment and save money, too. Based on these and other considerations, the DODO Team has determined that NEAR/Aurora will likely be the “next big thing” in Layer 1 technology. Together, we foresee this deployment ensuring DODO’s continued growth and market success for years to come.

There has never been a better time to make a dApp on NEAR - and if that’s something you’re into, please don’t hesitate to contact DODO.

## Looking Ahead

DODO expect to achieve the following over the next six months:

- Total Value Locked (TVL): **$100M+**
- Volume: **$300M+**
- Users: **100k+**
- Transactions: **100k+**

To achieve these, the DODO and Aurora/NEAR teams will collaborate in a marketing campaign to promote the deployment, and especially our generous user incentives, on all official channels.

“Our deployment on the NEAR Protocol is unlike our other recent multichain campaigns,” said Diane Dai, DODO’s CMO, “Since DODO has a unique ‘blue chip’ advantage on NEAR, we are more prepared than ever to bring market-leading liquidity to as many people as possible.”

Aurora believes that the launch of DODO is an important milestone in creating a healthy NEAR and Aurora ecosystem with strong partners and a great variety of products for the community.

DODO is coming to the NEAR Protocol by launching on Aurora.

DODO launches on Aurora to encompass the features of NEAR blockchain

Aurora, an Ethereum scaling solution that allows projects built on Ethereum to utilise the cutting-edge technology of the NEAR Protocol, has launched one of its most requested features: a block explorer for the Aurora network, which can be found at [explorer.aurora.dev](https://explorer.mainnet.aurora.dev/).

Earlier Aurora has announced [a partnership with Etherscan](https://awesomenear.com/articles/etherscan-will-launch-on-aurora/), planned to complete its launch later in the year. However, Aurora saw the need to provide devs with a block explorer well before the Etherscan integration is complete. Aurora is launching its instance of the open source [BlockScout](https://explorer.mainnet.aurora.dev/) for the Aurora network.

The Aurora explorer is a blockchain search engine that allows users to search for Aurora transactions on the Aurora network.

An ability to view all blockchain transactions is crucial for the convenience of users and developers. So, the Aurora explorer gives users access to transaction details about specific wallet addresses including amount transacted, sources, destination of funds, and transaction status.

## Why is an explorer on Aurora needed?

Aurora is a layer-2 Ethereum Virtual Machine (EVM) built and functioning on the NEAR Protocol blockchain, delivering a turn-key solution for developers to operate their DApps on an Ethereum-compatible, high-throughput, scalable, and future-safe platform, with low transaction costs for their users. Data is central to DApps and projects. An explorer facilitates this by providing the infrastructure for DApps and projects to have access to on-chain data.

The capabilities of Aurora are possible because it is built on top of the NEAR Protocol. NEAR is a modern layer-1 blockchain which is fast (2-3 second transaction finalization), scalable, and carbon neutral. The launch of an explorer gives any user instant and transparent access to Aurora’s on-chain data, adding accessible transparency to the network.

Aurora provides the Ethereum 1.0 development experience, with layer-2-like speed and scalability. If you are an Ethereum developer, getting started on Aurora is as easy as changing the RPC endpoint you interact with. Due to this, Aurora is giving devs instant access to a block explorer so they can get started with us today.

## Etherscan partnership

The first signs of the partnership between Etherscan and Aurora were made last week, when the AuroraDAO approved the addition of Etherscan representatives to the AuroraDAO council.

With an announcement that Aurora will partner with Etherscan to integrate Etherscan’s block exploring capabilities across the Aurora network, the Aurora team could not wait but to launch their instance of the blockchain explorer.

## What will the Aurora explorer be able to do?

The blockchain search engine is built using the open source EVM block explorer BlockScout. Its utility is to give transaction details about specific wallet addresses, including:

- amount transacted,
- sources,
- destination of funds,
- transaction status, and more.

At Aurora we believe that the future of blockchains will strongly depend on cross-chain communications and interoperability. That is why we are committed to providing top notch technology and are excited to grow our services in line with this vision! To foster this development, a block explorer has launched on Aurora for any existing and future users to use to their benefit.

Aurora has launched its instance of BlockScout: a block explorer for the Aurora network.

Aurora launches a block explorer to further improve user and developer experience

We are happy to announce the latest release of Aurora’s EVM Engine, version 2.4.0. Despite its innocuous-seeming version number, this release has had a big impact on several of our partners and thus furthers Aurora’s mission to expand the Ethereum ecosystem. Let’s get to it!

## Summary:
1. Quick reminder
2. Why is this update important for both users and developers ?
3. The Aurigami case
4. Technical details

## 1) Quick (and useful) reminder

Aurora is built on the NEAR blockchain, which differs from Ethereum 1.0 in a number of ways. The important one for this story is that the NEAR protocol places limits on how many things each transaction can do, while the Ethereum protocol only sets limits on each block (though users can set limits for their own individual transactions).

Therefore, Aurora must (in theory) fit an entire Ethereum block into a single NEAR transaction. This is quite challenging, but with Engine release 2.4.0 we have pushed some performance optimizations which move us closer to this ambitious goal.

## 2) Why is this update important for both users and developers ?

Many defi projects were meeting the error **Exceeded the maximum amount of gas allowed to burn per contract** and were confused because “gas” and “contract” are terms in Ethereum.

However, this error was actually coming from the NEAR transaction; “gas” was referring to NEAR gas (not EVM gas), and “contract” was specifically referring to Aurora’s Engine smart contract on NEAR. Given this context, the error message is pretty clear; there is some maximum amount of gas a contract is allowed to burn in a single transaction and our Engine is exceeding it trying to run these defi transactions.

Well guess what? With the 2.4.0 engine release, the problem is slowly coming to an end - we reduced the Engine’s gas usage by a factor 2, opening some very important use cases for developers, and making life easier for users by making it twice harder to accidentally hit the limit.

In particular, the amount of EVM computation that can fit in a single transaction now is sufficient to unblock some defi use cases that previously were simply not possible on Aurora.

## 3) The Aurigami case

We would like to shout out [Aurigami](https://awesomenear.com/aurigami), one of our DeFi partners, for devoting development resources to help us identify some of the opportunities for optimization that lead to this new release.

Thanks to the Engine 2.4.0 release, Aurigami was able to launch [on Aurora’s testnet](https://testnet.aurigami.finance/). As they are a borrowing and lending platform, this update was a core requirement to run their platform as smoothly as possible. It is globally even more important as this type of platform is crucial for the decentralized financial infrastructure of the Aurora ecosystem.

We are excited to see our ecosystem continue to grow and look forward to future updates that enable yet more defi use cases you know and love from Ethereum!

## 4) Technical details

If you’re still here, that’s great! You’re in for a real treat. Let’s get technical.

Let’s start with a quick recap of what the [Aurora Engine](https://github.com/aurora-is-near/aurora-engine) is and how it works. The Engine is a smart contract written in Rust on the NEAR blockchain. It contains a full EVM interpreter to be able to execute transactions exactly the same as Ethereum, as well as all the auxiliary logic for validating transactions before execution (checking signature, nonce, account balance vs gas price, etc).

When you send a transaction to an [Aurora RPC endpoint](https://doc.aurora.dev/getting-started/network-endpoints) our infrastructure wraps your signed Ethereum transaction into a NEAR transaction for the Engine. This means each Aurora transaction becomes a NEAR transaction, and therefore must follow the rules of the NEAR protocol. As mentioned in the summary, this is where the NEAR gas issue arises (and not Ethereum, as explained previously).

Naturally this raises the question: “how can the Engine be made more efficient so that it can do more EVM work within the same amount of NEAR gas?”

This is not an easy question to answer (and indeed we continue the optimization effort), but is critical for Aurora’s success. Fortunately for us, core developers at NEAR and developers at Aurigami, one of the affected defi projects, were willing to help us find answers to that question.

There turned out to be a few low-hanging fruits that together had a big impact.

- [Update to a more recent version of Rust](https://github.com/aurora-is-near/aurora-engine/pull/427) The rust compiler is good at optimizing the performance of code, and is always getting better. Simply moving to a later version of rust gave about a 1% improvement essentially for free.
- [Use little-endian representation of numbers on the EVM stack](https://github.com/aurora-is-near/sputnikvm/pull/7) The EVM technically is defined to use big endian encoding, however most modern architectures use little endian. Constantly switching the byte order of numbers going on and off the stack for arithmetic operations was quite costly compared to using little endian on the stack and only switching to big endian when necessary (e.g. writing to storage or returning a result).
- [Short-circuit the account empty check](https://github.com/aurora-is-near/aurora-engine/pull/439) An Ethereum account is considered “empty” if its nonce and balance are both 0 and no code is deployed there. Of course as soon as any one of those conditions is not met we need not check the others.
- Caching values read from the NEAR state by the Engine contract ([#438](https://github.com/aurora-is-near/aurora-engine/pull/438)) ([#446](https://github.com/aurora-is-near/aurora-engine/pull/446)) This improvement had the biggest impact on gas usage of the Engine. The full details as to why are given below.

All these changes together made the Engine consume around half the NEAR gas it did previously when executing certain defi transactions. This 2x improvement was enough to unblock Aurigami and allow them to [launch on Aurora’s testnet](https://testnet.aurigami.finance/).

To understand why the caching change was so impactful, we need to know a little about how NEAR represents state and how it determines gas costs. As many blockchains do, NEAR uses a trie to store the state as this allows creating fairly compact proofs of what is stored on chain. Each contract on NEAR has its own key-value storage for its state, and this is embedded within the full NEAR state trie.

NEAR is very careful about setting its gas costs. The goal is to ensure they can maintain the 1-second block time which enables the web2-like UX of nearly instant transaction confirmations. To achieve this goal it must be true that no block can take more than 1 second to process, and in particular all the transactions in the block must also fit in this time. Since gas is the measurement of computational work, the idea is simple: ensure the gas costs are carefully measured so that 1 second of work done by a transaction corresponds to a fixed amount of gas, and then set the limits much lower than that.

To have such a stringent connection between gas cost and wall-clock time, there must be a separate cost for essentially all operations a transaction could cause the node to perform. For example, there is read_base which is the cost for doing any contract state read whatsoever, as well as read_byte which is the cost on top of the base cost per byte read. Getting back to the state details, there is also the touching_trie_node cost which is the cost incurred for each node of the state trie that must be touched to read or write a value from storage.

As it turns out, these IO costs made up a large fraction of the total gas used by the Engine; more than 50% in some cases.Therefore, reducing the number of state reads necessary by introducing caching was a net win. Even though the cache logic itself has a cost (not to mention its memory footprint also has a cost), this was less than the amount saved by doing fewer reads.

To add even more nuance here, it turned out that some types of values required different caching logic than others. One particular value, called the “generation” is an implementation detail of the Engine. Each address has a “generation” associated with it. This value allows us to “delete” an entire address without actually incurring much IO cost; we simply increment the generation and ignore any state that was associated with lower generation values.

This means that reading a value from an EVM contract’s storage (which looks like a single read to devs at the Solidity level) turned out to be multiple reads because the Engine needed to read the generation first. However, the generation does not change over the course of a transaction (if an account is deleted and recreated in the same transaction these changes are actually cached in memory by the EVM interpreter, so the generation value written in the NEAR state never changes during a transaction). Moreover, a single transaction generally doesn’t touch many different addresses (even complex defi transactions rarely call more than 10 different EVM contracts). Therefore we can cache the complete address to generation mapping with each read, and this is exactly what was [implemented](https://github.com/aurora-is-near/aurora-engine/pull/438).

On the other hand, EVM contract storage lookup themselves could not be fully cached without significant overhead both because the values could potentially be much larger than the 32-bit number representing the generation, and because the keys could be much more numerous; if a transaction invokes 10 different contracts and each had to read 10 values from storage then that is 100 different keys to cache along with their values.

Moreover, it’s not clear all this caching would be worthwhile since a given value from the contract storage may not be read multiple times, whereas we were essentially guaranteed to need the generation value for an address multiple times. Therefore, the same kind of cache we used for generation values was not suitable for more general caching. However, it did benefit from a different kind of cache. Due to an inefficiency in the EVM interpreter (which we will address properly in the future), it turned out that what looked like reading a value once at the Solidity level, translated into consecutive, repeated reads of that value at the Engine level. There were examples where the same value could be read 3 or 4 times in a row! Fortunately consecutive, repeated reads can be addressed with an extremely simple LRU cache of size 1, and this is what was [implemented](https://github.com/aurora-is-near/aurora-engine/pull/446).

Whew, congrats on making it to the end! I hope you enjoyed this deep dive into the Aurora Engine. We continue this kind of optimization work as we advance our mission to expand Aurora to include more and more use cases. If this sounded interesting to you and you are proficient in Rust, consider taking a look at our careers page, we’d love to hear from you.

Despite its innocuous-seeming version number, this release has had a big impact on several of our partners and thus furthers Aurora’s mission to expand the Ethereum ecosystem.

Aurora Continues to Push EVM Scaling With Engine 2.4.0 Release

[Aurora](https://aurora.dev/), an Ethereum scaling solution that allows projects built on Ethereum to utilize the cutting-edge technology of NEAR has teamed up with [Etherscan](https://etherscan.io/), the leading block explorer for Ethereum, to allow developers to use the same familiar tool. 

While Aurora utilises NEAR as its foundation, it has always envisioned a future in which projects can move seamlessly between blockchains to suit their needs. The partnership with Etherscan is a significant step in that direction. 

“Etherscan provides the familiar interface of the explorer,” says Alex Shevchenko, the CEO of Aurora Labs. “Users and devs won’t need to educate themselves on how to use the Aurora block explorer, instead they would get the familiar tool.”

While Etherscan is most commonly known as a block explorer for Ethereum, it’s capable of so much more: from statistics, and token transfers and listing; to smart contract source code verification and ability to issue read and write calls directly from the UI. Making those tools available to a greater number of devs is key to Aurora’s mission. 

“Aurora is always focused on making the experience of devs and users as seamless as possible,” says Shevchenko. 

The explosive growth of DeFi and NFTs frequently causes surges in Ethereum gas prices––a problem that economically limits the participation of many users, and prevents dApp developers from scaling their businesses to their full potential. Helping developers to grow their business is a mission Etherscan shares with Aurora. 

> “We are happy to utilize our experience in building block explorer solutions into supporting Aurora, and extend our own vision of providing equitable access to blockchain data”, says Matthew Tan, Founder & CEO of Etherscan.

While today marks the start of the integration process, the product will be available later in the year. Stay tuned for updates on the release and other upcoming ones from the Aurora team.

Aurora has teamed up with Etherscan, the leading block explorer for Ethereum to allow developers to use the same familiar tool.

Etherscan will Launch on Aurora

Blockchain is among the most popular of all new technologies, and frequently referred to as Web 3.0. As new participants discover, however, it’s terribly complicated, with technical challenges every step of the way. A world of Googles and Facebooks brought wide adoption to Web 2.0. The clear opportunity now, is bridging the innovative world of Web 3.0, with the convenience and familiarity of Web 2.0.

Today we're excited to unveil that bridge, with Aurora+!

## What is Aurora+?

Aurora+ is an exciting new membership program for users of Aurora, that provides a suite of incredible benefits. Available today, all Aurora users can sign up for a free Basic account, including:

1. 50 free transactions per month. One of the biggest user experience hurdles throughout all of crypto, is understanding and dealing with transaction fees. Aurora+ eliminates this problem, setting the blockchain free!
2. AURORA Staking. Aurora+ members who stake AURORA tokens will enjoy not only a continuous stream of AURORA rewards, but also steams of rewards from the best projects throughout the Aurora ecosystem!
3. AURORA Airdrop. To ensure that all Aurora+ members experience the benefits of Aurora Staking, everyone who creates an account on Aurora+ during the first week of launch will be presented with an opportunity to claim and stake an Aurora Airdrop!

Those are the benefits available today. In the future, Aurora will continue to evolve the Aurora+ platform with foreseen features like:

1. Paid Premium Plans. Perhaps you need more than 50 transactions per months. Perhaps you're a trader and need your transactions prioritized. Just as with mobile phone service, Aurora+ Premium plans will allow users to access the features and services that exactly fit their needs.
2. Governance participation. Aurora+ members who stake AURORA will be eligible to participate in the governance of the Aurora protocol, through participation in the AuroraDAO.
3. Private transactions. Given the technical underpinnings between Aurora and the NEAR protocol, Aurora+ will roll out a solution to the Ethereum Dark Forest problems related to transaction analysis and front-running.
4. Single-point KYC. Aurora+ will offer optional KYC from within the user’s dashboard, recording the results to the blockchain, making them available to any dApps in the Aurora ecosystem that require KYCs.

## Aurobots — An exclusive NFT collection

In the famous words of Steve Jobs, we're excited to announce — one more thing!

To celebrate the launch of Aurora+, Aurora is giving away NFTs from an amazing new collection called "Aurobots", from renowned NFT creator, Mr. Brown.

111 unique Aurobot NFTs will be randomly distributed to lucky winners, in multiple lotteries corresponding to platform milestones during the first few weeks of launch. And in addition to owning a fantastic NFT, Aurobots holders will also benefit from a 10X boost of their monthly free transactions!

## Get started today!

Create your own free Aurora+ today, and begin experiencing the benefits of Web 3.0 with the convenience of Web 2.0 at: https://aurora.plus .


Aurora announces Aurora+, an exciting new platform providing Aurora users with free transactions, staking of AURORA tokens, airdrops and more.

Aurora+ sets the blockchain free!

Ethereum’s leading stableswap platform, Curve Finance, has integrated NEAR Protocol’s EVM layer, Aurora. Users can now connect to the Aurora network on their Ethereum wallets (such as Metamask) when using Curve, and enjoy the dapp’s deep liquidity pools without the high gas fees or wait time.

Aurora has witnessed the quickest growth in the recent month, crossing the $1.3b mark in TVL and reaching the Top 11 networks on DeFi Llama. At the time of writing, the Aurora ecosystem has more than 100 projects and 100 relayer nodes, with one of the most secure and innovative bridges in the industry operating between Ethereum, Aurora, and NEAR native.

The integration of Curve on Aurora comes at a critical time, with the burgeoning of bluechip DeFi protocols on Aurora, such as Aurigami, Bastion and Trisolaris, on one hand; and the deployment of market-leading bridge solutions, such as Multichain, Synapse, and Wormhole, on the other. Curve’s industry standard stableswap function will add a layer of DeFi composability and liquidity to the Aurora DeFi ecosystem, and at the same time, better position Aurora in an increasingly multi-chain world, allowing it to connect with other ecosystems via the transfer and exchange of pegged assets in its stablecoin, $wBTC, and $wETH pools.

In light of this integration, NEAR’s DeFi hub, Proximity Labs, will allocate up to $7.5M in grants to Curve to help establish their presence in the Aurora ecosystem. The synergy between Curve and Aurora will further accelerate the growth Aurora has enjoyed since the beginning of this year.

Ethereum’s leading stableswap platform, Curve Finance, has integrated NEAR Protocol’s EVM layer, Aurora.

Curve Finance Integrates the Aurora Network


## Aurora Provides an Ethereum Layer-2 Experience

The explosive growth of DeFi and NFTs frequently causes surges in Ethereum gas prices––a problem that economically limits the participation of many users, and prevents dApp developers from scaling their businesses to their full potential. To address these challenges, we’re proud to announce the mainnet release of Aurora, a turnkey solution for developers seeking to extend their dApps to reach additional markets.

![Aurora](https://awesome-near.s3.amazonaws.com/articles/aurora_fb.jpg "Aurora")

Aurora runs on [NEAR Protocol](https://near.org/) and takes advantage of its many unique features, including sharding and developer gas fee remuneration. Aurora consists of two core components: the **Aurora** Engine runtime, which allows for the seamless deployment of Solidity and Vyper smart contracts, and the **Aurora Bridge** (based on the [Rainbow Bridge](https://near.org/bridge) technology), providing for the permissionless transfer of tokens and data between Ethereum and Aurora. 

Aurora provides a number of enhancements for developers:

1. Aurora fees are up to 1,000x lower than Ethereum’s. For example, the cost of transferring a ERC-20 token is below $0.01, while for Ethereum (at 50 Gwei and an ETH price of $3,000), it’s around $5.40.
2. Aurora is able to host thousands of transactions per second, representing an increase of 50x compared to Ethereum 1.0. 
3. Aurora transaction finality inherits from the underlying NEAR Protocol, i.e. two NEAR blocks, or approximately two seconds—substantially lower even than a single block confirmation time of 13 seconds in Ethereum (which is not enough for transaction finality). Also, fast finality of NEAR blockchain reduces significantly the risk of frontrunning attacks.
Ecosystem growth on Aurora is future-proof: the sharding approach of the underlying NEAR Protocol provides for horizontal EVM scaling, with asynchronous communication between multiple Aurora shards.
4. Aurora offers a greener option for Ethereum users: full, uncompromising Ethereum compatibility on top of the decentralised and climate-neutral Proof-of-Stake L1 NEAR Protocol.
5. Aurora solves the current and future computational challenges of the Ethereum ecosystem, while preserving the existing engineering investment in both smart contracts and front-end code.

Aurora launches on NEAR Protocol, providing an Ethereum L2 experience. Aurora complements Ethereum & provides lower gas fees and faster transactions.

Aurora launches on NEAR Protocol

Aurora is an EVM built on the NEAR Protocol, delivering a turn-key solution for developers to operate their apps on an Ethereum-compatible, high-throughput, scalable and future-safe platform, with low transaction costs for their users. Aurora’s main features include:

- Fully compatible EVM for fast deployment of Solidity smart contracts;
- Horizontal scaling possibility thanks to NEAR Protocol’s dynamic resharding;
- High throughput (x10 increase in transaction throughput comparing to Ethereum);
- Fast confirmations (Transaction execution takes only 1-2 seconds in Aurora);
- x1000 reduction in gas costs;
- Trustless bridge architecture between Ethereum and Aurora / NEAR.

AwesomeNEAR

Aurora (AURORA)

Bridge + EVM Scaling Solution for Ethereum.

Aurora official and social links

Aurora Twitter

Aurora GitHub, Open Source, Source Code

About Aurora

What is Aurora? What is AURORA? Where can I get Aurora AURORA tokens? Who invested Aurora? How does Aurora compare to other projects?

Aurora Token Stats

Aurora Token Symbol is AURORAAurora AURORA Price

Aurora AURORA Price All Time High / All Time LowPrice ATH / ATL ⓘ

Aurora AURORAMarket Cap

Aurora AURORAMarket Cap Rank

Aurora AURORA24H Volume

Aurora AURORA Total Value LockedTVL ⓘ

Aurora AURORA Fully Diluted ValuationFDV ⓘ

Aurora AURORACirculating Supply

Aurora AURORATotal Supply

AURORA Token Address

AURORA Token Contract Address. How to find AURORA Token Address

NEAR Chain

Aurora Chain

Aurora News

Aurora funding, strategic partnership news, tutorials articles

Aurora Twitter