ETHS in the eyes of technologists: the essence is financial speculation rather than product innovation

Author: Wuyue, Geek Web3

Introduction: The current ETH inscription is still an old wine in a new bottle from Ordinals, and there is no real new paradigm. ETHS still has security risks, and while it is true that it is more decentralized than Rollup, its withdrawal process still relies on third-party notaries/administrators, and there is a risk of theft. Obviously, ETHS is still mostly based on financial speculation, not that it can bring innovation that ETH Layer 2 can’t bring. **

Recently BTC popularity of ecological inscriptions has driven developers of other chains to build similar systems. Inscription systems on different chains are slightly different in how they are implemented and what can be achieved, but there are some commonalities:

1. The inscriptions use the text information attached to the transfer to express the operation you want to complete, for example, write “transfer 1 coin to XXX” in the message. Note that this information is plain text and will not involve operations such as on-chain smart contract execution.
2. The developer will design a set of specifications and standards to normalize all text information.
3. The developer provides a set of Indexer indexer, which is used to collect the text information of all inscriptions on the chain and calculate the state of the inscription system. Indexer is an off-chain open-source component that anyone can run.

BTC inscription Ordinals has established a mechanism for issuing NFTs and tokens on the BTC, and has also led to large-scale thinking about BTC L2, in this sense, we can consider Ordinals to have a certain cutting-edge and exploratory nature. However, Ordinals was limited by the architecture of the BTC itself in terms of technology and product experience, and was also criticized by BTC community OG because of dust pollution and data occupation.

After all, the ETH ETH itself has complex smart contracts, and ERC20 and NFT are also the contents of the ETH workshop, and what impact will these inscription projects have on the ecology of the ETH, and will there be controversies and turmoil on the BTC?

Technical implementation of Ethions

Let’s take a look at the implementation of Ethions, which is a well-known inscription project in ETH workshop that mainly uses Calldata to operate.

**Calldata is the original input data transmitted in ETH transactions. **It is generally used to transmit parameters required for smart contract interaction, but can also be used to send text messages to EOA addresses (messages, inscriptions, transfer notes, etc.). In the figure, Input Data is calldata.

If you want to use Ethions to engrave “Hello world” in a transaction, you need to build a transaction that contains the following calldata:

When the off-chain Indexer hears the transaction, it updates the database and notifies the user that a new inscription has been generated, which reads Hello world. The inscription can also contain more complex content, such as base64, which represents image information.

Ethions has currently adopted 6 ESIPs (Proposals for improvement to the Ethions protocol), similar to EIP proposals, to define the use of inscriptions in different scenarios. However, these are only basic inscription specifications, such as the format of inscription transactions initiated from EOA, contract emit events, and so on.

Since Ethions is a project on ETH, it can also use the smart contract of ETH Fang to achieve a certain degree of logic. It is important to note that interacting directly with smart contracts is not the recommended way for Ethions.

Although the official NFT marketplace, etc., is also directly implemented with smart contracts. According to the official documentation, what Ethions wants to provide users with is a “decentralized and affordable computing service”: stripping computing off-chain will significantly reduce the cost of using ETH. **

Let’s take a closer look at the cost of invoking a smart contract, which can be divided into three parts:

Base Transaction Cost: Any ETH transaction is payable and is currently 21000 gas.

• • Data transfer cost (calldata) :* * calldata is generally used to submit data and parameters that interact with smart contracts. After EIP-2028 is adjusted, calldata consumes 16 gas per byte (4 gas for bytes with 0 data). Contract execution cost: If the transaction calls a function in the smart contract, then there is also a computational cost depending on the complexity of the function execution. For example, if a state update is involved (such as updating balance information in an ERC-20 contract), calling SSTORE will consume up to 5,000~20,000 gas.

Let’s take a very simple USDT transfer transaction as an example, which consumed a total of 63197 gas and the calldata is:

Let’s parse the calldata and how much gas it will cost:**

• ETH calldata is in hexadecimal format, i.e. one byte per two digits (16^2 = 2^8). A 0x at the beginning of the day indicates that the data is in hexadecimal format.
• The a9059cbb after the 0x at the beginning is a function selector and occupies 4 non-zero bytes.
• The next 32 bytes are the address, preceded by 12 bytes of zeros (because the ETH address is 20 bytes, here the left is filled with zeros to 32 bytes), and 20 bytes of non-zero address data.
• The last 32 bytes represent the amount, with a large number of zeros on the left, 3b9aca00 non-zero data at the end, and 4 bytes non-zero.
• So, 28 non-zero bytes and 40 zero bytes

Therefore, calldataGas = 28 *16 + 40 *4 = 608 gas.

The total gas is 63197, minus the calldata cost and fixed cost, and the smart contract computational cost to execute the transaction is 41589 gas. **The cost of contract computation accounts for the majority of this transaction, and this is only a simple transaction, and the cost of contract computation will increase further in complex transactions. **

Putting the computation process off-chain does significantly reduce the cost of use: if you don’t want to call the smart contract directly on-chain, you can send a predetermined EOA address

0x00000000000000000000000000000000000face7 send transaction data

In the calldata of the transaction, declare which contract you originally wanted to call, and the corresponding input parameters. Since the above address is an EOA account and does not have a contract code, the aforementioned operation will not trigger the computation task on the chain, ** just publish a message. **

Off-chain, after the Indexer listens to this message, it will parse it to figure out which contract on the chain the originator of the message originally wanted to call ETH and then the Indexer will calculate the result of the contract call off-chain.

If the offline Indexer wants to perform inscription and smart contract operations, it must have a set of STF (State Transition Function) rules and runtime, and the complex one can be called a virtual machine VM. Ethions launched its own VM in ESIP-4, the Ethions VM, which was later renamed Facet VM.

Facet - Kind of like a coprocessor

Facet defines itself as a cheap, easy-to-use, secure, and decentralized computing platform. **Listen to the calldata of Ethions on the ETH workshop, pull it to the VM for calculation, and finally return the result to the user. **Facet consists of several key components:

• Facet VM, a set of VMs written in ruby, is responsible for listening to ETHS transactions, parsing calldata, and executing operations.
• Rubidity, the smart contract programming language in Facet, has a certain similarity with Ruby, but retains a lot of solidity usage and concepts, in the hope that developers can quickly get started.
• Dumb Contract, a type of contract that runs on Facet. The name is full of humor. Some people are right to call it a dumb contract, dumb itself is a pun, dumb can describe the silent process of this kind of contract working. But on the other hand, according to the official saying “So dumb, they’re smart”, there is a strong sense of calling smart contracts, so it’s no problem to call stupid contracts.

The stupid contract itself will not actually be deployed on the ETH, but its code will be published to the ETH chain in the form of calldata. Here’s an example of a facet calling a stupid contract:

A minting transaction to an EOA black hole address

0x00000000000000000000000000000000000face7 submit the calldata in the figure below to declare the tokens and amount you want to mint, which is actually the same as Ordinals or BRC-20:**

Let’s take a look at the visual comparison between Rubidity and Solidity, as shown in the image below.

Although it is officially said that Rubidity has a concept and structure similar to Solidity, so that developers can get started quickly. But we know that this has a negative impact on the development of the developer side. And at present, Facet VM only supports stupid contracts in the official whitelist, which shows that the official does not have full confidence in this set of languages and VMs. I don’t know if reusing EVM is officially more engineering difficult than developing a new VM and a new language. But one thing is certain: a new language, a new contract, a new ecology, and a new way to use the ETH, there are indeed enough gimmicks.

Facet’s bashing of smart contracts

The Facet documentation has the following powerful comment on ETH and smart contracts: "Smart Contracts are considered to be the feature above all others that makes Ethereum special, and yet Facet’s thesis is that Smart Contracts are Ethereum’s biggest design flaw.”

They believe that ETH Fang’s smart contract is the biggest design flaw, because the contract itself is deterministic as long as the input (calldata) is given, so it should not be calculated on-chain and waste money for no reason. Combined with what Ethions calls “decentralized and affordable computing services”, it is clear that Ethions and Facet are keen to create a market impression that “we are creating a new ETH scaling paradigm and way of using it”, but in fact, some of ETHS’s own technical solutions are not very reliable.

From a product point of view, Facet can indirectly call smart contracts off-chain, and has its own off-chain stupid contract system, which is indeed officially practicing its slogan.

But from an economic point of view, there is no such thing as a free lunch, and storage and computing certainly cost money. So how does Indexer solve this part of the cost?**There is no clear explanation in this official, we can imagine:

• Charges to users. For example, the NFT marketplace charges buyers a fee, but we can’t look at the long-term charging method of an L2-like network with a simple project fee model.
• Get rich by relying on your own ecological hype. This is certainly feasible, but it is only a short-term solution that makes the project party feel good for a while. If Ethions is to become a new paradigm of ETH, Indexer must have a long-term, network-based economic mechanism to ensure its operation.
• If it’s a non-profit public good, then what kind of organizations will donate? I don’t think the ETH Foundation will be particularly active, because the ETH Foundation itself has a very good plan - Rollup.

The root cause of the emergence of facets and stupid contracts

If we just need a simple form of ETH Fang inscription, then only one item of Ethions is enough. So why did its ESIP-4 proposal give rise to Facet?

Because the inscription system cannot be used for complex transaction logic. We can examine the operating logic of Ethions’ official NFT marketplace contract, which uses a pending order mechanism.

If you want to deposit the inscription NFT into the contract, you only need to write the calldata as the EthionId of the inscription and call the marketplace contract. Since this operation deliberately chooses an invalid form of function call, fallback() will be triggered by default.

Eventually, an event called PotentialEthionDeposited will be thrown on the ETH Place, and the Indexer node will transfer the ownership of the NFT to the marketplace contract locally after hearing the event off-chain.

In order to save gas, the ETHS trading market does not store some parameters of sellers’ pending orders, such as price and expiration time, in the ETH contract, but puts them offline in the form of messages, which should be stored on the dApp server. Once the buyer has monitored the message, they can issue a buyWithSignature() command to make a purchase.

It is normal for NFTs to use the maker order mechanism, because NFTs themselves are not homogeneous. So if it’s a homogenized token inscription, can you use the AMM mechanism of the contract? The answer is no. The status of the inscription NFT or token is not on L1, which is similar to Ordinals and BRC-20. This is diametrically opposed to the propaganda of some communities, and everyone needs to pay attention to the fact that the inscription is not a real ETH asset on the chain. We can’t say that the calldata that generates the asset is on L1, and you can declare the operation instruction on L1, which is called the native asset on L1, otherwise we can also call the L2 native asset on the Rollup L1 asset, because the calldata of the Rollup is on L1. Obviously, it’s ridiculous to call this an asset an L1 native asset.

In fact, this contract is only responsible for collecting money, transferring money, and throwing events for the Indexer node in the chain to listen to and trigger the corresponding operation. In the eyes of the ETH EVM, the state of something like an inscription cannot be restored in the “World State”, a database dedicated to storing state in ETH, and the contract cannot refer to it.

Regardless of the form of the asset, whether it is a token or an NFT or anything bizarre, I can give a very simple criterion for distinguishing an L1 asset from an L2 asset: whether its state can be restored on the “world state” of the ETH, whether the L1 EVM can reference, call, query, modify the state of the asset, and if not, then it is not an L1 asset.

So you can also see that the name of the deposit event is PotentialEthionDeposit, which is “possible inscription deposit”, rather than a deterministic deposit, because the contract cannot determine whether this inscription exists and cannot verify its authenticity. If you place an order for a non-existent inscription, or someone else’s inscription, the contract will not reject you, but the Indexer will not include your behavior.

Therefore, the inscription system can only implement this simple pseudo-contract logic, and pending orders are one of them. **The essence of a pending order is that the two parties to the transaction agree with each other to provide the information provided by each other under a rule, in fact, it can be expressed in plain text without a smart contract, which is similar to the principle of the inscription.

We can imagine how the above process can be done without the use of smart contracts: the seller engraves a message in an ordinary transaction, and the person who transfers me 1 ETH with the postscript 123 can get my inscription NFT with the number 123. In this way, the Indexer only needs to support this logic, and it can directly transfer it to the off-chain Indexer database if it hears that someone has transferred 1 ETH to the seller with a postscript BCH.

Of course, this example will actually bring some problems, such as repeated transactions that may result from multiple people snapping up an NFT, etc., the seller receives multiple transfers, but in the end the NFT can only be assigned to one person by the Indexer. This should also be one of the reasons why the official clearly criticizes smart contracts, but uses contracts to realize the NFT market, so you should also be able to understand that the official statement that calling smart contracts through Facet without computation is unreliable propaganda.

Of course, pending orders can theoretically use plain text, instead of having to use contracts, but the relatively complex logic of AMM must use smart contracts, because it requires not the p2p agreement of both parties, but the contract agreement. The contract that acts as a reliable reviewer needs to check the basic information such as balance and liquidity, and perform calculations, and any asset data he needs must be available to the contract.

AMMs are just a relatively simple form of DeFi, and any other complex logic cannot be implemented on Ethions alone. That’s why Facet was launched - the first priority of Facet is cross-domain! it’s actually an L2, but it doesn’t have a block structure, so we don’t call it cross-chain, it’s cross-domain. When all L1 assets are cross-domain to Facet, there is no problem that cross-domain cannot be called, and all off-chain assets can be operated with stupid contracts to support complex contract logic.

vs. Rollup

From the above tirade, you should be able to see that Ethions’ scheme is somewhat similar to Rollup. But this is only “similar”, if strictly speaking, it can only implement a subset of the core functionality of Rollup. And the crippled functionality is fatal to its narrative, or puts the user at serious risk.

Rollups are complex systems, and we won’t expand on them here. It has a few things in common with Ethions:

• Submit the calldata of L2 transactions on ETH Square.

• All operations are handled off-chain.

The commonalities are very clear, and we need to elaborate on the differences.

Rollup Bulk Submit Calldata

In most cases, users in the rollup do not submit transactions directly to L1, but submit them to the off-chain sequencer, which sorts all transactions, packages and compresses them, and sends calldata to L1 in batches. In this way, the calldata of multiple users is submitted in a single transaction, which can dilute the base cost of 21,000 gas.

There is no such mechanism in Ethions, where all users submit calldata directly to L1.

Let’s use the USDT example above (608 gas for calldata), assuming that 100 users initiate 100 transactions, and calculate the cost difference between the two very loosely:

• Inscription users are required to pay 21608 gas (608 + 21000) per person. The rest of the computation is not paid because the computation is off-chain.
• Rollup users pay 818 gas per person ((608*100+21000)/100). The arithmetic part is the same as above.

Of course, each rollup user also needs to pay L2 computing and storage fees to the sequencer, but it is much cheaper than L1 and is negligible in this case. In addition, the rollup also needs some additional special fields to increase the volume, but at the same time there is better data compression, which we will not expand here.

Through this rough estimate, it can be found that Ethions does not have any advantage over Layer 2 in terms of cost. In addition, in the community propaganda of the project, I have seen something like “4000 inscriptions can be transferred in batches, about 0.11ETH, and the average transfer only needs 0.05U” to prove that the use of Ethions is very cheap, which actually does not clarify the principle and interaction details of ETHS.

Off-chain pre-confirmation

Thanks to the off-chain sequencer, user requests for rollups can be pre-confirmed within 1s. This is much better than the inscription system’s 12 seconds or more on L1, UX. Of course, proponents of the inscription can also argue that the finality of such a transaction is unreliable until the calldata is submitted to the ETH chain.

Censorship Resistance & Decentralization

Users in Rollups may be censored by off-chain sequencers, while Ethions cannot censor users. However, a well-designed rollup will have a forced aggregation function to counter the censorship of the sequencer, and ultimately the sequencer will not have the power to censor the user at all.

Therefore, when users use Rollup, they can also bypass the sequencer directly on L1. Rollups give users different options, either by using a faster sequencer or by using L1 directly. But Ethions can only use L1 and doesn’t give users the freedom to choose.

In addition, Ethions criticized Rollup’s sequencer as centralized. But the Indexer itself is also a highly centralized component. Ethions explained that Indexer is not centralized because it can be run and verified by anyone, but in fact the vast majority of people don’t run their own nodes. Therefore, ETHS is only in extreme cases, it will show its decentralized side than Rollup, after all, the Rollup sequencer may be down or malfunctioning, but ETHS can continue to operate as long as there are community members running multiple Indexers. **

Profit Model

It is impossible for any project to generate electricity with love, and long-term development projects must seriously consider the issue of profit model, whether it is a combination of centralized entities or decentralized entities, they must be profitable to be able to protect the network security for a long time.

Rollup’s sequencer has a clear profit model: overcharging gas, squeezing MEV, etc. The sequencer has the power to keep the network running. Since Ethions submits calldata directly to L1, Indexer is not easy to charge.

Developer Friendliness

Most of the contract development languages and toolchains of Rollup can be directly used by ETH, and developers can seamlessly migrate to Rollup. None of these are present in Ethions, new Rubidity needs to be mastered, new scans need to be built, new VMs need to be familiarized, and so on. Of course, these resistances, in turn, are also a pioneering opportunity that may be brought about by the development of a new ecology.

Withdrawal & Status Settlement

This is Facet’s fatal problem. We know that Rollup will not only submit calldata (input) to L1 in batches, but also submit the state settlement (output) after N operations to L1 at regular intervals. ZKR and OPR have different proofs to determine whether the relationship between input and output is correct, and regardless of the proof method, the final judgment is the contract on L1. The output and input on the Rollup are traceable and cannot be faked.

So what is the use of status settlement? It is used for withdrawals, i.e. the withdrawal of funds from L2 to L1. When the status on L1 is published, we can use Merkle Proof and other means to prove that my withdrawal request on L2 is included in the state root. Once the contract is verified, the asset can be released on L1.

**Facet does not have a state settlement mechanism, so he cannot achieve permissionless, decentralized withdrawals from L2 to L1. **As mentioned above, he needs an L2 layer in turn to execute more complex contract logic. Such as his AMM Swap FacetSwap.

We can see that in FacetSwap (a dex built with stupid contracts on Facet), there are clearly two actions: deposit and withdrawal. Generally, Swap does not have deposits and withdrawals, because Facet requires you to cross borders before you can use it.

In Facet, the deposit needs to lock the L1 funds on the L1 bridge contract, and emit the corresponding event ethions_protocol_CreateEthion for the Indexer to index. This is consistent with other L2 top-up methods.

**Withdrawals, on the other hand, have serious security concerns. **Since there is no status settlement mechanism on Facet, it is not possible to use contracts to automatically determine whether a withdrawal is valid or not on L2 to L1. So what method does Facet use? Administrator Release, or Witness Mechanism, similar to the previously stolen Axie Bridge.

Let’s take a look directly at Facet’s bridge, at the address

0xD729345aA12c5Af2121D96f87B673987f354496B。

The hashedMessage is a message signed by the signer, which contains some content that is withdrawn. A signer is a preset admin address. Because there is no state settlement, there is no way to do any verification, such as whether the account has so many coins on L2. Therefore, all the funds on the contract can be withdrawn with the signer signature, whether the project party is evil or hacker attacks to obtain the private key. **

In Rollup, there is no need for witnesses to release assets, and in the sidechain, if witnesses want to be more decentralized, they can choose a part of their own consensus system as a proxy, and use staking and other methods to carry out a certain economic deterrence to curb evil.

In Ethions and Facet, nothing. It’s simply, unabashedly an admin address. This is probably too sloppy for an L2-like project that often shouts that “smart contracts are a design flaw”, “Rollup is centralized”, and “we are a next-generation computing platform”. Obviously, there are many more flaws in him, but we can keep a wait-and-see view of them, although they are not easy to compensate for and may be present in BTC Layer 2 as well. **

Summary

There is a certain amount of “false propaganda” in the current Ethions, a few main points:

• Assets on Ethions and Facet are not assets issued on L1.
• In order to have complex contract capabilities, the L2 entity of Facet has evolved, but it has great financial security risks.
• The official claim to be based on the contract on L1 is not even used for its own top application.
• Ethions is similar to a very incomplete Rollup. Neither the cheapness and speed of a Rollup, nor the security of a Rollup. What he can achieve, Rollup can do, and Rollup can achieve very important functions that it can’t provide.
• If he wants to solve the above problem, he needs to develop a state settlement mechanism, plus a sequencer, L2 block, then it will eventually become a rollup.

Taking advantage of the BTC inscriptions, Ethions has relied on concepts to hype up old wine in new bottles, but has not yet discovered a new paradigm. At present, ETHS is still dominated by financial speculation, not that this product itself can bring things that ETH Layer 2 does not have. The long-term value of this kind of thing is obviously still to be explored,** but in its current form, ETHS has taken on the “unbearable weight of life”, and his propaganda slogan is far from its practical effect. **