Solidity, как проверить декодирование calldata в конкретную структуру
У меня есть солидный интерфейс, который выглядит так, я бы хотел, чтобы мой вызов вернулся, если переданные данные вызова не относятся к определенному типу
// Resolver interface
interface IResolver {
// Pass payment info as calldata only the manager should have the right to update it
function resolve(uint256 amount, ResolverOptions calldata resolverOptions) external returns (uint256);
// Reverts if the calldata passes is not a proper struct
function validateAdditionalCalldata(bytes calldata additionalCalldata) external view;
}
Я создал класс для реализации этого здесь:
struct fooResolverOptions {
address[] fooAddresses;
uint256[] fooAmounts;
}
contract FooResolver is IResolver {
// Validate the additional calldata passed to the resolver contract
function validateAdditionalCalldata(bytes calldata additionalCalldata) view external {
// Convert the additional calldata to bytes memory
bytes memory additionalCalldataMemory = additionalCalldata;
// Decode the additional calldata as a FooResolverOptions struct
FooResolverOptions memory fooOptions;
bool success = abi.decode(additionalCalldataMemory, fooOptions);
// Check if the decode was successful
require(success, "Invalid additional calldata");
}
}
Ни один из способов, которые я пытался декодировать, не работает:
bool success = abi.decode(additionalCalldataMemory, fooOptions);
таким образом утверждается, что из декодирования нет возвращаемого значения.
FooResolverOptions memory fooOptions;
abi.decode(additionalCalldata, fooOptions);
Этот способ утверждает, что ему нужен кортеж типов. Как декодировать данные структуры и подтвердить их успешность?
Ответы 1
В настоящее время Solidity (v0.8) не поддерживает динамические аргументы в abi.decode(), поэтому вам нужно написать логику, которая проверяет соответствие предварительно определенному набору типов.
bytes calldata additionalCalldata в вашем примере — это массив байтов, поэтому abi.decode(additionalCalldataMemory, <types>); пытается декодировать двоичный файл во все, что <types> вы передаете. Если ввод соответствует длине типа, он просто декодирует значение в тип.
Пример, в котором значение подходит как к типам bool, так и к типам address, поэтому обе операции выполняются успешно:
function validateAdditionalCalldata() pure external returns (bool, address) {
bytes memory additionalCalldataMemory = hex"0000000000000000000000000000000000000000000000000000000000000001";
bool decoded1 = abi.decode(additionalCalldataMemory, (bool));
address decoded2 = abi.decode(additionalCalldataMemory, (address));
return (decoded1, decoded2);
}
Когда значение не соответствует типу, генерируется исключение. Неперехваченное исключение эффективно отменяет транзакцию или вызов. Однако вы можете использовать try / catch, чтобы поймать исключение.
pragma solidity ^0.8;
contract FooResolver {
function validateAdditionalCalldata() external view returns (bool, address) {
// does not fit `bool` but still fits `address`
bytes memory additionalCalldataMemory = hex"0000000000000000000000000000000000000000000000000000000000000002";
bool decoded1;
try this.decodeToBool(additionalCalldataMemory) returns (bool decodedValue) {
decoded1 = decodedValue;
} catch {
decoded1 = false;
}
address decoded2 = abi.decode(additionalCalldataMemory, (address));
return (decoded1, decoded2);
}
// workaround - try/catch can be currently (v0.8) used on external function calls - but not on native function calls
function decodeToBool(bytes memory data) external pure returns (bool) {
return abi.decode(data, (bool));
}
}
@RitzyDev Как «будет ли шестнадцатеричный код переполнять этот тип», так и ожидаемая длина массива байтов: 1) фактически только 0 и 1 в bool, поэтому вы не можете назначить ему 2 ... 2) Массивы фиксированного размера имеют предопределенную длину байта в объявление типа данных (например, ожидается, что address[2] займет ровно 2 слота по 32 байта). Массивы динамического размера (например, address[]) следуют шаблону данных, который использует 2 слота для пустых массивов или как минимум 3 слота для массивов со значениями. Второе значение слота содержит длину данных, поэтому его также можно использовать для проверки.
Спасибо, у вас есть ресурсы, где я могу изучить это подробнее, я просмотрел документы Solidity, но я не вижу особого упоминания о том, как работает abi.encode
@RitzyDev В документации есть специальный раздел, описывающий, как работает кодировка ABI, включая динамические типы с примерами: docs.soliditylang.org/en/v0.8.17/abi-spec.html
хм, я смотрел на это, документация неясна, в ней явно не указано, что будет вызывать ошибки. Хотя спасибо за информацию
Вы уверены, что сказали правильно? Я попытался создать для него тест здесь: stackoverflow.com/questions/75012873/… и он все равно возвращается правильно
@RitzyDev Отличный улов. У меня возникла ошибка, когда данные были короче, чем ожидалось: abi.decode(hex"0001", (bool)); ... Но когда ввод длиннее, он только обрезает данные, но не ошибается: abi.decode(hex"000000000000000000000000000000000000000000000000000000000000000000000001", (bool));
хорошо, так что просто для пояснения, когда вы имеете в виду подходит, вы имеете в виду, будет ли шестнадцатеричный переполнять этот тип? например, abi.decode не проверяет длину данных вызова, чтобы убедиться, что они совпадают? например, поскольку он принимает массив типов, будет ли он считать, что вы пропустили часть для декодирования, или он всегда должен соответствовать длине типов, которые вы пытаетесь декодировать?