Ethereum: The type address is not converted by default to the expected structure
As an experienced Ethereum programmer, you probably know the nuances of working with the Ethereum ecosystem. In this article, we will look at a frequent problem, which appears when trying to manipulate data structures in Solidita, the programming language used to write intelligent contracts in blockchain Ethereum.
Problem: Enter the address in front of the structure
The solidita structure is defined using the “{}” keyword, followed by the name of the structure, fields and their types. “Type address” is a “address” occurrence, which is determined by the unique numerical identifier of the contract or user in the Ethereum network.
By defining the “structure” in Solidity, you create a new data structure with specific fields and corresponding types. However, when you try to assign the value of one type of structure to another type, e.g. by returning the “structure” from the function and initiating another variable with the same structure type, it seems that there is a problem for closed conversion.
** Error: “The address type is not converted by default …”
An error message indicates that Solidity does not know how to convert the “address type” value returned by the function to the expected type of second variable. This is because the definition of the “structure” in the code has a specific order of fields, and the types used are incompatible.
Why is this happening?
To understand where this problem comes from, let’s take a closer look at how the Solidity compiler copes with the definitions of structures and field assignments. When defining the “structure” consisting of many fields of solidity, it must make sure that all fields are assigned to the appropriate variables in the correct order.
In your case, the problem is that when you return the “structure” from the function, the compiler tries to convert it to a structure type (e.g. “{}”), which expects specific types of fields. However, the “address type” returned by the function may not correspond to any of these types of fields.
Example of code
Let’s look at a simple example illustrating this problem:
`strength
Pragma solidity ^0.8.0;
Configuration structure {
Uint256 Public network;
}
The GetnetWorkConfig () Public Pure function returns (config) {
return the configuration ({
Network: 1, // The address type is not converted by default to the structure
Version: 1,
Version name: “1.0”
});
}
`
In this example, the “GetnetWorkConfig” function returns the “config” structure with three fields (“Network”, “Version” and “Versionname”). However, when you initiate another variable using a returned value, it expects the “config” structure to occur, but the compiler tries to assign a “type address” value.
solutions
To solve this problem, you can use several methods:
- Use explicit conversions : Define “Struct” fields using specific types (eg “Uint256 Network;”). Thanks to this, you can be sure that the appropriate types of fields will be used when assigning values.
`strength
Pragma solidity ^0.8.0;
Configuration structure {
Uint256 Public network;
}
The GetnetWorkConfig () Public Pure function returns (config) {
return the configuration ({
Network: 1,
Version: 2, // Use an open conversion to Uint256
Version name: “2.0”
});
}
`
- Use the type alias: Define ALIAS “Type” for code type and use it consistently throughout the text:
`strength
Pragma solidity ^0.8.0;
Configuration structure {
Uint256 Public network;
}
Enter NetworkConfig = address;
GetnetworkConfig function () public pure Return (NetworkConfig) {
Return NetworkConfig (1);
}
`
3.
`strength
Pragma’s strength ^0.8.