enu-kuro/research_on_aurora_evm.md

## research_on_aurora_evm.md

      
    Raw
  

              research_on_aurora_evm.md
            
          
    Concise explanation about Aurora Engine

Let’s start with a quick recap of what the 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 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.

https://aurora.dev/blog/aurora-engine-2-4-0-release
Near team tried introducing EVM runtime without any change in the current NEAR Protocol.

Aurora's EVM runtime is just a Near's smart contract.
Relayers wrap Ethereum transactions which Aurora users send into NEAR transactions so actualy all Aurora's transactions are also Near's transaciton.

Aurora users pay ETH(bridge from Ethereum) to relayers for EVM gas fee and relayers pay NEAR for Near's smart contract execution instead of Aurora users.
You can see Aurora smart contract's transactions on Near.

https://explorer.near.org/accounts/aurora
For normal Ethereum transaction, relayers call "submit" method in the Aurora smart contract.

https://github.com/aurora-is-near/aurora-engine/blob/7109e30926ea33f67c6f702aa2b796b025cca96a/engine/src/lib.rs#L244
Interesting Topics:


EVM Runtime base token

https://gov.near.org/t/evm-runtime-base-token/340

ETH or NEAR?


Storage staking price

https://gov.near.org/t/storage-staking-price/399/6

Storage staking cost for Aurora contract could be too expensive.


Aurora Cross Contract Calls

aurora-is-near/aurora-engine#461

Currently you can call contracts in Aurora from contracts in Near but not the opposite.


Questions:


Can you implement EVM written in Move?

And is it's computation cost acceptable level?

- Are there no scaling problem on Aptos?

Near has a sharding so even if Aurora were congested it won't affect other shared and theoretically create multiple EVM runtimes in other shard.

Can Aptos excute transactions sequentially?

Aptos seems to excute transactions in parallel but EVM needs sequential excution.