Extended packing and extracting library for value types (#5056)
Co-authored-by: ernestognw <ernestognw@gmail.com>
This commit is contained in:
Hadrien Croubois
GitHub
@ -1,40 +1,845 @@
|
||||
// SPDX-License-Identifier: MIT
|
||||
// This file was procedurally generated from scripts/generate/templates/Packing.js.
|
||||
|
||||
pragma solidity ^0.8.20;
|
||||
|
||||
/**
|
||||
* @dev Helper library packing and unpacking multiple values into bytes32
|
||||
* @dev Helper library packing and unpacking multiple values into bytesXX.
|
||||
*
|
||||
* Example usage:
|
||||
*
|
||||
* ```solidity
|
||||
* library MyPacker {
|
||||
* type MyType is bytes32;
|
||||
*
|
||||
* function _pack(address account, bytes4 selector, uint64 period) external pure returns (MyType) {
|
||||
* bytes12 subpack = Packing.pack_4_8(selector, bytes8(period));
|
||||
* bytes32 pack = Packing.pack_20_12(bytes20(account), subpack);
|
||||
* return MyType.wrap(pack);
|
||||
* }
|
||||
*
|
||||
* function _unpack(MyType self) external pure returns (address, bytes4, uint64) {
|
||||
* bytes32 pack = MyType.unwrap(self);
|
||||
* return (
|
||||
* address(Packing.extract_32_20(pack, 0)),
|
||||
* Packing.extract_32_4(pack, 20),
|
||||
* uint64(Packing.extract_32_8(pack, 24))
|
||||
* );
|
||||
* }
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
// solhint-disable func-name-mixedcase
|
||||
library Packing {
|
||||
type Uint128x2 is bytes32;
|
||||
error OutOfRangeAccess();
|
||||
|
||||
/// @dev Cast a bytes32 into a Uint128x2
|
||||
function asUint128x2(bytes32 self) internal pure returns (Uint128x2) {
|
||||
return Uint128x2.wrap(self);
|
||||
function pack_1_1(bytes1 left, bytes1 right) internal pure returns (bytes2 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(8, right))
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev Cast a Uint128x2 into a bytes32
|
||||
function asBytes32(Uint128x2 self) internal pure returns (bytes32) {
|
||||
return Uint128x2.unwrap(self);
|
||||
function pack_2_2(bytes2 left, bytes2 right) internal pure returns (bytes4 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(16, right))
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev Pack two uint128 into a Uint128x2
|
||||
function pack(uint128 first128, uint128 second128) internal pure returns (Uint128x2) {
|
||||
return Uint128x2.wrap(bytes32(bytes16(first128)) | bytes32(uint256(second128)));
|
||||
function pack_4_4(bytes4 left, bytes4 right) internal pure returns (bytes8 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(32, right))
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev Split a Uint128x2 into two uint128
|
||||
function split(Uint128x2 self) internal pure returns (uint128, uint128) {
|
||||
return (first(self), second(self));
|
||||
function pack_4_8(bytes4 left, bytes8 right) internal pure returns (bytes12 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(32, right))
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev Get the first element of a Uint128x2 counting from higher to lower bytes
|
||||
function first(Uint128x2 self) internal pure returns (uint128) {
|
||||
return uint128(bytes16(Uint128x2.unwrap(self)));
|
||||
function pack_4_12(bytes4 left, bytes12 right) internal pure returns (bytes16 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(32, right))
|
||||
}
|
||||
}
|
||||
|
||||
/// @dev Get the second element of a Uint128x2 counting from higher to lower bytes
|
||||
function second(Uint128x2 self) internal pure returns (uint128) {
|
||||
return uint128(uint256(Uint128x2.unwrap(self)));
|
||||
function pack_4_16(bytes4 left, bytes16 right) internal pure returns (bytes20 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(32, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_4_20(bytes4 left, bytes20 right) internal pure returns (bytes24 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(32, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_4_24(bytes4 left, bytes24 right) internal pure returns (bytes28 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(32, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_4_28(bytes4 left, bytes28 right) internal pure returns (bytes32 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(32, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_8_4(bytes8 left, bytes4 right) internal pure returns (bytes12 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(64, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_8_8(bytes8 left, bytes8 right) internal pure returns (bytes16 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(64, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_8_12(bytes8 left, bytes12 right) internal pure returns (bytes20 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(64, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_8_16(bytes8 left, bytes16 right) internal pure returns (bytes24 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(64, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_8_20(bytes8 left, bytes20 right) internal pure returns (bytes28 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(64, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_8_24(bytes8 left, bytes24 right) internal pure returns (bytes32 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(64, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_12_4(bytes12 left, bytes4 right) internal pure returns (bytes16 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(96, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_12_8(bytes12 left, bytes8 right) internal pure returns (bytes20 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(96, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_12_12(bytes12 left, bytes12 right) internal pure returns (bytes24 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(96, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_12_16(bytes12 left, bytes16 right) internal pure returns (bytes28 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(96, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_12_20(bytes12 left, bytes20 right) internal pure returns (bytes32 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(96, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_16_4(bytes16 left, bytes4 right) internal pure returns (bytes20 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(128, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_16_8(bytes16 left, bytes8 right) internal pure returns (bytes24 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(128, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_16_12(bytes16 left, bytes12 right) internal pure returns (bytes28 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(128, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_16_16(bytes16 left, bytes16 right) internal pure returns (bytes32 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(128, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_20_4(bytes20 left, bytes4 right) internal pure returns (bytes24 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(160, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_20_8(bytes20 left, bytes8 right) internal pure returns (bytes28 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(160, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_20_12(bytes20 left, bytes12 right) internal pure returns (bytes32 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(160, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_24_4(bytes24 left, bytes4 right) internal pure returns (bytes28 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(192, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_24_8(bytes24 left, bytes8 right) internal pure returns (bytes32 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(192, right))
|
||||
}
|
||||
}
|
||||
|
||||
function pack_28_4(bytes28 left, bytes4 right) internal pure returns (bytes32 result) {
|
||||
assembly ("memory-safe") {
|
||||
result := or(left, shr(224, right))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_2_1(bytes2 self, uint8 offset) internal pure returns (bytes1 result) {
|
||||
if (offset > 1) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(248, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_2_1(bytes2 self, bytes1 value, uint8 offset) internal pure returns (bytes2 result) {
|
||||
bytes1 oldValue = extract_2_1(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_4_1(bytes4 self, uint8 offset) internal pure returns (bytes1 result) {
|
||||
if (offset > 3) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(248, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_4_1(bytes4 self, bytes1 value, uint8 offset) internal pure returns (bytes4 result) {
|
||||
bytes1 oldValue = extract_4_1(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_4_2(bytes4 self, uint8 offset) internal pure returns (bytes2 result) {
|
||||
if (offset > 2) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(240, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_4_2(bytes4 self, bytes2 value, uint8 offset) internal pure returns (bytes4 result) {
|
||||
bytes2 oldValue = extract_4_2(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_8_1(bytes8 self, uint8 offset) internal pure returns (bytes1 result) {
|
||||
if (offset > 7) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(248, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_8_1(bytes8 self, bytes1 value, uint8 offset) internal pure returns (bytes8 result) {
|
||||
bytes1 oldValue = extract_8_1(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_8_2(bytes8 self, uint8 offset) internal pure returns (bytes2 result) {
|
||||
if (offset > 6) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(240, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_8_2(bytes8 self, bytes2 value, uint8 offset) internal pure returns (bytes8 result) {
|
||||
bytes2 oldValue = extract_8_2(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_8_4(bytes8 self, uint8 offset) internal pure returns (bytes4 result) {
|
||||
if (offset > 4) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(224, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_8_4(bytes8 self, bytes4 value, uint8 offset) internal pure returns (bytes8 result) {
|
||||
bytes4 oldValue = extract_8_4(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_12_1(bytes12 self, uint8 offset) internal pure returns (bytes1 result) {
|
||||
if (offset > 11) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(248, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_12_1(bytes12 self, bytes1 value, uint8 offset) internal pure returns (bytes12 result) {
|
||||
bytes1 oldValue = extract_12_1(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_12_2(bytes12 self, uint8 offset) internal pure returns (bytes2 result) {
|
||||
if (offset > 10) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(240, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_12_2(bytes12 self, bytes2 value, uint8 offset) internal pure returns (bytes12 result) {
|
||||
bytes2 oldValue = extract_12_2(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_12_4(bytes12 self, uint8 offset) internal pure returns (bytes4 result) {
|
||||
if (offset > 8) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(224, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_12_4(bytes12 self, bytes4 value, uint8 offset) internal pure returns (bytes12 result) {
|
||||
bytes4 oldValue = extract_12_4(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_12_8(bytes12 self, uint8 offset) internal pure returns (bytes8 result) {
|
||||
if (offset > 4) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(192, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_12_8(bytes12 self, bytes8 value, uint8 offset) internal pure returns (bytes12 result) {
|
||||
bytes8 oldValue = extract_12_8(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_16_1(bytes16 self, uint8 offset) internal pure returns (bytes1 result) {
|
||||
if (offset > 15) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(248, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_16_1(bytes16 self, bytes1 value, uint8 offset) internal pure returns (bytes16 result) {
|
||||
bytes1 oldValue = extract_16_1(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_16_2(bytes16 self, uint8 offset) internal pure returns (bytes2 result) {
|
||||
if (offset > 14) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(240, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_16_2(bytes16 self, bytes2 value, uint8 offset) internal pure returns (bytes16 result) {
|
||||
bytes2 oldValue = extract_16_2(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_16_4(bytes16 self, uint8 offset) internal pure returns (bytes4 result) {
|
||||
if (offset > 12) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(224, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_16_4(bytes16 self, bytes4 value, uint8 offset) internal pure returns (bytes16 result) {
|
||||
bytes4 oldValue = extract_16_4(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_16_8(bytes16 self, uint8 offset) internal pure returns (bytes8 result) {
|
||||
if (offset > 8) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(192, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_16_8(bytes16 self, bytes8 value, uint8 offset) internal pure returns (bytes16 result) {
|
||||
bytes8 oldValue = extract_16_8(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_16_12(bytes16 self, uint8 offset) internal pure returns (bytes12 result) {
|
||||
if (offset > 4) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(160, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_16_12(bytes16 self, bytes12 value, uint8 offset) internal pure returns (bytes16 result) {
|
||||
bytes12 oldValue = extract_16_12(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_20_1(bytes20 self, uint8 offset) internal pure returns (bytes1 result) {
|
||||
if (offset > 19) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(248, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_20_1(bytes20 self, bytes1 value, uint8 offset) internal pure returns (bytes20 result) {
|
||||
bytes1 oldValue = extract_20_1(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_20_2(bytes20 self, uint8 offset) internal pure returns (bytes2 result) {
|
||||
if (offset > 18) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(240, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_20_2(bytes20 self, bytes2 value, uint8 offset) internal pure returns (bytes20 result) {
|
||||
bytes2 oldValue = extract_20_2(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_20_4(bytes20 self, uint8 offset) internal pure returns (bytes4 result) {
|
||||
if (offset > 16) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(224, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_20_4(bytes20 self, bytes4 value, uint8 offset) internal pure returns (bytes20 result) {
|
||||
bytes4 oldValue = extract_20_4(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_20_8(bytes20 self, uint8 offset) internal pure returns (bytes8 result) {
|
||||
if (offset > 12) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(192, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_20_8(bytes20 self, bytes8 value, uint8 offset) internal pure returns (bytes20 result) {
|
||||
bytes8 oldValue = extract_20_8(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_20_12(bytes20 self, uint8 offset) internal pure returns (bytes12 result) {
|
||||
if (offset > 8) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(160, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_20_12(bytes20 self, bytes12 value, uint8 offset) internal pure returns (bytes20 result) {
|
||||
bytes12 oldValue = extract_20_12(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_20_16(bytes20 self, uint8 offset) internal pure returns (bytes16 result) {
|
||||
if (offset > 4) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(128, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_20_16(bytes20 self, bytes16 value, uint8 offset) internal pure returns (bytes20 result) {
|
||||
bytes16 oldValue = extract_20_16(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_24_1(bytes24 self, uint8 offset) internal pure returns (bytes1 result) {
|
||||
if (offset > 23) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(248, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_24_1(bytes24 self, bytes1 value, uint8 offset) internal pure returns (bytes24 result) {
|
||||
bytes1 oldValue = extract_24_1(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_24_2(bytes24 self, uint8 offset) internal pure returns (bytes2 result) {
|
||||
if (offset > 22) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(240, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_24_2(bytes24 self, bytes2 value, uint8 offset) internal pure returns (bytes24 result) {
|
||||
bytes2 oldValue = extract_24_2(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_24_4(bytes24 self, uint8 offset) internal pure returns (bytes4 result) {
|
||||
if (offset > 20) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(224, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_24_4(bytes24 self, bytes4 value, uint8 offset) internal pure returns (bytes24 result) {
|
||||
bytes4 oldValue = extract_24_4(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_24_8(bytes24 self, uint8 offset) internal pure returns (bytes8 result) {
|
||||
if (offset > 16) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(192, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_24_8(bytes24 self, bytes8 value, uint8 offset) internal pure returns (bytes24 result) {
|
||||
bytes8 oldValue = extract_24_8(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_24_12(bytes24 self, uint8 offset) internal pure returns (bytes12 result) {
|
||||
if (offset > 12) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(160, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_24_12(bytes24 self, bytes12 value, uint8 offset) internal pure returns (bytes24 result) {
|
||||
bytes12 oldValue = extract_24_12(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_24_16(bytes24 self, uint8 offset) internal pure returns (bytes16 result) {
|
||||
if (offset > 8) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(128, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_24_16(bytes24 self, bytes16 value, uint8 offset) internal pure returns (bytes24 result) {
|
||||
bytes16 oldValue = extract_24_16(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_24_20(bytes24 self, uint8 offset) internal pure returns (bytes20 result) {
|
||||
if (offset > 4) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(96, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_24_20(bytes24 self, bytes20 value, uint8 offset) internal pure returns (bytes24 result) {
|
||||
bytes20 oldValue = extract_24_20(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_28_1(bytes28 self, uint8 offset) internal pure returns (bytes1 result) {
|
||||
if (offset > 27) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(248, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_28_1(bytes28 self, bytes1 value, uint8 offset) internal pure returns (bytes28 result) {
|
||||
bytes1 oldValue = extract_28_1(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_28_2(bytes28 self, uint8 offset) internal pure returns (bytes2 result) {
|
||||
if (offset > 26) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(240, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_28_2(bytes28 self, bytes2 value, uint8 offset) internal pure returns (bytes28 result) {
|
||||
bytes2 oldValue = extract_28_2(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_28_4(bytes28 self, uint8 offset) internal pure returns (bytes4 result) {
|
||||
if (offset > 24) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(224, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_28_4(bytes28 self, bytes4 value, uint8 offset) internal pure returns (bytes28 result) {
|
||||
bytes4 oldValue = extract_28_4(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_28_8(bytes28 self, uint8 offset) internal pure returns (bytes8 result) {
|
||||
if (offset > 20) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(192, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_28_8(bytes28 self, bytes8 value, uint8 offset) internal pure returns (bytes28 result) {
|
||||
bytes8 oldValue = extract_28_8(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_28_12(bytes28 self, uint8 offset) internal pure returns (bytes12 result) {
|
||||
if (offset > 16) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(160, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_28_12(bytes28 self, bytes12 value, uint8 offset) internal pure returns (bytes28 result) {
|
||||
bytes12 oldValue = extract_28_12(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_28_16(bytes28 self, uint8 offset) internal pure returns (bytes16 result) {
|
||||
if (offset > 12) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(128, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_28_16(bytes28 self, bytes16 value, uint8 offset) internal pure returns (bytes28 result) {
|
||||
bytes16 oldValue = extract_28_16(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_28_20(bytes28 self, uint8 offset) internal pure returns (bytes20 result) {
|
||||
if (offset > 8) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(96, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_28_20(bytes28 self, bytes20 value, uint8 offset) internal pure returns (bytes28 result) {
|
||||
bytes20 oldValue = extract_28_20(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_28_24(bytes28 self, uint8 offset) internal pure returns (bytes24 result) {
|
||||
if (offset > 4) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(64, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_28_24(bytes28 self, bytes24 value, uint8 offset) internal pure returns (bytes28 result) {
|
||||
bytes24 oldValue = extract_28_24(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_32_1(bytes32 self, uint8 offset) internal pure returns (bytes1 result) {
|
||||
if (offset > 31) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(248, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_32_1(bytes32 self, bytes1 value, uint8 offset) internal pure returns (bytes32 result) {
|
||||
bytes1 oldValue = extract_32_1(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_32_2(bytes32 self, uint8 offset) internal pure returns (bytes2 result) {
|
||||
if (offset > 30) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(240, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_32_2(bytes32 self, bytes2 value, uint8 offset) internal pure returns (bytes32 result) {
|
||||
bytes2 oldValue = extract_32_2(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_32_4(bytes32 self, uint8 offset) internal pure returns (bytes4 result) {
|
||||
if (offset > 28) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(224, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_32_4(bytes32 self, bytes4 value, uint8 offset) internal pure returns (bytes32 result) {
|
||||
bytes4 oldValue = extract_32_4(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_32_8(bytes32 self, uint8 offset) internal pure returns (bytes8 result) {
|
||||
if (offset > 24) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(192, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_32_8(bytes32 self, bytes8 value, uint8 offset) internal pure returns (bytes32 result) {
|
||||
bytes8 oldValue = extract_32_8(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_32_12(bytes32 self, uint8 offset) internal pure returns (bytes12 result) {
|
||||
if (offset > 20) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(160, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_32_12(bytes32 self, bytes12 value, uint8 offset) internal pure returns (bytes32 result) {
|
||||
bytes12 oldValue = extract_32_12(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_32_16(bytes32 self, uint8 offset) internal pure returns (bytes16 result) {
|
||||
if (offset > 16) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(128, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_32_16(bytes32 self, bytes16 value, uint8 offset) internal pure returns (bytes32 result) {
|
||||
bytes16 oldValue = extract_32_16(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_32_20(bytes32 self, uint8 offset) internal pure returns (bytes20 result) {
|
||||
if (offset > 12) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(96, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_32_20(bytes32 self, bytes20 value, uint8 offset) internal pure returns (bytes32 result) {
|
||||
bytes20 oldValue = extract_32_20(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_32_24(bytes32 self, uint8 offset) internal pure returns (bytes24 result) {
|
||||
if (offset > 8) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(64, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_32_24(bytes32 self, bytes24 value, uint8 offset) internal pure returns (bytes32 result) {
|
||||
bytes24 oldValue = extract_32_24(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
|
||||
function extract_32_28(bytes32 self, uint8 offset) internal pure returns (bytes28 result) {
|
||||
if (offset > 4) revert OutOfRangeAccess();
|
||||
assembly ("memory-safe") {
|
||||
result := and(shl(mul(8, offset), self), shl(32, not(0)))
|
||||
}
|
||||
}
|
||||
|
||||
function replace_32_28(bytes32 self, bytes28 value, uint8 offset) internal pure returns (bytes32 result) {
|
||||
bytes28 oldValue = extract_32_28(self, offset);
|
||||
assembly ("memory-safe") {
|
||||
result := xor(self, shr(mul(8, offset), xor(oldValue, value)))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user