Technical Interpretation of Ethereum Inscription ETHS: The essence is financial speculation rather than product innovation

Written by: Wu Yue, Geek Web3

Introduction: The current Ethereum inscription is still Ordinals in a new bottle, with no real new paradigm. ETHS still existsSafetyRisk: Although it is more decentralized than Rollup, its withdrawal process still relies on third-party notaries/administrators.stealRisk. Obviously, ETHS is still mostly financial speculation, rather than bringing innovations that Ethereum Layer2 cannot bring.

The recent popularity of BTC ecological inscriptions has driven developers of other chains to build similar systems. The implementation methods and achievable functions of inscription systems on different chains are slightly different, but they have some common points:

1. The inscriptions all 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 in plain text and does not involve the intelligence on the chain.contractExecute and other operations.

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

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

BTC Ordinals has established a set of NFT issuance on BTC.TokenThe mechanism also led to the BTC L2 In this sense, we can think that Ordinals has a certain cutting-edge and exploratory nature. However, Ordinals is limited by the BTC architecture in terms of technology and product experience. It is also affected by BTC due to dust pollution and data occupation. Community OG's criticism.

So, does it make sense to replicate the inscription on Ethereum? After all, Ethereum itself has complex intelligence.contract, ERC20 and NFT are also existing content on Ethereum; what impact will these inscription projects have on the Ethereum ecosystem, and will there be controversies and turmoil on BTC?

Technical implementation of Ethscriptions

Let’s first take a look at the implementation of Ethscriptions, which is a famous inscription project on Ethereum that mainly uses Calldata to operate.

Calldata is the raw input data transmitted in an Ethereum transaction.Generally used to transmit intelligencecontractParameters required for interaction, but can also be used to send text messages to EOA addresses (leaves messages, inscriptions, transfer notes, etc.). In the figure, Input Data is calldata.

If you want to use Ethscriptions to engrave "Hello world" in a transaction, you need to construct a transaction with the following calldata:

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

Ethscriptions has currently passed 6 ESIPs (Proposals for improvement to the Ethscriptions protocol), similar to EIP 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, and so on.

Since Ethscriptions is a project on Ethereum, it can also use Ethereum's smart contracts to implement a certain degree of logic. It should be noted that directly interacting with smart contracts is not the recommended method for Ethscriptions.

Although the official NFT market is also directly implemented with smart contracts. According to the official document,What Ethscriptions wants to provide users is "decentralized and reasonably priced computing services": stripping computing off-chain will significantly reduce the cost of using Ethereum.

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

• Basic transaction costs: Any Ethereum transaction needs to pay, currently 21000 gas.

• Data transfer costs(calldata): calldata is generally used to submit data and parameters for interacting with smart contracts. After the EIP-2028 adjustment, each byte of calldata data generally consumes 16 gas (if the data is 0 bytes, it consumes 4 gas).

• Contract execution costs：If the transaction calls a function in a smart contract, then the computational cost will also need to be paid 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 5000~20000 gas.

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

Let's parse the 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 means that the data is in hexadecimal.

• The first 0x followed by a9059cbbIs the function selector, occupies 4 non-zero bytes.

• The next 32 bytes are the address, with 12 bytes of zeros in front (because the Ethereum address is 20 bytes, it is padded with zeros to 32 bytes), and 20 bytes of non-zero address data.

• The last 32 bytes represent the amount, padded with a lot of zeros on the left, and ending with3b9aca00Non-zero data, 4 bytes non-zero.

• So, there are 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, so the smart contract computation cost of executing this transaction is 41589 gas.The contract operation cost accounts for the majority of this transaction, and this is just a simple transaction. The cost of contract operation will increase further in complex transactions.

Putting the computation process off-chain does significantly reduce the cost of use: if you do not want to call the smart contract directly on the chain, you can send it to a pre-agreed EOA address.

0x00000000000000000000000000000000000face7Send transaction data

In the calldata of the transaction, declare which contract you want to call and the corresponding input parameters. Since the above address is an EOA account and has no contract code, the above operations will not trigger computing tasks on the chain.It was just a message posted.

Off-chain, after Indexer listens to this message, it will parse it to find out which contract on the ETH chain the sender of this message originally wanted to call, and then 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. The more complex ones can be called virtual machines VM. Ethscriptions launched its own VM in ESIP-4 - Ethscriptions VM, which was later renamed Facet VM.

Facet - a bit like a coprocessor

Facet defines itself as a cheap and easy-to-useSafety, a decentralized computing platform.Monitor the calldata of Ethscriptions on Ethereum, pull it into the VM for calculation, and finally return the result to the user.Facet consists of several key components:

• Facet VM, a VM written in ruby, is responsible for monitoring ETHS transactions, parsing calldata, and performing operations.

• Rubidity, the smart contract programming language in Facet, has some similarities with Ruby, but also retains many usages and concepts of solidity, so that developers can get started quickly.

• Dumb Contract is a contract that runs on Facet. The name is full of humor. Some people call it dumb contract, which is also correct. Dumb itself is a pun, and dumb can describe the silent process of the contract. But on the other hand, according to the official motto "So dumb, they're smart", it is a strong challenge to smart contract, so it is okay to call it dumb contract.

The dumb contract itself will not be actually deployed on Ethereum, but its code will be published to the ETH chain in the form of calldata.The following is an example of Facet calling the DaiBen contract:

A minting transaction to the EOA black hole address

0x00000000000000000000000000000000000face7Submit the calldata in the figure below and declare that you want to mintTokenand quantity,This is exactly the same as Ordinals or BRC-20:

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

Although the official said that Rubidity has similar concepts and structures to Solidity, so that developers can quickly get started. But we know that this actually has a certain negative impact on the development of the developer side. AndCurrently, Facet VM only supports the dumb contracts in the official whitelist, which shows that the official does not have full confidence in this language and VM.I don’t know whether reusing EVM is more difficult for the government in terms of engineering technology than developing a new VM and a new language. But one thing is certain: a new language, a new contract, a new ecosystem, and a new way of using Ethereum are indeed enough to attract attention.

Facet’s attack on smart contracts

The Facet document makes the following scathing comment about 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 contracts are the biggest design flaw, because as long as the input (calldata) of the contract itself is given, its output is certain, so it should not be calculated on the chain, wasting money for no reason. Combined with what Ethscriptions calls "decentralized and reasonably priced computing services",Obviously, Ethscriptions and Facet want to create a market impression that "we are creating a new Ethereum scaling paradigm and usage method", but in fact some of ETHS's own technical solutions are not very reliable.

From a product perspective, Facet can indirectly call smart contracts off-chain and has its own off-chain dumb contract system. Indeed, the official is practicing its slogan.

But from an economic perspective, there is no free lunch in the world, and storage and computing certainly cost money. So how does Indexer solve this cost?There is no official explanation for this, so we can imagine:

• Charge users. For example, NFT markets charge buyers a handling fee, but we cannot view a similar project as a simple charging model. L2 The long-term charging method of the network.

• Getting rich by hyping up its own ecosystem. This is certainly feasible, but it is only a short-term solution that makes the project party happy for a while. If Ethscriptions wants to become a new Ethereum paradigm, Indexer must have a long-term economic mechanism based on the network to ensure its operation.

• If it is unprofitable public goods, which organizations will donate? I think at least the Ethereum Foundation will not be particularly active, because Ethereum itself has a very good solution - Rollup.

The root cause of Facet and Dumb Contract

If we just need a simple form of Ethereum inscriptions, then only one project, Ethscriptions, is enough. Then why did its ESIP-4 proposal give birth to Facet?

Because the inscription system cannot be used for complex transaction logic. We can examine the operating logic of the official NFT market contract of Ethscriptions, which uses the order mechanism.

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

Eventually, a newPotentialEthscriptionDepositedAfter the Indexer node monitors this event off-chain, it will transfer the ownership of the NFT to the market contract locally.

In order to save gas, the ETHS trading market does not store some parameters of the seller's order, such as price, deadline, etc., in the ETH contract, but instead stores them offline in the form of messages. It is estimated that they are stored on the dApp server. After the buyer monitors this message, he can publishbuyWithSignature()Instructions to purchase.

It is normal for NFT to use the order mechanism, because NFT itself is not homogeneous.TokenCan Inscription use the AMM mechanism of the contract? The answer is no. The status of Inscription NFT or token is not on L1, just like Ordinals and BRC-20.This is completely contrary to the propaganda of some communities. Everyone needs to be careful to distinguish that inscriptions are not real assets on the ETH chain.我们并不能说生成资产的 calldata 在 L1 上，并且可以在 L1 上声明操作指令，就叫 L1 上的原生资产，否则 Rollup 上的 L2 原生资产我们也可以称为 L1 资产，因为 Rollup 的 calldata 都在 L1 上。Obviously, calling this an L1 native asset is ridiculous.

You may wonder, isn’t the above just a transaction using a smart contract? Why is it said that the contract cannot read and operate the inscription? In fact, this contract is only responsible for collecting money, transferring money, and throwing events for the Indexer node under the chain to listen and trigger corresponding operations.In the eyes of Ethereum EVM, the state of things like inscriptions cannot be restored in the "world state" database that specifically stores the state of Ethereum, and the contract cannot reference it.

No matter what form the asset takes, whether it’s a token, NFT, or anything weird,I can give a very simple standard to distinguish L1 assets from L2 assets: whether its state can be restored on the "world state" of Ethereum, whether the L1 EVM can reference, call, query, and modify the state of the asset. If not, then it is not an L1 asset.

So you can also see that the name of the recharge event isPotentialEthscriptionDeposit, that is, "possible inscription recharge" rather than a deterministic recharge, because the contract cannot determine whether the 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 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 placing an order is that both parties to the transaction mutually agree on the information provided by the other party under a certain rule. In fact, it can be expressed in plain text without using a smart contract, which is similar to the principle of inscriptions.

We can imagine how to complete the above process without using smart contracts: the seller engraves a message in a normal transaction, and the person who transfers 1ETH to me with the message 123 can get my inscription NFT numbered 123. In this way, only Indexer needs to support this logic. If it monitors that someone has transferred 1ETH to the seller with the message ABC, it can directly transfer it in the Indexer database off-chain.

Of course, this example actually brings some problems, such as multiple people rushing to buy an NFT, which may lead to repeated transactions. The seller received 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 criticized smart contracts but used contracts to implement the NFT market. Therefore, you should also understand what the official said.Calling smart contracts through Facet without performing calculations is unreliable propaganda.

Of course, in theory, orders can be placed in plain text instead of contracts, but relatively complex logic such as AMM must use smart contracts because it does not require p2p-style recognition from both parties, but contract recognition. The contract, which acts as a reliable reviewer, needs to check basic information such as balance and liquidity, and perform calculations. Any asset data it needs must be available to the contract.

AMM is just a relatively simple form of DeFi, and any other complex logic cannot be implemented on Ethscriptions alone. This is why Facet was launched - Facet's first priority is cross-domain! It is actually an L2, but without a block structure, so we call it cross-domain instead of cross-chain. When all L1 assets are cross-domained to Facet, there will be no problem of cross-domain inability to call, and all off-chain assets can be operated with dumb contracts off-chain, thereby supporting complex contract logic.

Comparison with Rollup

Through the above long discussion, you should be able to find that the Ethscriptions solution is somewhat similar to Rollup. But this is only "similar". If we strictly speaking, it can only achieve the core functions of Rollup.SubsetThe incomplete functions bring fatal damage to its narrative, or put the users in serious threat.

Rollup is a complex system, which we will not expand on here. It has some similarities with Ethscriptions:

• Both submit L2 transaction data calldata on Ethereum.

• All operations are processed off-chain.

The similarities are very clear, and we need to discuss the differences in detail.

Rollup batch submit calldata

In most cases, users in Rollup do not submit transactions directly to L1, but submit them to the off-chain sorter, which will sort all transactions, package and compress them, and send the calldata in batches to L1. In this way, the calldata of multiple users are submitted in one transaction, which can dilute the basic cost of 21,000 gas.

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

Let’s use the USDT example above (608 gas for calldata) and assume that 100 users initiate 100 transactions. Let’s roughly calculate the cost difference between the two:

• Each inscription user needs to pay 21608 gas (608 + 21000). The remaining calculation part is not paid because the calculation is off-chain.

• Each Rollup user pays 818 gas ((608*100+21000)/100). The calculation part is the same as above.

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

Through this rough estimate, it can be found that Ethscriptions has no cost advantage over Layer2.CommunityIn the promotional language, I have seen something like "4000 inscriptions can be transferred in batches, which costs about 0.11ETH, and each transfer only costs 0.05U on average" to prove that the use of Ethscriptions is very cheap. In fact, this does not clarify the principles and interaction details of ETHS.

Off-chain pre-confirmation

Due to the off-chain sequencer, Rollup user requests can be pre-confirmed within 1 second. This is much better than the 12 seconds or longer inscription system on L1, and the UX is much better. Of course, inscription supporters can also refute that before the calldata is submitted to the ETH chain, the finality of such transaction results is unreliable.

Censorship resistance and decentralization

Users in Rollup may be censored by the off-chain sorter, while Ethscriptions cannot censor users. However, a well-designed Rollup will have a forced collection function to counter the sorter's censorship, ultimately making the sorter completely powerless to censor users.

Therefore, when users use Rollup, they can also bypass the sorter and use it directly on L1. Rollup gives users different choices, they can use a faster sorter or directly use L1. However, Ethscriptions can only use L1 and does not give users the freedom to choose.

In addition, Ethscriptions criticized the Rollup sequencer for being centralized. However, Indexer itself is also a highly centralized component. Ethscriptions explained that Indexer is not centralized because anyone can run and verify it, but in fact, most people will not run a node themselves.所以 ETHS 只是在极端情况下，会体现出它比 Rollup 去中心化的一面，毕竟 Rollup 排序器可能宕机或者故障，但 ETHS 只要有社区成员运行多个 Indexer，就可以持续运转。

Profit Model

No project can be powered by love. 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 in order to protect the network in the long run.Safety.

The sorter of Rollup has a clear profit model: charging more gas, squeezing MEV, etc. The sorter has an incentive to ensure the normal operation of the network. Ethscriptions Since users submit calldata directly to L1, it is difficult for Indexer to charge.

Developer Friendliness

Most of Rollup's contract development languages and tool chains can directly use Ethereum's, and developers can seamlessly migrate to Rollup. These do not exist in Ethscriptions, and you need to master new Rubidity, build new scans, get familiar with new VMs, etc. Of course, these obstacles are also opportunities for pioneering when a new ecosystem develops.

Withdrawal and Status Settlement

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

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

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

We can see that in FacetSwap (DEX built on Facet using the Daiben contract), there are two clear actions: deposit and withdrawal. Generally, Swap does not have deposit and withdrawal, because Facet requires you to cross domains before you can use it.

In Facet, recharge requires locking L1 funds on the L1 bridge contract and emitting the corresponding eventethscriptions_protocol_CreateEthscriptionLet Indexer do the indexing. This is consistent with other L2 recharge methods.

而提现则有严重的Safetyquestion.由于在 Facet 上没有任何的状态结算机制，L2 到 L1 上无法用合约自动判定一笔提现是否有效。那 Facet 使用了什么方法呢？管理员放行，或者叫见证人机制，类似于此前被盗的 Axie 桥。

Let's take a look at the bridge in Facet, the address is

0xD729345aA12c5Af2121D96f87B673987f354496B.

hashedMessageIt is a message signed by the signer, which contains some withdrawal content. The signer is a preset administrator address. Because there is no state settlement, no verification can be done, such as whether the account has so many coins on L2.Therefore, all funds on the contract can be taken away simply by the signer's signature, regardless of whether the project owner does evil or a hacker attacks to obtain the private key.

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

In Ethscriptions and Facets, nothing. It is simply and undisguisedly an administrator address. This is not a good idea for anXiaobai NavigationFor L2-like projects that often claim that "smart contracts are design flaws", "Rollups are centralized", and "we are a new generation of computing platforms", this is probably too sloppy.Obviously, it still has many shortcomings, but we can wait and see, although these shortcomings are not easy to make up for and may also exist in Bitcoin Layer2.

Summarize

There is a certain amount of "false advertising" in the current Ethscriptions. Here are some key points:

• Assets on Ethscriptions and Facet are not assets issued on L1.

• 为了有复杂的合约能力，演化出了 Facet 这个 L2 实体，但有极大的资金SafetyHidden danger.

• The official announcement is to de-computate contracts on L1, but even their flagship applications are not used.

• Ethscriptions is like a Rollup with very incomplete basic functions. It is neither as cheap and fast as Rollup, nor as secure as Rollup. What it can achieve, Rollup can achieve, but it cannot provide the very important functions that Rollup can achieve.

• If he wants to solve the above problems, he needs to develop a state settlement mechanism, plus a sorter and L2 block, then it will eventually become a Rollup.

Ethscriptions took advantage of the popularity of BTC inscriptions and relied on concept hype to put old wine in new bottles, but it has not yet discovered a new paradigm. At present, ETHS is still mainly based on financial speculation, rather than saying that this product itself can bring something that Ethereum Layer2 does not have. The long-term value of this thing is obviously still waiting for people to explore.But judging from its current form, ETHS has already taken on "the unbearable weight of life", and its slogan is far from its practical effect.

The article comes from the Internet:Technical Interpretation of Ethereum Inscription ETHS: The essence is financial speculation rather than product innovation

Related recommendations: An overview of the anti-inflation stablecoin (Flatcoin) track: Why is it regarded by Vitalik as one of the TOP3 crypto trends in 2023?

In the field of digital currency, although traditional stablecoins are designed to be pegged to specific fiat currencies or assets to maintain their stability, as fiat currencies become inflated, the corresponding digital stablecoins are also affected. Author: Leo Deng, LK Venture TL;DR The rise of inflation-resistant stablecoins: Digital stablecoins pegged to fiat currencies are affected by the decline in purchasing power, leading to financial markets’ interest in a…