60262186
Lok Sze Decoration Engineering Limited
Flat C7, 5/F, Tung Lee Factory Building, 9 Lai Yip Street, Kwun Tong, Kowloon
Interact with the contracts implemented in solidity: a guide
In the world of Ethereum, the implementation of the contract is a fundamental aspect of the construction of decentralized applications (APPS). While it is common to interact with these contracts using the web3 library, there are cases in which we must omit this restriction and communicate directly with the implemented contracts. In this article, we will explore how to interact with the contracts implemented in solidity, focusing on both calls directed to other contractual addresses and using the keywords of assembly.
Direct calls vs. Web library
Before immersing yourself in the issue of interaction with implemented contracts, it is essential to understand the difference between direct calls and interactions of the web bookcase:
* Direct calls : it is possible to send a message directly to another contractual address using the ‘contractual’ syntax in solidity.
* Example:
`
Callfunction Contract {
Myfunction Function () Public Returns (chain memory) {
Return CallContratCT ("Otherconttract", "Myfunction");
}
}
* Web library
: The Web3 library provides an interface to interact with Ethereum Networks, which allows you to make applications and send messages to other contracts.
Interact with the contracts implemented
To interact with the contracts implemented without using the Web3 bookshop, it is necessary to use a combination of theCallConttract ‘function and the words of key assembly of the only one. Here are some examples:
1. Direct called
You can call another contractual address directly when you pass it as a topic to “CallContratCT”:
`Solidity
// assume a
Pragma solidity ^0.8.0;
Callfunction Contract {
// works to interact with another contract
Myfunction Function () Public Returns (chain memory) {
Return CallContratCT ("Otherconttract", "Myfunction");
}
}
2. Use of key assembly words
You can also use the key assembly words to make direct calls or send messages to other contracts:
Solidity
// assume a
Pragma solidity ^0.8.0;
Callfunction Contract {
// works to interact with another contract
Myfunction Function () Public Returns (chain memory) {
// Send a message to another contract
assembly
Leave MSG = Mjmpack ("OtrocontTract", "Myfunction", 0)
Call (0, msg, 0)
}
}
In this example, we use theMjmpackfunction to pack a message in memory before sending it to the other contract.
Example of use of the case
Here is an example of how it is possible to interact with two contracts: contract A and contract B. In contract A, we define a "Myfunction" which returns a chain value. So we call this function of another contract using direct calls or words of key assembly:
Solidity
// assume a
Pragma solidity ^0.8.0;
Callfunction Contract {
// works to interact with another contract
Myfunction Function () Public Returns (chain memory) {
Back "Hello, World!";
}
}
In this example, we callcontracted.myfunction () directly or we use the key assembly words to send a message to the contract B:
`Solidity
// Contract B
Pragma solidity ^0.8.0;
Callfunction Contract {
// works to interact with another contract
Myfunction Function () Public Returns (chain memory) {
Back "Hello, World!";
}
}
`
Following these guidelines and examples, it can now interact with the contracts implemented in solidity without depending on the web bookcase.
Conclusion
The interaction with implemented contracts is an essential aspect for building decentralized applications. By understanding how to use direct calls and keywords of assembly in solidity, it is possible to create more complex interactions between contracts and improve the general understanding of the Ethereum programming model.