Technical interpretation of Ethereum's inscription ETHS: Is it financial hype or not a product innovation?

INTRODUCTION

The current Ethereum inscription is essentially an old wine in a new bottle from Ordinals, a new paradigm with no real meaning. ETHS still has security risks, and although it is more decentralized than Rollup, its withdrawal process still relies on a third-party notary/manager, and there is a risk of theft. Obviously, currently ETHS is still mostly financial hype, not that it can bring about innovations that Ethereum Layer 2 cannot bring.

The recent popularity of BTC ecological inscriptions has encouraged developers of other chains to build similar systems. The way the inscription systems on different chains are implemented and the functions they can achieve are slightly different, but they have a few things in common:

1. The inscriptions all use text information attached to the transfer to express the operation you want to complete, such as writing “transfer 1 coin to XXX” in the message. Note that this information is in plain text and does not involve operations such as smart contract execution on the chain.

2. Developers will design a series of specifications and standards to standardize all text information.

3. The developer provides a set of Indexer indexers to calculate the internal state of the inscription system after collecting the text information of all inscriptions on the chain. Indexer is an off-chain open source component that anyone can run.

The BTC inscription Ordinals has established a mechanism for issuing NFTs and tokens on BTC, and has also led to large-scale thinking about BTC L2. In this sense, we can think that Ordinals is somewhat cutting-edge and exploratory. However, Ordinals was limited by BTC’s own architecture in terms of technology and product experience, and was also criticized by the BTC community OG for reasons such as dust pollution and data consumption.

So, does it make sense to reprint the inscription on Ethereum? After all, Ethereum itself has complex smart contracts, and ERC20 and NFTs are also part of Ethereum itself; what impact will these inscription projects have on the Ethereum ecosystem, and will they cause controversy and turmoil on BTC?

Ethical’s technical implementation

Let’s first take a look at how Ethical is implemented. It is a famous inscription project on Ethereum that mainly uses Calldata to operate.

Calldata is the original input data transmitted in an Ethereum transaction. It is generally used to transmit parameters required for smart contract interaction, but it can also be used to send text messages (comments, inscriptions, transfer notes, etc.) to an EOA address. In the figure, input data is calldata.

If you want to use Ethnography to inscribe “Hello world” in a transaction, you need to build a transaction with the following calldata:

After the off-chain Indexer monitors this transaction, it will update the database and notify the user that a new inscription has been generated, and the content of the inscription is Hello World. More complex content, such as base64 representing image information, can also be placed in the inscription.

Ethnicity has now passed 6 ESIPs (EIP-like proposals) to define the use of inscriptions in different scenarios. However, these are only relatively basic inscription specifications, such as the format of inscription transactions initiated from EOA, contract emit events, etc.

Since Ethnicity is a project on Ethereum, it is also possible to implement a certain degree of logic using Ethereum’s smart contracts. It’s important to note that directly interacting with smart contracts is not the recommended approach by Ethical.

Although official NFT marketplaces and the like are also directly implemented using smart contracts. According to the official documentation, Ethical wants to provide users with a “decentralized and affordable computing service”: splitting the computation off the chain will significantly reduce the cost of using Ethereum.

Let’s explore in detail the cost of calling a smart contract, which can be divided into three parts:

·Basic transaction costs: Any Ethereum transaction requires payment, currently 21000 gas.

·Data transmission cost (calldata): Calldata is generally used to submit data and parameters for interaction with smart contracts. After EIP-2028 adjustment, calldata generally consumes 16 gas per byte (4 gas if the data is 0 bytes).

·Contract execution cost: If a transaction calls a function in a smart contract, then depending on the complexity of the function execution, calculation costs must also be paid. For example, if a status update is involved (such as updating balance information in a ERC-20 contract), calling SSTORE can consume up to 5000-20,000 gas.

Let’s take a very simple USDT transfer transaction. The transaction cost a total of 63,197 gas, and the calldata is:

Let’s analyze this calldata and how much gas it will cost:

·Ethereum calldata is in hexadecimal format, that is, every two digits are one byte (16^2 = 2^8). The 0x at the beginning indicates that the data is in hexadecimal.

·The a9059cbb after the beginning 0x is a function selector and takes up 4 non-zero bytes.

·The next 32 bytes are addresses, with 12 bytes of zeros in front (since Ethereum addresses are 20 bytes, 0 to 32 bytes are added on the left), 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. After subtracting the calldata cost and fixed cost, the smart contract calculation cost for executing this transaction is 41,589 gas. Contract calculation costs account for the majority of this transaction, and this is just a simple transaction. In complex transactions, the cost of contract calculation will rise further.

Putting the computation process off-chain will indeed significantly reduce usage costs: if you don’t want to call smart contracts directly on the chain, you can go to an agreed EOA address

0x0000000000000000000000000000000face7 Send transaction data

In the transaction’s calldata, specify which contract you originally wanted to call, and the corresponding input parameters. Since the above address is an EOA account and there is no contract code, the operation described above will not trigger calculation tasks on the chain; it just posts a message.

Off-chain, after Indexer listens to this message, it will analyze it to find out which contract on the ETH chain the originator of this message originally wanted to call, then Indexer will calculate the contract call results off-chain.

Well, if an offline indexer wants to calculate inscriptions and smart contracts, it must have a set of STF (state transition function) rules and runtime. The complicated part can be called a virtual machine VM. Ethnic launched its own VM—Ethnic VM—in ESIP-4, which was later renamed Facet VM.

Facet — a bit like a coprocessor

Facet defines itself as a cheap, easy to use, secure, and decentralized computing platform. Listen to Ethical’s calldata on Ethereum, pull it to the VM for calculation, and finally return the results to the user. Facets have several key components:

·Facet VM, a set of VMs written in Ruby, is responsible for monitoring ETHS transactions, parsing calldata, and executing operations.

·Rubidity, the smart contract programming language in Facet, is similar to Ruby, and also retains many solidity uses and concepts, so developers can get started quickly.

·Dumb contract, a dumb contract, a type of contract that runs on Facet. The name is full of humour. Some people are also right to call it a dumb contract. Dumb itself is a pun; dumb can describe the silent process of this kind of contract work. But on the other hand, according to the official proverb “ So dumb, they’re smart,” it means being foolish, with a strong sense of arguing with smart contracts, so there’s no problem calling them stupid contracts.

The stupid contract itself won’t actually be deployed on Ethereum; its code will be posted to the ETH chain in the form of calldata. Here’s an example of Facet calling a stupid contract:

A minting transaction to an EOA black hole address

0x000000000000000000000000000face7 submits the calldata in the image below, stating that you only want the token and amount of mint. This is actually the same as Ordinals or BRC-20:

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

Although the official statement is that Rubidity has a Solidity-like concept and structure, so developers can get started quickly. But we know that this actually has a negative impact on the developers’ side’s development. Also, currently Facet VM only supports stupid contracts on the official whitelist, which shows that the government doesn’t have much confidence in this language and VM. Whether to reuse EVM is officially more difficult in engineering than developing a new VM and a new language, I don’t know. But one thing is certain: the new language, the new contract, the new ecosystem, and the new way to use Ethereum are really enough gimmicks.

Facet’s attack on smart contracts

The Facet documentation made the following strong comments on Ethereum 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 Ethereum’s smart contract is the biggest design flaw, because the contract itself only requires a given input (calldata), and its output is determined, so it should not be calculated on the chain, wasting money for no reason. Combined with Ethical’s “decentralized and affordable computing service,” it is clear that Ethnic and Facet really want to create a market impression, “We are creating a new Ethereum expansion paradigm and usage method,” but in reality, some of ETHS’s own technical solutions are not very reliable.

From a product perspective, Facet can invoke smart contracts indirectly under the chain, and it also has its own stupid contract system under the chain. Indeed, the government is carrying out its slogan.

However, from an economic point of view, there are no free lunches in the world; of course, storage and computing require money. So how does Indexer solve this part of the cost? There’s no official explanation for this, so let’s imagine:

· Users are charged. For example, the processing fee charged by the NFT market from buyers, but we can’t look at a simple project charging model as a long-term L2 network-like charging method.

·Become rich through your own ecological hype. This is of course possible, but it’s just a short-term solution to keep the project cool for a while. If Ethnicity is to become a new Ethereum paradigm, Indexer must have a long-term, network-based economic mechanism to guarantee operation.

·If public goods are not profitable, which organizations will donate? I think at least the Ethereum Foundation won’t be particularly active because Ethereum itself has a very good solution - Rollup.

The root cause of Facet and stupid contracts

If we just need the simple form of the Ethereum inscription, then just one project of Ethnic is enough. So why did its ESIP-4 proposal spawn Facet again?

Because the inscription system cannot be used for complex transaction logic. We can examine the operating logic of Ethical’s 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 ethscriptionID of the inscription and call the market contract. Since this operation deliberately selects an invalid form of function call, it triggers fallback () by default.

Eventually, an event called PotentialEthScriptionOfferings will be thrown on the Ethereum chain. After the Indexer node monitors this event off-chain, it will locally transfer the ownership of the NFT into a market contract.

In order to save gas, the ETHS trading market does not store some parameters of the seller’s pending orders, such as price, deadline, etc. in the ETH contract, but instead places them offline in the form of messages. Visually, they should have been stored on the dApp server. Once the buyer has monitored this message, they can submit a purchase by issuing the BuyWithSignature () command.

Using a pending order mechanism is normal for NFTs because NFTs themselves are not homogenous. So if it’s a homogenized token inscription, can the AMM mechanism of the contract be used? The answer is no. The status of the inscribed NFTs or tokens is not on L1, which is about the same as Ordinals and BRC-20. This is the complete opposite of some community propaganda. Everyone needs to be careful. The inscription is not an asset on the ETH chain in the true sense of the word. We can’t say that the calldata that generated the asset is on L1, and we can declare operation instructions on L1, called the native asset on L1. Otherwise, the L2 native asset on Rollup can also be called an L1 asset, because Rollup’s calldata is all on L1. Obviously, it’s ridiculous to call this kind of asset an L1 native asset.

You might be wondering, isn’t that just a smart contract is used to trade? Why is it said that the inscriptions on the contract cannot be read and manipulated? In fact, this contract is only responsible for collecting money, transferring money, and throwing events for the indexer nodes under the chain to listen and trigger corresponding operations. In the eyes of Ethereum EVM, the state of something like an inscription cannot be restored in the “World State” database that specifically stores the state of Ethereum, nor can contracts reference it.

No matter what form an asset is, a token, an NFT, or anything strange, I can give a very simple standard to identify L1 assets and L2 assets: can their state be restored to the “state of the world” of Ethereum, can L1’s EVM reference, call, query, and modify the state of the asset; if not, then it is not an L1 asset.

Therefore, you can also see that the name of the deposit event is PotentialEthscriptionDeposit, that is, “possible inscription recharge”, rather than a definitive recharge, because the contract cannot determine whether this inscription exists, and it is impossible to verify its authenticity. If you order an inscription that doesn’t exist, or someone else’s, the contract won’t reject you; it’s just that Indexer won’t include your actions.

Therefore, the inscription system can only implement this simple pseudo-contract logic; pending orders are one of them. The essence of a pending order is that both parties to the transaction agree with each other’s information under a rule. In fact, it can be expressed in plain text without a smart contract. This is similar to the principle of an inscription.

We can imagine how this process can be completed without using a smart contract: the seller engraves a message in a normal transaction, transfers me 1ETH, and someone who notes 123 can get an NFT with my inscription number 123. This only requires Indexer to support this logic. It listens that someone has transferred 1ETH to the seller and added an ABC, then it can be transferred directly to the off-chain Indexer database.

Of course, this example will actually cause some problems, such as repeated transactions that may result from multiple people snapping up an NFT. The seller has received multiple transfers, but in the end, the NFTs can only be transferred to one person by the Indexer. This should also be one of the reasons why the government clearly criticizes smart contracts but uses contracts to implement the NFT market, so you should also be able to understand the official statement that calling smart contracts without calculation through Facet is unreliable.

Of course, pending orders can theoretically use plain text rather than requiring a contract, but AMM’s relatively complex logic requires smart contracts, because it requires not a peer-to-peer agreement between the two parties, but contractual approval. A contract that acts as a reliable reviewer requires checking basic information such as balance and liquidity, and performing calculations. The contract must be able to obtain any asset data it needs.

AMM, on the other hand, is just a relatively simple form of DeFi, and any other complex logic cannot be implemented on Ethnic alone. That’s why Facet was launched — Facet’s number one priority is cross-domain! It’s actually an L2, but it doesn’t have a block structure, so we don’t call it cross-chain but cross-domain. When all L1 assets are cross-domain to Facet, there is no problem that they cannot be called across domains. All off-chain assets can be operated with stupid contracts under the chain, thereby supporting complex contract logic.

Comparison with Rollup

Through the lengthy discussion above, you should be able to see that Ethical’s solution is somewhat similar to Rollup. But that’s just “similar”; strictly speaking, it only implements a subset of Rollup’s core functionality. The missing functionality, on the other hand, caused fatal damage to its narrative, or put users at serious risk.

Rollup is a complicated system, and we’re not going to expand it here. It has something in common with Ethanol:

• They all submit data calldata for L2 transactions on Ethereum.

• All computations are processed off-chain.

The commonalities are very clear, and we need to demonstrate the differences in detail.

Rollup bulk submission of calldata

In most cases, users in Rollup do not submit transactions directly to L1, but rather submit them to an off-chain sequencer. The sequencer sorts all transactions, packages and compresses them, and sends the calldata to L1 in batches. By submitting calldata from multiple users in one transaction, the basic cost of 21,000 gas can be diluted.

There is no such mechanism in Ethnicity; all users submit calldata directly to L1.

Using the USDT example above (608 gas for calldata), let’s assume that 100 users have initiated 100 transactions, and roughly calculate the cost difference between the two with very little rigor:

· Each inscription user will pay 21608 gas (608 + 21000). The rest of the computation is not paid because the computation is off-chain.

·Rollup users pay 818 gas ((608*100+21000) /100) per person. The math part is the same as above.

Of course, every Rollup user also needs to pay L2 computation and storage fees to the sequencer, but it’s much cheaper than L1, so it’s negligible in this case. Also, rollup requires some additional special fields to increase the volume, but at the same time, it also has better data compression, so we won’t expand it here.

Through this rough estimate, it can be seen that Ethanol has no cost advantage over Layer 2. Also, in the project’s community propaganda, I’ve seen things like “4000 inscriptions can be transferred in batches, about 0.11 ETH, and on average, only 0.05U per transfer” to prove that the use of Ethanol is cheap. In fact, it doesn’t clarify the principles and interaction details of ETHS.

Off-chain pre-confirmation

Thanks to an off-chain sequencer, Rollup’s user requests can be pre-confirmed within 1s. This is a lot better UX than the inscription system for 12 seconds or more on L1. Of course, supporters of the inscription can also counter that until calldata is submitted to the ETH chain, the final results of such transactions are unreliable.

Censorship-resistant and decentralized

Users on Rollup are likely to be censored by off-chain sequencers, while Ethical cannot censor users. However, a well-designed Rollup will have a forced aggregation function to counter the review of the sequencer, and ultimately the sequencer has no power to review users at all.

Therefore, when users use Rollup, they can also directly bypass the sequencer on L1. Rollup gives users different choices. You can use a faster sequencer or use L1 directly. However, Ethnic can only use L1, and there is no room for users to choose freely.

Also, Ethnic criticized Rollup’s sequencer for being centralized. But Indexer itself is also a highly centralized component. Ethnic explained that since anyone can run and verify Indexer, it’s not centralized, but in fact, the vast majority of people don’t run nodes themselves. Therefore, ETHS only shows its decentralized side compared to Rollup in extreme cases. After all, the Rollup sequencer may go down or fail, but ETHS can continue to operate as long as community members run multiple Indexers.

Profit model

No project can use love to generate electricity. Long-term development projects must carefully consider the issue of profit models. Whether it is a centralized entity or a combination of decentralized entities, they must be profitable to protect network security for a long time.

Rollup’s sequencer has a clear profit model: charging more gas, extracting MEV, etc. The sequencer has power to ensure the normal operation of the network. Since users submit calldata directly to L1, Indexer doesn’t charge much.

Developer-friendliness

Most of Rollup’s contract development languages, tool chains, etc. can directly use Ethereum, and developers can seamlessly migrate to Rollup. None of these exist in Ethnic; you need to master new Rubidity, build new scans, get familiar with new VMs, etc. Of course, when viewed in reverse, this resistance is also an opportunity for exploration that may be brought about by the development of a new ecosystem.

Withdrawals and status settlement

This is Facet’s fatal problem. We know that Rollup not only submits calldata (input) to L1 in batches, but also regularly submits state settlement (output) after N operations to L1. ZKR and OPR have different methods of proof to determine whether the relationship between input and output is correct. Regardless of the method of proof, the final decision is an L1 contract. The output and input on Rollup are traceable and cannot be faked.

So what’s the use of status settlement? Used for withdrawals, that is, L2 to L1 fund withdrawals. 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 that status root based on the status root. Once the contract has been verified correctly, assets can be released on L1.

Facet has no status settlement mechanism, so it is impossible for him to achieve permissionless, decentralized withdrawals from L2 to L1. As mentioned above, he also needed an L2 layer to execute more complex contract logic. Like his AMM Swap FacetSwap.

We can see that FacetSwap (a dex built on Facet with stupid contracts) clearly has two actions: deposit and withdrawal. Normally, there are no deposits or withdrawals for Swap, because Facet requires you to cross domains before you can use it.

In Facet, the deposit requires locking L1’s funds on the L1 bridge contract, and emitting the corresponding event ethscriptions_protocol_createEthscription for indexer to be indexed. This is consistent with other L2 recharge methods.

Withdrawals, on the other hand, have serious security issues. Since there is no status settlement mechanism on Facet, contracts cannot be used to automatically determine whether a withdrawal is valid from L2 to L1. So what method did Facet use? The administrator released, or witness mechanism, similar to the previously stolen Axie Bridge.

Let’s take a look directly at Facet’s bridge. The address is:

0xd729345aa12c5af2121d96f87b673987f354496b.

HashedMessage is a message signed by the signer and contains some of the content of the withdrawal. signer is a default administrator address. Because there is no status settlement, no verification can be done, such as whether the account has this many coins on L2. Therefore, all funds in the contract can be taken away with the signer’s signature, whether it is the project party’s misconduct or a hacker attack to obtain the private key.

In Rollup, there is no need for witnesses to release assets at all; in sidechains, if witnesses want to do something decentralized, they can select part of their own consensus system as agents and use collateral to deter evil to a certain extent.

In Ethnic and Facet, nothing. It’s simply, undisguised, an administrator address. This is probably too crude for an L2 project that often shouts “smart contracts are design flaws,” “Rollup is centralized,” and “we are a next-generation computing platform.” Obviously, he still has many flaws, but we can keep watching, although these flaws aren’t easy to fix, and they probably exist in Bitcoin Layer 2 as well.

summed

Currently, there is some “false propaganda” in Ethnicity. Here are a few key points:

·Assets on Ethnic and Facet are not assets issued on L1.

·In order to have complex contract capabilities, Facet has evolved into an L2 entity, but it has huge financial security risks.

·The official claim is to remove contract computation on L1, but it doesn’t even use its own top app.

·Ethanol is similar to a Rollup with very poor basic functionality. Neither Rollup is cheap and quick, nor is Rollup safe. What he can achieve, Rollup can do, and it can’t provide the very important functions that Rollup can achieve.

·If he wants to solve the above problems, he needs to develop a status settlement mechanism, plus a sequencer and an L2 block, then it will eventually become a Rollup.

Ethnicity has taken advantage of the BTC inscription and relied on the concept to hype up old wine in new bottles, but it hasn’t discovered a new paradigm. Currently, ETHS is still mainly based on financial speculation, not that this product itself can bring something that Ethereum Layer 2 doesn’t have. The long-term value of this kind of thing has obviously yet to be discovered, but in its current form, ETHS has taken on the “unbearable burden of life,” and his slogan is far different from its practical effect.

Disclaimer：

1. This article is reprinted from [theblockbeats]. All copyrights belong to the original author [雾月，极客 Web3]. If there are objections to this reprint, please contact the Gate Learn team, and they will handle it promptly.
2. Liability Disclaimer: The views and opinions expressed in this article are solely those of the author and do not constitute any investment advice.
3. Translations of the article into other languages are done by the Gate Learn team. Unless mentioned, copying, distributing, or plagiarizing the translated articles is prohibited.