Product Innovation or Financial Speculation?Technical Interpretation ETH Workshop Inscription ETHS

Original source: Foggy Moon, 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, which carries the risk of theft. Obviously, ETHS is still mostly based on financial speculation at the moment, not that it can bring innovation that ETH Layer 2 can’t bring.

The recent popularity of BTC 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 all use the text information attached to the transfer to express the operation they 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 series of specifications and standards to normalize all text information.

3. The developer provides a set of Indexer indexer, which is used to calculate the 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.

BTC inscription Ordinals established a set of mechanisms for issuing NFTs and tokens on BTC, and 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 BTC’s own architecture in terms of technology and product experience, and was also criticized by the BTC community OG due to dust pollution and data usage.

After all ETH, ETH workshop itself has complex smart contracts, and ERC 20 and NFT are also the contents of ETH workshop, and what impact will these inscription projects have on the ecology of ETH, and will there be controversy and turmoil on 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 uses Calldata to operate.

Calldata is the raw input data that is transferred in ETH transactions. It is generally used to transmit parameters required for smart contract interactions, but it can also be used to send text messages to EOA addresses (messages, inscriptions, transfer notes, etc.). In the diagram, 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 calldata like this:

When the off-chain indexer hears about the transaction, it updates the database and notifies the user that a new inscription has been created that reads Hello world. It is also possible to put more complex content in the inscription, such as base 64, which represents image information.

Ethions has currently adopted 6 ESIPs (Proposals for improvement to the Ethions protocol), similar to EIPs, to define the use of inscriptions in different scenarios. However, these are only the 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 ETH Fang’s smart contracts 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 the EIP-2028 adjustment, calldata data 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 according to the complexity of the function execution, you also need to pay the computational cost. 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, 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 indicates that the data is in hexadecimal.

• A 9059 CBB after 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, and 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 left and 3 b 9 aca 00 non-zero data at the end, and 4 bytes of 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 the fixed cost, then the smart contract computational cost to execute the transaction is 41589 gas. In this transaction, the cost of contract computation accounts for the lion, and this is just a simple transaction, and the cost of contract computation will further increase in complex transactions.

Moving 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 an agreed EOA address

0x00000000000000000000000000000000000face7 Send transaction data

In the calldata of the transaction, declare which contract you originally wanted to call, along with 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, but will only publish a message.

Off-chain, after the Indexer listens to this message, it will parse it to figure out which contract the originator of the message originally wanted to call ETH chain, 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 runtimes, and the more complex ones can be called virtual machine VMs. 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 performing operations.

· Rubidity, the smart contract programming language in Facet, has some similarities with Ruby, but retains a lot of the usage and concepts of solidity, so 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, and dumb can describe the silent process of such a 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 okay to call them 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 invoking a stupid contract:

A minting transaction to an EOA black hole address

0x00000000000000000000000000000000000face7 Submit the calldata in the figure below to declare the token 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 diagram 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. Whether or not to reuse the EVM is officially more difficult to engineer than to develop a new VM and a new language, I don’t know. 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 want to create a market impression that “we are creating a new ETH scaling paradigm and usage method”, 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 official explanation, we can imagine:

Charges to users. For example, the NFT marketplace charges buyers a fee, but we can’t look at the long-term fee collection 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 ETH paradigm, Indexer must have a long-term, network-based economic mechanism to ensure its operation.

If it is a non-profit public goods, then what institutions will donate to? I think at least ETH Fang Foundation will not be particularly active, because ETH Fang 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 will be enough. So why did its ESIP-4 proposal give rise to Facet?

Because the inscription system cannot be used for complex transaction logic. Let’s take a look at the 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() is triggered by default.

Eventually, an event called PotentialEthionDeposited will be thrown on the ETH chain, 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, ETHS’s trading market did not store some parameters of sellers’ pending orders, such as price and cut-off time, in the ETH contract, but placed them offline in the form of messages, which should be stored on the dApp’s 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 a maker order mechanism because NFTs are not fungible in themselves. So if it’s a homogenized token inscription, can you use the AMM mechanism of the contract? The answer is no. The state of the inscription NFT or token, which is not on L1, is similar to Ordinals and BRC-20. This is diametrically opposed to the propaganda of some communities, and everyone needs to be careful to identify that the inscription is not an asset on the ETH chain in the true sense of the word. We can’t say that the calldata of the generated asset is on L1, and we can declare operation instructions on L1, which is called the native asset on L1, otherwise the L2 native asset on the rollup can also be called the 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 things like inscriptions 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 outlandish, I can give a very simple criterion for identifying an L1 asset from an L2 asset: whether its state can be restored on the “world state” of the ETH, whether the EVM of L1 can reference, call, query, modify the state of the asset, and if not, then it is not an L1 asset.

Therefore, 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 record 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, forwards me 1 ETH with a postscript 123 and gets an inscription NFT with my 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 someone transferring 1 ETH to the seller with a postscript BCH.

Of course, this example will actually bring some problems, such as duplicate 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, rather than contracts, but the relatively complex logic of AMMs requires smart contracts, because it requires not p2p agreement between the two parties, but contract recognition. 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. Rollups

From the above tirade, you should be able to see that Ethions’ solution is somewhat similar to Rollup. But this is only “similar”, and if strictly speaking, it only implements 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 data 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.

Rollups submit calldata in bulk

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 them, compresses them, and sends calldata to L1 in batches. Submitting calldata for multiple users in a single transaction 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 very loosely:

• Inscription users are required to pay 21608 gas (608 + 21000) each. 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 it has better data compression, which we will not expand here.

From this rough estimate, it can be seen that Ethions does not have any cost advantage over Layer 2. In addition, in the community propaganda of the project, I have seen something like “4000 inscriptions can be transferred in batches, about 0.11 ETH, and the average transfer only needs 0.05 U” to prove that Ethions is cheap to use, which does not actually 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 1 s. 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 and 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 eventually 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 anyone can run and verify it, but in fact the vast majority of people don’t run their own nodes. After all, the Rollup sequencer may be down or malfunction, but ETHS can continue to run 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: overcharge gas, squeeze MEV, etc. The sequencer has the power to keep the network running. Ethions Since users submit calldata directly to L1, Indexer is actually not good at charging.

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 this exists 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.

Payouts and status settlements

This is Famet’s fatal problem. We know that the 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 state settlement? It is used for withdrawals, i.e. withdrawals 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 doesn’t have a stateful settlement mechanism, so he can’t implement permissionless, decentralized withdrawals from L2 to L1. As mentioned above, he in turn needs an L2 layer 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 domains 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 on L2 to L1 to automatically determine whether a withdrawal is valid or not. So what method does Facet use? Administrator clearance, or witness mechanism, is similar to the previously stolen Axie Bridge.

Let’s take a look directly at Facet’s bridge, which is:

0xD729345aA12c5Af2121D96f87B673987f354496B。

The hashedMessage is a message signed by the signer, which contains some content that has been withdrawn. The 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, regardless of whether the project party is evil or hackers attack 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 certain economic deterrence and deter evil.

In Ethions and Facets, nothing. It’s simply, unabashedly an admin address. This is probably too sloppy for an L2-like project that shouts “smart contracts are design flaws”, “rollups are centralized”, and “we are a next-generation computing platform”. Obviously, there are many more flaws in him, but we can stay on the sidelines, although they are not easy to remedy and may be present in BTC Layer 2 as well.

Summarize

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

· Neither Ethions nor Facet are assets issued on L1.

In order to have complex contract capabilities, the L2 entity Facet has evolved, but it has great financial security risks.

Officially, the contract is calculated on L1, but it doesn’t even use its own top application.

· Ethions is like a very incomplete Rollup. Neither the cheapness and speed of Rollup, nor the security of 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 old wine in new bottles, but has yet to discover a new paradigm. The current ETHS is still dominated by financial speculation, not that the product itself can bring something 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 already taken on the “unbearable weight of life”, and his slogan is far from effective in practice.

Link to original article