mirror of
https://github.com/ethereum/solidity
synced 2023-10-03 13:03:40 +00:00
606 lines
29 KiB
Plaintext
606 lines
29 KiB
Plaintext
object "DepositContract_541_deployed" {
|
|
code {
|
|
{
|
|
mstore(64, 128)
|
|
if iszero(lt(calldatasize(), 4))
|
|
{
|
|
let _1 := 0
|
|
switch shr(224, calldataload(_1))
|
|
case 0x01ffc9a7 {
|
|
if callvalue() { revert(_1, _1) }
|
|
return(128, add(abi_encode_bool(fun_supportsInterface(abi_decode_bytes4(calldatasize()))), not(127)))
|
|
}
|
|
case 0x22895118 {
|
|
let param, param_1, param_2, param_3, param_4, param_5, param_6 := abi_decode_bytes_calldatat_bytes_calldatat_bytes_calldatat_bytes32(calldatasize())
|
|
fun_deposit(param, param_1, param_2, param_3, param_4, param_5, param_6)
|
|
return(mload(64), _1)
|
|
}
|
|
case 0x621fd130 {
|
|
if callvalue() { revert(_1, _1) }
|
|
abi_decode(calldatasize())
|
|
let ret := fun_to_little_endian(convert_uint256_to_uint64(sload(0x20)))
|
|
let memPos := mload(64)
|
|
return(memPos, sub(abi_encode_bytes(memPos, ret), memPos))
|
|
}
|
|
case 0xc5f2892f {
|
|
if callvalue() { revert(_1, _1) }
|
|
abi_decode(calldatasize())
|
|
let ret_1 := fun_get_deposit_root()
|
|
let memPos_1 := mload(64)
|
|
return(memPos_1, sub(abi_encode_bytes32(memPos_1, ret_1), memPos_1))
|
|
}
|
|
}
|
|
revert(0, 0)
|
|
}
|
|
function abi_decode_bytes_calldata(offset, end) -> arrayPos, length
|
|
{
|
|
if iszero(slt(add(offset, 0x1f), end)) { revert(0, 0) }
|
|
length := calldataload(offset)
|
|
if gt(length, 0xffffffffffffffff) { revert(0, 0) }
|
|
arrayPos := add(offset, 0x20)
|
|
if gt(add(add(offset, length), 0x20), end) { revert(0, 0) }
|
|
}
|
|
function abi_decode(dataEnd)
|
|
{
|
|
if slt(add(dataEnd, not(3)), 0) { revert(0, 0) }
|
|
}
|
|
function abi_decode_bytes4(dataEnd) -> value0
|
|
{
|
|
if slt(add(dataEnd, not(3)), 32) { revert(0, 0) }
|
|
let value := calldataload(4)
|
|
if iszero(eq(value, and(value, shl(224, 0xffffffff)))) { revert(0, 0) }
|
|
value0 := value
|
|
}
|
|
function abi_decode_bytes_calldatat_bytes_calldatat_bytes_calldatat_bytes32(dataEnd) -> value0, value1, value2, value3, value4, value5, value6
|
|
{
|
|
if slt(add(dataEnd, not(3)), 128) { revert(0, 0) }
|
|
let offset := calldataload(4)
|
|
let _1 := 0xffffffffffffffff
|
|
if gt(offset, _1) { revert(0, 0) }
|
|
let value0_1, value1_1 := abi_decode_bytes_calldata(add(4, offset), dataEnd)
|
|
value0 := value0_1
|
|
value1 := value1_1
|
|
let offset_1 := calldataload(36)
|
|
if gt(offset_1, _1) { revert(0, 0) }
|
|
let value2_1, value3_1 := abi_decode_bytes_calldata(add(4, offset_1), dataEnd)
|
|
value2 := value2_1
|
|
value3 := value3_1
|
|
let offset_2 := calldataload(68)
|
|
if gt(offset_2, _1) { revert(0, 0) }
|
|
let value4_1, value5_1 := abi_decode_bytes_calldata(add(4, offset_2), dataEnd)
|
|
value4 := value4_1
|
|
value5 := value5_1
|
|
value6 := calldataload(100)
|
|
}
|
|
function abi_encode_bytes_calldata_ptr(start, length, pos) -> end
|
|
{
|
|
mstore(pos, length)
|
|
calldatacopy(add(pos, 0x20), start, length)
|
|
mstore(add(add(pos, length), 0x20), 0)
|
|
end := add(add(pos, and(add(length, 31), not(31))), 0x20)
|
|
}
|
|
function abi_encode_bytes_calldata(start, length, pos) -> end
|
|
{
|
|
calldatacopy(pos, start, length)
|
|
let _1 := add(pos, length)
|
|
mstore(_1, 0)
|
|
end := _1
|
|
}
|
|
function abi_encode_bytes_to_bytes(value, pos) -> end
|
|
{
|
|
let length := mload(value)
|
|
mstore(pos, length)
|
|
copy_memory_to_memory(add(value, 0x20), add(pos, 0x20), length)
|
|
end := add(add(pos, and(add(length, 31), not(31))), 0x20)
|
|
}
|
|
function abi_encode_bytes_memory_ptr(value, pos) -> end
|
|
{
|
|
let length := mload(value)
|
|
copy_memory_to_memory(add(value, 0x20), pos, length)
|
|
end := add(pos, length)
|
|
}
|
|
function abi_encode_packed_bytes32_bytes32(pos, value0, value1) -> end
|
|
{
|
|
mstore(pos, value0)
|
|
mstore(add(pos, 32), value1)
|
|
end := add(pos, 64)
|
|
}
|
|
function abi_encode_packed_bytes32_bytes_calldata(pos, value0, value1, value2) -> end
|
|
{
|
|
mstore(pos, value0)
|
|
calldatacopy(add(pos, 32), value1, value2)
|
|
let _1 := add(add(pos, value2), 32)
|
|
mstore(_1, 0)
|
|
end := _1
|
|
}
|
|
function abi_encode_packed_bytes32_bytes_bytes24(pos, value0, value1) -> end
|
|
{
|
|
mstore(pos, value0)
|
|
let length := mload(value1)
|
|
copy_memory_to_memory(add(value1, 32), add(pos, 32), length)
|
|
let _1 := add(pos, length)
|
|
mstore(add(_1, 32), 0)
|
|
end := add(_1, 56)
|
|
}
|
|
function abi_encode_packed_bytes_calldata_slice_bytes32(pos, value0, value1) -> end
|
|
{
|
|
calldatacopy(pos, value0, value1)
|
|
let _1 := add(pos, value1)
|
|
mstore(_1, 0x00)
|
|
mstore(_1, 0x00)
|
|
end := add(_1, 32)
|
|
}
|
|
function abi_encode_packed_bytes_calldata_bytes16(pos, value0, value1) -> end
|
|
{
|
|
calldatacopy(pos, value0, value1)
|
|
let _1 := add(pos, value1)
|
|
mstore(_1, 0)
|
|
mstore(_1, 0)
|
|
end := add(_1, 16)
|
|
}
|
|
function abi_encode_packed_bytes_bytes24_bytes32(pos, value0, value2) -> end
|
|
{
|
|
let length := mload(value0)
|
|
copy_memory_to_memory(add(value0, 0x20), pos, length)
|
|
let end_1 := add(pos, length)
|
|
mstore(end_1, 0)
|
|
mstore(add(end_1, 24), value2)
|
|
end := add(end_1, 56)
|
|
}
|
|
function abi_encode_bool(value0) -> tail
|
|
{
|
|
tail := 160
|
|
mstore(128, iszero(iszero(value0)))
|
|
}
|
|
function abi_encode_bytes32(headStart, value0) -> tail
|
|
{
|
|
tail := add(headStart, 32)
|
|
mstore(headStart, value0)
|
|
}
|
|
function abi_encode_bytes_calldata_bytes_calldata_bytes_bytes_calldata_bytes(headStart, value0, value1, value2, value3, value4, value5, value6, value7) -> tail
|
|
{
|
|
mstore(headStart, 160)
|
|
let tail_1 := abi_encode_bytes_calldata_ptr(value0, value1, add(headStart, 160))
|
|
mstore(add(headStart, 32), sub(tail_1, headStart))
|
|
let tail_2 := abi_encode_bytes_calldata_ptr(value2, value3, tail_1)
|
|
mstore(add(headStart, 64), sub(tail_2, headStart))
|
|
let tail_3 := abi_encode_bytes_to_bytes(value4, tail_2)
|
|
mstore(add(headStart, 96), sub(tail_3, headStart))
|
|
let tail_4 := abi_encode_bytes_calldata_ptr(value5, value6, tail_3)
|
|
mstore(add(headStart, 128), sub(tail_4, headStart))
|
|
tail := abi_encode_bytes_to_bytes(value7, tail_4)
|
|
}
|
|
function abi_encode_bytes(headStart, value0) -> tail
|
|
{
|
|
mstore(headStart, 32)
|
|
tail := abi_encode_bytes_to_bytes(value0, add(headStart, 32))
|
|
}
|
|
function assert_helper()
|
|
{
|
|
mstore(0x00, shl(224, 0x4e487b71))
|
|
mstore(4, 1)
|
|
revert(0x00, 0x24)
|
|
}
|
|
function calldata_array_index_range_access_bytes_calldata(offset, length) -> offsetOut, lengthOut
|
|
{
|
|
if gt(64, length) { revert(0x00, 0x00) }
|
|
offsetOut := offset
|
|
lengthOut := 64
|
|
}
|
|
function calldata_array_index_range_access_bytes_calldata_3133(offset, length, endIndex) -> offsetOut, lengthOut
|
|
{
|
|
if gt(64, endIndex) { revert(0, 0) }
|
|
if gt(endIndex, length) { revert(0, 0) }
|
|
offsetOut := add(offset, 64)
|
|
lengthOut := add(endIndex, not(63))
|
|
}
|
|
function checked_add_uint256(x) -> sum
|
|
{
|
|
if gt(x, not(1)) { panic_error_0x11() }
|
|
sum := add(x, 0x01)
|
|
}
|
|
function convert_uint256_to_uint64(value) -> converted
|
|
{
|
|
converted := and(value, 0xffffffffffffffff)
|
|
}
|
|
function copy_memory_to_memory(src, dst, length)
|
|
{
|
|
let i := 0
|
|
for { } lt(i, length) { i := add(i, 32) }
|
|
{
|
|
mstore(add(dst, i), mload(add(src, i)))
|
|
}
|
|
if gt(i, length) { mstore(add(dst, length), 0) }
|
|
}
|
|
function extract_from_storage_value_dynamict_bytes32(slot_value, offset) -> value
|
|
{
|
|
value := shr(shl(3, offset), slot_value)
|
|
}
|
|
function finalize_allocation(memPtr, size)
|
|
{
|
|
let newFreePtr := add(memPtr, and(add(size, 31), not(31)))
|
|
if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
|
|
mstore(64, newFreePtr)
|
|
}
|
|
function fun_deposit(var_pubkey_offset, var_pubkey_length, var_withdrawal_credentials_offset, var_withdrawal_credentials_length, var_signature_offset, var_signature_length, var_deposit_data_root)
|
|
{
|
|
require_helper_stringliteral_c3b5(eq(var_pubkey_length, 0x30))
|
|
let _1 := 0x20
|
|
require_helper_stringliteral(eq(var_withdrawal_credentials_length, _1))
|
|
require_helper_stringliteral_e15d(eq(var_signature_length, 0x60))
|
|
require_helper_stringliteral_d4d9(iszero(lt(callvalue(), 0x0de0b6b3a7640000)))
|
|
require_helper_stringliteral_7db0(iszero(mod(callvalue(), 0x3b9aca00)))
|
|
let _2 := 0xffffffffffffffff
|
|
require_helper_stringliteral_c445(iszero(gt(div(callvalue(), 0x3b9aca00), _2)))
|
|
let expr_279_mpos := fun_to_little_endian(and(div(callvalue(), 0x3b9aca00), _2))
|
|
let _3 := sload(_1)
|
|
let expr_291_mpos := fun_to_little_endian(and(_3, _2))
|
|
let _4 := mload(64)
|
|
log1(_4, sub(abi_encode_bytes_calldata_bytes_calldata_bytes_bytes_calldata_bytes(_4, var_pubkey_offset, var_pubkey_length, var_withdrawal_credentials_offset, var_withdrawal_credentials_length, expr_279_mpos, var_signature_offset, var_signature_length, expr_291_mpos), _4), 0x649bbc62d0e31342afea4e5cd82d4049e7e1ee912fc0889aa790803be39038c5)
|
|
let expr_304_mpos := mload(64)
|
|
let _5 := sub(abi_encode_packed_bytes_calldata_bytes16(add(expr_304_mpos, _1), var_pubkey_offset, var_pubkey_length), expr_304_mpos)
|
|
let _6 := not(31)
|
|
mstore(expr_304_mpos, add(_5, _6))
|
|
finalize_allocation(expr_304_mpos, _5)
|
|
let _7 := mload(64)
|
|
let _8 := sub(abi_encode_bytes_memory_ptr(expr_304_mpos, _7), _7)
|
|
if iszero(staticcall(gas(), 2, _7, _8, 0x00, _1)) { revert_forward() }
|
|
let _9 := mload(0x00)
|
|
let expr_317_offset, expr_length := calldata_array_index_range_access_bytes_calldata(var_signature_offset, var_signature_length)
|
|
let expr_mpos := mload(64)
|
|
let _10 := sub(abi_encode_bytes_calldata(expr_317_offset, expr_length, add(expr_mpos, _1)), expr_mpos)
|
|
mstore(expr_mpos, add(_10, _6))
|
|
finalize_allocation(expr_mpos, _10)
|
|
let _11 := mload(64)
|
|
if iszero(staticcall(gas(), 2, _11, sub(abi_encode_bytes_memory_ptr(expr_mpos, _11), _11), 0x00, _1)) { revert_forward() }
|
|
let _12 := mload(0x00)
|
|
let expr_offset, expr_325_length := calldata_array_index_range_access_bytes_calldata_3133(var_signature_offset, var_signature_length, var_signature_length)
|
|
let expr_330_mpos := mload(64)
|
|
let _13 := sub(abi_encode_packed_bytes_calldata_slice_bytes32(add(expr_330_mpos, _1), expr_offset, expr_325_length), expr_330_mpos)
|
|
mstore(expr_330_mpos, add(_13, _6))
|
|
finalize_allocation(expr_330_mpos, _13)
|
|
let _14 := mload(64)
|
|
if iszero(staticcall(gas(), 2, _14, sub(abi_encode_bytes_memory_ptr(expr_330_mpos, _14), _14), 0x00, _1)) { revert_forward() }
|
|
let _15 := mload(0x00)
|
|
let expr_332_mpos := mload(64)
|
|
let _16 := sub(abi_encode_packed_bytes32_bytes32(add(expr_332_mpos, _1), _12, _15), expr_332_mpos)
|
|
mstore(expr_332_mpos, add(_16, _6))
|
|
finalize_allocation(expr_332_mpos, _16)
|
|
let _17 := mload(64)
|
|
if iszero(staticcall(gas(), 2, _17, sub(abi_encode_bytes_memory_ptr(expr_332_mpos, _17), _17), 0x00, _1)) { revert_forward() }
|
|
let _18 := mload(0x00)
|
|
let expr_345_mpos := mload(64)
|
|
let _19 := sub(abi_encode_packed_bytes32_bytes_calldata(add(expr_345_mpos, _1), _9, var_withdrawal_credentials_offset, var_withdrawal_credentials_length), expr_345_mpos)
|
|
mstore(expr_345_mpos, add(_19, _6))
|
|
finalize_allocation(expr_345_mpos, _19)
|
|
let _20 := mload(64)
|
|
if iszero(staticcall(gas(), 2, _20, sub(abi_encode_bytes_memory_ptr(expr_345_mpos, _20), _20), 0x00, _1)) { revert_forward() }
|
|
let _21 := mload(0x00)
|
|
let expr_356_mpos := mload(64)
|
|
let _22 := sub(abi_encode_packed_bytes_bytes24_bytes32(add(expr_356_mpos, _1), expr_279_mpos, _18), expr_356_mpos)
|
|
mstore(expr_356_mpos, add(_22, _6))
|
|
finalize_allocation(expr_356_mpos, _22)
|
|
let _23 := mload(64)
|
|
if iszero(staticcall(gas(), 2, _23, sub(abi_encode_bytes_memory_ptr(expr_356_mpos, _23), _23), 0x00, _1)) { revert_forward() }
|
|
let _24 := mload(0x00)
|
|
let expr_358_mpos := mload(64)
|
|
let _25 := sub(abi_encode_packed_bytes32_bytes32(add(expr_358_mpos, _1), _21, _24), expr_358_mpos)
|
|
mstore(expr_358_mpos, add(_25, _6))
|
|
finalize_allocation(expr_358_mpos, _25)
|
|
let _26 := mload(64)
|
|
if iszero(staticcall(gas(), 2, _26, sub(abi_encode_bytes_memory_ptr(expr_358_mpos, _26), _26), 0x00, _1)) { revert_forward() }
|
|
let var_node := mload(0x00)
|
|
require_helper_stringliteral_18a6(eq(var_node, var_deposit_data_root))
|
|
require_helper_stringliteral_122a(lt(_3, 0xffffffff))
|
|
update_storage_value_offsett_uint256_to_uint256(checked_add_uint256(_3))
|
|
let var_size := sload(_1)
|
|
let var_height := 0x00
|
|
for { }
|
|
lt(var_height, _1)
|
|
{
|
|
var_height := increment_uint256(var_height)
|
|
}
|
|
{
|
|
if eq(and(var_size, 0x01), 0x01)
|
|
{
|
|
let _27, _28 := storage_array_index_access_bytes_3138(var_height)
|
|
update_storage_value_bytes32_to_bytes32(_27, _28, var_node)
|
|
leave
|
|
}
|
|
let _29, _30 := storage_array_index_access_bytes_3138(var_height)
|
|
let _31 := extract_from_storage_value_dynamict_bytes32(sload(_29), _30)
|
|
let expr_416_mpos := mload(64)
|
|
let _32 := sub(abi_encode_packed_bytes32_bytes32(add(expr_416_mpos, _1), _31, var_node), expr_416_mpos)
|
|
mstore(expr_416_mpos, add(_32, _6))
|
|
finalize_allocation(expr_416_mpos, _32)
|
|
let _33 := mload(64)
|
|
if iszero(staticcall(gas(), 2, _33, sub(abi_encode_bytes_memory_ptr(expr_416_mpos, _33), _33), 0x00, _1)) { revert_forward() }
|
|
var_node := mload(0x00)
|
|
var_size := shr(0x01, var_size)
|
|
}
|
|
assert_helper()
|
|
}
|
|
function fun_get_deposit_root() -> var
|
|
{
|
|
let var_node := 0
|
|
let _1 := 0x20
|
|
let var_size := sload(_1)
|
|
let var_size_1 := var_size
|
|
let var_height := var_node
|
|
for { }
|
|
lt(var_height, _1)
|
|
{
|
|
var_height := increment_uint256(var_height)
|
|
}
|
|
{
|
|
let _2 := 0x01
|
|
switch eq(and(var_size, _2), _2)
|
|
case 0 {
|
|
let _3, _4 := storage_array_index_access_bytes_3142(var_height)
|
|
let _5 := extract_from_storage_value_dynamict_bytes32(sload(_3), _4)
|
|
let _6 := 64
|
|
let expr_157_mpos := mload(_6)
|
|
let _7 := sub(abi_encode_packed_bytes32_bytes32(add(expr_157_mpos, _1), var_node, _5), expr_157_mpos)
|
|
mstore(expr_157_mpos, add(_7, not(31)))
|
|
finalize_allocation(expr_157_mpos, _7)
|
|
let _8 := mload(_6)
|
|
if iszero(staticcall(gas(), 0x02, _8, sub(abi_encode_bytes_memory_ptr(expr_157_mpos, _8), _8), 0, _1)) { revert_forward() }
|
|
var_node := mload(0)
|
|
}
|
|
default {
|
|
let _9, _10 := storage_array_index_access_bytes(var_height)
|
|
let _11 := extract_from_storage_value_dynamict_bytes32(sload(_9), _10)
|
|
let _12 := 64
|
|
let expr_145_mpos := mload(_12)
|
|
let _13 := sub(abi_encode_packed_bytes32_bytes32(add(expr_145_mpos, _1), _11, var_node), expr_145_mpos)
|
|
mstore(expr_145_mpos, add(_13, not(31)))
|
|
finalize_allocation(expr_145_mpos, _13)
|
|
let _14 := mload(_12)
|
|
if iszero(staticcall(gas(), 0x02, _14, sub(abi_encode_bytes_memory_ptr(expr_145_mpos, _14), _14), 0, _1)) { revert_forward() }
|
|
var_node := mload(0)
|
|
}
|
|
var_size := shr(_2, var_size)
|
|
}
|
|
let expr_177_mpos := fun_to_little_endian(and(var_size_1, 0xffffffffffffffff))
|
|
let expr_182_mpos := mload(64)
|
|
let _15 := sub(abi_encode_packed_bytes32_bytes_bytes24(add(expr_182_mpos, _1), var_node, expr_177_mpos), expr_182_mpos)
|
|
mstore(expr_182_mpos, add(_15, not(31)))
|
|
finalize_allocation(expr_182_mpos, _15)
|
|
let _16 := mload(64)
|
|
if iszero(staticcall(gas(), 0x02, _16, sub(abi_encode_bytes_memory_ptr(expr_182_mpos, _16), _16), 0, _1)) { revert_forward() }
|
|
var := mload(0)
|
|
}
|
|
function fun_supportsInterface(var_interfaceId) -> var_
|
|
{
|
|
let _1 := and(var_interfaceId, shl(224, 0xffffffff))
|
|
let expr := eq(_1, shl(224, 0x01ffc9a7))
|
|
if iszero(expr)
|
|
{
|
|
expr := eq(_1, shl(224, 0x85640907))
|
|
}
|
|
var_ := expr
|
|
}
|
|
function fun_to_little_endian(var_value) -> var_ret_mpos
|
|
{
|
|
let memPtr := mload(64)
|
|
let newFreePtr := add(memPtr, 64)
|
|
if or(gt(newFreePtr, 0xffffffffffffffff), lt(newFreePtr, memPtr)) { panic_error_0x41() }
|
|
mstore(64, newFreePtr)
|
|
mstore(memPtr, 0x08)
|
|
calldatacopy(add(memPtr, 0x20), calldatasize(), 0x20)
|
|
var_ret_mpos := memPtr
|
|
let expr := and(shl(192, var_value), shl(192, 0xffffffffffffffff))
|
|
mstore8(memory_array_index_access_bytes_3147(memPtr), byte(0x07, expr))
|
|
mstore8(memory_array_index_access_bytes_3148(memPtr), byte(0x06, expr))
|
|
mstore8(memory_array_index_access_bytes_3149(memPtr), byte(0x05, expr))
|
|
mstore8(memory_array_index_access_bytes_3150(memPtr), byte(0x04, expr))
|
|
mstore8(memory_array_index_access_bytes_3151(memPtr), byte(0x03, expr))
|
|
mstore8(memory_array_index_access_bytes_3152(memPtr), byte(0x02, expr))
|
|
mstore8(memory_array_index_access_bytes_3153(memPtr), byte(1, expr))
|
|
mstore8(memory_array_index_access_bytes(memPtr), byte(0, expr))
|
|
}
|
|
function increment_uint256(value) -> ret
|
|
{
|
|
if eq(value, not(0)) { panic_error_0x11() }
|
|
ret := add(value, 1)
|
|
}
|
|
function memory_array_index_access_bytes_3147(baseRef) -> addr
|
|
{
|
|
if iszero(mload(baseRef)) { panic_error_0x32() }
|
|
addr := add(baseRef, 32)
|
|
}
|
|
function memory_array_index_access_bytes_3148(baseRef) -> addr
|
|
{
|
|
if iszero(lt(0x01, mload(baseRef))) { panic_error_0x32() }
|
|
addr := add(baseRef, 33)
|
|
}
|
|
function memory_array_index_access_bytes_3149(baseRef) -> addr
|
|
{
|
|
if iszero(lt(0x02, mload(baseRef))) { panic_error_0x32() }
|
|
addr := add(baseRef, 34)
|
|
}
|
|
function memory_array_index_access_bytes_3150(baseRef) -> addr
|
|
{
|
|
if iszero(lt(0x03, mload(baseRef))) { panic_error_0x32() }
|
|
addr := add(baseRef, 35)
|
|
}
|
|
function memory_array_index_access_bytes_3151(baseRef) -> addr
|
|
{
|
|
if iszero(lt(0x04, mload(baseRef))) { panic_error_0x32() }
|
|
addr := add(baseRef, 36)
|
|
}
|
|
function memory_array_index_access_bytes_3152(baseRef) -> addr
|
|
{
|
|
if iszero(lt(0x05, mload(baseRef))) { panic_error_0x32() }
|
|
addr := add(baseRef, 37)
|
|
}
|
|
function memory_array_index_access_bytes_3153(baseRef) -> addr
|
|
{
|
|
if iszero(lt(0x06, mload(baseRef))) { panic_error_0x32() }
|
|
addr := add(baseRef, 38)
|
|
}
|
|
function memory_array_index_access_bytes(baseRef) -> addr
|
|
{
|
|
if iszero(lt(0x07, mload(baseRef))) { panic_error_0x32() }
|
|
addr := add(baseRef, 39)
|
|
}
|
|
function panic_error_0x11()
|
|
{
|
|
mstore(0, shl(224, 0x4e487b71))
|
|
mstore(4, 0x11)
|
|
revert(0, 0x24)
|
|
}
|
|
function panic_error_0x32()
|
|
{
|
|
mstore(0, shl(224, 0x4e487b71))
|
|
mstore(4, 0x32)
|
|
revert(0, 0x24)
|
|
}
|
|
function panic_error_0x41()
|
|
{
|
|
mstore(0, shl(224, 0x4e487b71))
|
|
mstore(4, 0x41)
|
|
revert(0, 0x24)
|
|
}
|
|
function require_helper_stringliteral_122a(condition)
|
|
{
|
|
if iszero(condition)
|
|
{
|
|
let memPtr := mload(64)
|
|
mstore(memPtr, shl(229, 4594637))
|
|
mstore(add(memPtr, 4), 32)
|
|
mstore(add(memPtr, 36), 33)
|
|
mstore(add(memPtr, 68), "DepositContract: merkle tree ful")
|
|
mstore(add(memPtr, 100), "l")
|
|
revert(memPtr, 132)
|
|
}
|
|
}
|
|
function require_helper_stringliteral_18a6(condition)
|
|
{
|
|
if iszero(condition)
|
|
{
|
|
let memPtr := mload(64)
|
|
mstore(memPtr, shl(229, 4594637))
|
|
mstore(add(memPtr, 4), 32)
|
|
mstore(add(memPtr, 36), 84)
|
|
mstore(add(memPtr, 68), "DepositContract: reconstructed D")
|
|
mstore(add(memPtr, 100), "epositData does not match suppli")
|
|
mstore(add(memPtr, 132), "ed deposit_data_root")
|
|
revert(memPtr, 164)
|
|
}
|
|
}
|
|
function require_helper_stringliteral(condition)
|
|
{
|
|
if iszero(condition)
|
|
{
|
|
let memPtr := mload(64)
|
|
mstore(memPtr, shl(229, 4594637))
|
|
mstore(add(memPtr, 4), 32)
|
|
mstore(add(memPtr, 36), 54)
|
|
mstore(add(memPtr, 68), "DepositContract: invalid withdra")
|
|
mstore(add(memPtr, 100), "wal_credentials length")
|
|
revert(memPtr, 132)
|
|
}
|
|
}
|
|
function require_helper_stringliteral_7db0(condition)
|
|
{
|
|
if iszero(condition)
|
|
{
|
|
let memPtr := mload(64)
|
|
mstore(memPtr, shl(229, 4594637))
|
|
mstore(add(memPtr, 4), 32)
|
|
mstore(add(memPtr, 36), 51)
|
|
mstore(add(memPtr, 68), "DepositContract: deposit value n")
|
|
mstore(add(memPtr, 100), "ot multiple of gwei")
|
|
revert(memPtr, 132)
|
|
}
|
|
}
|
|
function require_helper_stringliteral_c3b5(condition)
|
|
{
|
|
if iszero(condition)
|
|
{
|
|
let memPtr := mload(64)
|
|
mstore(memPtr, shl(229, 4594637))
|
|
mstore(add(memPtr, 4), 32)
|
|
mstore(add(memPtr, 36), 38)
|
|
mstore(add(memPtr, 68), "DepositContract: invalid pubkey ")
|
|
mstore(add(memPtr, 100), "length")
|
|
revert(memPtr, 132)
|
|
}
|
|
}
|
|
function require_helper_stringliteral_c445(condition)
|
|
{
|
|
if iszero(condition)
|
|
{
|
|
let memPtr := mload(64)
|
|
mstore(memPtr, shl(229, 4594637))
|
|
mstore(add(memPtr, 4), 32)
|
|
mstore(add(memPtr, 36), 39)
|
|
mstore(add(memPtr, 68), "DepositContract: deposit value t")
|
|
mstore(add(memPtr, 100), "oo high")
|
|
revert(memPtr, 132)
|
|
}
|
|
}
|
|
function require_helper_stringliteral_d4d9(condition)
|
|
{
|
|
if iszero(condition)
|
|
{
|
|
let memPtr := mload(64)
|
|
mstore(memPtr, shl(229, 4594637))
|
|
mstore(add(memPtr, 4), 32)
|
|
mstore(add(memPtr, 36), 38)
|
|
mstore(add(memPtr, 68), "DepositContract: deposit value t")
|
|
mstore(add(memPtr, 100), "oo low")
|
|
revert(memPtr, 132)
|
|
}
|
|
}
|
|
function require_helper_stringliteral_e15d(condition)
|
|
{
|
|
if iszero(condition)
|
|
{
|
|
let memPtr := mload(64)
|
|
mstore(memPtr, shl(229, 4594637))
|
|
mstore(add(memPtr, 4), 32)
|
|
mstore(add(memPtr, 36), 41)
|
|
mstore(add(memPtr, 68), "DepositContract: invalid signatu")
|
|
mstore(add(memPtr, 100), "re length")
|
|
revert(memPtr, 132)
|
|
}
|
|
}
|
|
function revert_forward()
|
|
{
|
|
let pos := mload(64)
|
|
returndatacopy(pos, 0, returndatasize())
|
|
revert(pos, returndatasize())
|
|
}
|
|
function storage_array_index_access_bytes_3138(index) -> slot, offset
|
|
{
|
|
if iszero(lt(index, 0x20)) { panic_error_0x32() }
|
|
slot := index
|
|
offset := 0x00
|
|
}
|
|
function storage_array_index_access_bytes_3142(index) -> slot, offset
|
|
{
|
|
if iszero(lt(index, 0x20)) { panic_error_0x32() }
|
|
slot := add(0x21, index)
|
|
offset := 0
|
|
}
|
|
function storage_array_index_access_bytes(index) -> slot, offset
|
|
{
|
|
if iszero(lt(index, 0x20)) { panic_error_0x32() }
|
|
slot := index
|
|
offset := 0
|
|
}
|
|
function update_storage_value_offsett_uint256_to_uint256(value)
|
|
{ sstore(0x20, value) }
|
|
function update_storage_value_bytes32_to_bytes32(slot, offset, value)
|
|
{
|
|
let _1 := sload(slot)
|
|
let shiftBits := shl(3, offset)
|
|
let mask := shl(shiftBits, not(0))
|
|
sstore(slot, or(and(_1, not(mask)), and(shl(shiftBits, value), mask)))
|
|
}
|
|
}
|
|
}
|
|
// ----
|