Overview
TokenID
11565
Total Transfers
-
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Loading...
Loading
Loading...
Loading
Loading...
Loading
This contract may be a proxy contract. Click on More Options and select Is this a proxy? to confirm and enable the "Read as Proxy" & "Write as Proxy" tabs.
Contract Source Code Verified (Exact Match)
Contract Name:
MigrationNFT
Compiler Version
v0.8.23+commit.f704f362
ZkSolc Version
v1.4.1
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: BSD-3-Clause-Clear
pragma solidity 0.8.23;
import {ERC721} from "openzeppelin-contracts/contracts/token/ERC721/ERC721.sol";
import {Strings} from "openzeppelin-contracts/contracts/utils/Strings.sol";
import {NODLMigration} from "./NODLMigration.sol";
contract MigrationNFT is ERC721 {
uint256 public nextTokenId;
uint256 public immutable maxHolders;
NODLMigration public immutable migration;
uint256[] public levels;
string[] public levelToTokenURI;
/**
* @notice Mapping of token IDs to the levels they represent denominated from 1 (0 means token does not exists)
*/
mapping(uint256 => uint256) public tokenIdToNextLevel;
/**
* @notice Mapping of holders to the highest level they reached (denominated from 1)
*/
mapping(address => uint256) public holderToNextLevel;
uint256 public individualHolders;
mapping(bytes32 => bool) public claimed;
error UnsortedLevelsList();
error UnequalLengths();
error TooManyHolders();
error AlreadyClaimed();
error NoLevelUp();
error ProposalDoesNotExist();
error NotExecuted();
error SoulboundIsNotTransferrable();
/**
* @notice Construct a new MigrationNFT contract
* @param _migration the NODLMigration contract to bridge tokens
* @param _maxHolders the maximum number of holders for the NFTs
* @param _levels an array representing the different reward levels expressed in
* the amount of tokens needed to get the NFT
* @param _levelToTokenURI an array of URIs to the metadata of the NFTs
*/
constructor(
NODLMigration _migration,
uint256 _maxHolders,
uint256[] memory _levels,
string[] memory _levelToTokenURI
) ERC721("OG ZK NODL", "OG_ZK_NODL") {
migration = _migration;
maxHolders = _maxHolders;
levels = _levels;
levelToTokenURI = _levelToTokenURI;
if (_levels.length != _levelToTokenURI.length) {
revert UnequalLengths();
}
for (uint256 i = 1; i < levels.length; i++) {
if (levels[i] <= levels[i - 1]) {
revert UnsortedLevelsList();
}
}
}
/**
* @notice Return the URI of the proper metadata for the given token ID
* @param tokenId the token ID to mint
*/
function tokenURI(uint256 tokenId) public view virtual override(ERC721) returns (string memory) {
_requireOwned(tokenId); // this will also mean that tokenIdToNextLevel is at least 1
uint256 level = tokenIdToNextLevel[tokenId];
return levelToTokenURI[level - 1];
}
/**
* @notice Mint a new NFT for the given user
* @param txHash the transaction hash to bridge
*/
function safeMint(bytes32 txHash) public {
_mustNotHaveBeenClaimed(txHash);
(address target, uint256 amount,,, bool executed) = migration.proposals(txHash);
_mustBeAnExistingProposal(target);
_mustBeExecuted(executed);
bool alreadyHolder = _mustAlreadyBeHolderOrEnougHoldersRemaining(target);
(uint256[] memory levelsToMint, uint256 nbLevelsToMint) = _computeLevelUps(target, amount);
claimed[txHash] = true;
if (!alreadyHolder) {
individualHolders++;
}
for (uint256 i = 0; i < nbLevelsToMint; i++) {
uint256 tokenId = nextTokenId++;
tokenIdToNextLevel[tokenId] = levelsToMint[i] + 1;
holderToNextLevel[target] = levelsToMint[i] + 1;
_safeMint(target, tokenId);
}
}
function _computeLevelUps(address target, uint256 amount)
internal
view
returns (uint256[] memory levelsToMint, uint256 nbLevelsToMint)
{
levelsToMint = new uint256[](levels.length);
nbLevelsToMint = 0;
// We effectively iterate over all the levels the `target` has YET
// to qualify for. This expressively skips levels the `target` has
// already qualified for.
uint256 nextLevel = holderToNextLevel[target];
for (uint256 i = nextLevel; i < levels.length; i++) {
if (amount >= levels[i]) {
levelsToMint[i - nextLevel] = i;
nbLevelsToMint++;
}
}
if (nbLevelsToMint == 0) {
revert NoLevelUp();
}
}
function _mustNotHaveBeenClaimed(bytes32 txHash) internal view {
if (claimed[txHash]) {
revert AlreadyClaimed();
}
}
function _mustBeAnExistingProposal(address target) internal pure {
// the relayers skip any transfers to the 0 address
if (target == address(0)) {
revert ProposalDoesNotExist();
}
}
function _mustBeExecuted(bool executed) internal pure {
if (!executed) {
revert NotExecuted();
}
}
function _mustAlreadyBeHolderOrEnougHoldersRemaining(address target) internal view returns (bool alreadyHolder) {
alreadyHolder = balanceOf(target) > 0;
if (!alreadyHolder && individualHolders == maxHolders) {
revert TooManyHolders();
}
}
function _update(address to, uint256 tokenId, address auth) internal override(ERC721) returns (address) {
address from = _ownerOf(tokenId);
if (from != address(0) && to != address(0)) {
// only burn or mint is allowed for a soulbound token
revert SoulboundIsNotTransferrable();
}
return super._update(to, tokenId, auth);
}
}// SPDX-License-Identifier: GPL-3.0-or-later
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
pragma solidity >=0.5.0;
contract DSTest {
event log (string);
event logs (bytes);
event log_address (address);
event log_bytes32 (bytes32);
event log_int (int);
event log_uint (uint);
event log_bytes (bytes);
event log_string (string);
event log_named_address (string key, address val);
event log_named_bytes32 (string key, bytes32 val);
event log_named_decimal_int (string key, int val, uint decimals);
event log_named_decimal_uint (string key, uint val, uint decimals);
event log_named_int (string key, int val);
event log_named_uint (string key, uint val);
event log_named_bytes (string key, bytes val);
event log_named_string (string key, string val);
bool public IS_TEST = true;
bool private _failed;
address constant HEVM_ADDRESS =
address(bytes20(uint160(uint256(keccak256('hevm cheat code')))));
modifier mayRevert() { _; }
modifier testopts(string memory) { _; }
function failed() public returns (bool) {
if (_failed) {
return _failed;
} else {
bool globalFailed = false;
if (hasHEVMContext()) {
(, bytes memory retdata) = HEVM_ADDRESS.call(
abi.encodePacked(
bytes4(keccak256("load(address,bytes32)")),
abi.encode(HEVM_ADDRESS, bytes32("failed"))
)
);
globalFailed = abi.decode(retdata, (bool));
}
return globalFailed;
}
}
function fail() internal virtual {
if (hasHEVMContext()) {
(bool status, ) = HEVM_ADDRESS.call(
abi.encodePacked(
bytes4(keccak256("store(address,bytes32,bytes32)")),
abi.encode(HEVM_ADDRESS, bytes32("failed"), bytes32(uint256(0x01)))
)
);
status; // Silence compiler warnings
}
_failed = true;
}
function hasHEVMContext() internal view returns (bool) {
uint256 hevmCodeSize = 0;
assembly {
hevmCodeSize := extcodesize(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D)
}
return hevmCodeSize > 0;
}
modifier logs_gas() {
uint startGas = gasleft();
_;
uint endGas = gasleft();
emit log_named_uint("gas", startGas - endGas);
}
function assertTrue(bool condition) internal {
if (!condition) {
emit log("Error: Assertion Failed");
fail();
}
}
function assertTrue(bool condition, string memory err) internal {
if (!condition) {
emit log_named_string("Error", err);
assertTrue(condition);
}
}
function assertEq(address a, address b) internal {
if (a != b) {
emit log("Error: a == b not satisfied [address]");
emit log_named_address(" Left", a);
emit log_named_address(" Right", b);
fail();
}
}
function assertEq(address a, address b, string memory err) internal {
if (a != b) {
emit log_named_string ("Error", err);
assertEq(a, b);
}
}
function assertEq(bytes32 a, bytes32 b) internal {
if (a != b) {
emit log("Error: a == b not satisfied [bytes32]");
emit log_named_bytes32(" Left", a);
emit log_named_bytes32(" Right", b);
fail();
}
}
function assertEq(bytes32 a, bytes32 b, string memory err) internal {
if (a != b) {
emit log_named_string ("Error", err);
assertEq(a, b);
}
}
function assertEq32(bytes32 a, bytes32 b) internal {
assertEq(a, b);
}
function assertEq32(bytes32 a, bytes32 b, string memory err) internal {
assertEq(a, b, err);
}
function assertEq(int a, int b) internal {
if (a != b) {
emit log("Error: a == b not satisfied [int]");
emit log_named_int(" Left", a);
emit log_named_int(" Right", b);
fail();
}
}
function assertEq(int a, int b, string memory err) internal {
if (a != b) {
emit log_named_string("Error", err);
assertEq(a, b);
}
}
function assertEq(uint a, uint b) internal {
if (a != b) {
emit log("Error: a == b not satisfied [uint]");
emit log_named_uint(" Left", a);
emit log_named_uint(" Right", b);
fail();
}
}
function assertEq(uint a, uint b, string memory err) internal {
if (a != b) {
emit log_named_string("Error", err);
assertEq(a, b);
}
}
function assertEqDecimal(int a, int b, uint decimals) internal {
if (a != b) {
emit log("Error: a == b not satisfied [decimal int]");
emit log_named_decimal_int(" Left", a, decimals);
emit log_named_decimal_int(" Right", b, decimals);
fail();
}
}
function assertEqDecimal(int a, int b, uint decimals, string memory err) internal {
if (a != b) {
emit log_named_string("Error", err);
assertEqDecimal(a, b, decimals);
}
}
function assertEqDecimal(uint a, uint b, uint decimals) internal {
if (a != b) {
emit log("Error: a == b not satisfied [decimal uint]");
emit log_named_decimal_uint(" Left", a, decimals);
emit log_named_decimal_uint(" Right", b, decimals);
fail();
}
}
function assertEqDecimal(uint a, uint b, uint decimals, string memory err) internal {
if (a != b) {
emit log_named_string("Error", err);
assertEqDecimal(a, b, decimals);
}
}
function assertNotEq(address a, address b) internal {
if (a == b) {
emit log("Error: a != b not satisfied [address]");
emit log_named_address(" Left", a);
emit log_named_address(" Right", b);
fail();
}
}
function assertNotEq(address a, address b, string memory err) internal {
if (a == b) {
emit log_named_string ("Error", err);
assertNotEq(a, b);
}
}
function assertNotEq(bytes32 a, bytes32 b) internal {
if (a == b) {
emit log("Error: a != b not satisfied [bytes32]");
emit log_named_bytes32(" Left", a);
emit log_named_bytes32(" Right", b);
fail();
}
}
function assertNotEq(bytes32 a, bytes32 b, string memory err) internal {
if (a == b) {
emit log_named_string ("Error", err);
assertNotEq(a, b);
}
}
function assertNotEq32(bytes32 a, bytes32 b) internal {
assertNotEq(a, b);
}
function assertNotEq32(bytes32 a, bytes32 b, string memory err) internal {
assertNotEq(a, b, err);
}
function assertNotEq(int a, int b) internal {
if (a == b) {
emit log("Error: a != b not satisfied [int]");
emit log_named_int(" Left", a);
emit log_named_int(" Right", b);
fail();
}
}
function assertNotEq(int a, int b, string memory err) internal {
if (a == b) {
emit log_named_string("Error", err);
assertNotEq(a, b);
}
}
function assertNotEq(uint a, uint b) internal {
if (a == b) {
emit log("Error: a != b not satisfied [uint]");
emit log_named_uint(" Left", a);
emit log_named_uint(" Right", b);
fail();
}
}
function assertNotEq(uint a, uint b, string memory err) internal {
if (a == b) {
emit log_named_string("Error", err);
assertNotEq(a, b);
}
}
function assertNotEqDecimal(int a, int b, uint decimals) internal {
if (a == b) {
emit log("Error: a != b not satisfied [decimal int]");
emit log_named_decimal_int(" Left", a, decimals);
emit log_named_decimal_int(" Right", b, decimals);
fail();
}
}
function assertNotEqDecimal(int a, int b, uint decimals, string memory err) internal {
if (a == b) {
emit log_named_string("Error", err);
assertNotEqDecimal(a, b, decimals);
}
}
function assertNotEqDecimal(uint a, uint b, uint decimals) internal {
if (a == b) {
emit log("Error: a != b not satisfied [decimal uint]");
emit log_named_decimal_uint(" Left", a, decimals);
emit log_named_decimal_uint(" Right", b, decimals);
fail();
}
}
function assertNotEqDecimal(uint a, uint b, uint decimals, string memory err) internal {
if (a == b) {
emit log_named_string("Error", err);
assertNotEqDecimal(a, b, decimals);
}
}
function assertGt(uint a, uint b) internal {
if (a <= b) {
emit log("Error: a > b not satisfied [uint]");
emit log_named_uint(" Value a", a);
emit log_named_uint(" Value b", b);
fail();
}
}
function assertGt(uint a, uint b, string memory err) internal {
if (a <= b) {
emit log_named_string("Error", err);
assertGt(a, b);
}
}
function assertGt(int a, int b) internal {
if (a <= b) {
emit log("Error: a > b not satisfied [int]");
emit log_named_int(" Value a", a);
emit log_named_int(" Value b", b);
fail();
}
}
function assertGt(int a, int b, string memory err) internal {
if (a <= b) {
emit log_named_string("Error", err);
assertGt(a, b);
}
}
function assertGtDecimal(int a, int b, uint decimals) internal {
if (a <= b) {
emit log("Error: a > b not satisfied [decimal int]");
emit log_named_decimal_int(" Value a", a, decimals);
emit log_named_decimal_int(" Value b", b, decimals);
fail();
}
}
function assertGtDecimal(int a, int b, uint decimals, string memory err) internal {
if (a <= b) {
emit log_named_string("Error", err);
assertGtDecimal(a, b, decimals);
}
}
function assertGtDecimal(uint a, uint b, uint decimals) internal {
if (a <= b) {
emit log("Error: a > b not satisfied [decimal uint]");
emit log_named_decimal_uint(" Value a", a, decimals);
emit log_named_decimal_uint(" Value b", b, decimals);
fail();
}
}
function assertGtDecimal(uint a, uint b, uint decimals, string memory err) internal {
if (a <= b) {
emit log_named_string("Error", err);
assertGtDecimal(a, b, decimals);
}
}
function assertGe(uint a, uint b) internal {
if (a < b) {
emit log("Error: a >= b not satisfied [uint]");
emit log_named_uint(" Value a", a);
emit log_named_uint(" Value b", b);
fail();
}
}
function assertGe(uint a, uint b, string memory err) internal {
if (a < b) {
emit log_named_string("Error", err);
assertGe(a, b);
}
}
function assertGe(int a, int b) internal {
if (a < b) {
emit log("Error: a >= b not satisfied [int]");
emit log_named_int(" Value a", a);
emit log_named_int(" Value b", b);
fail();
}
}
function assertGe(int a, int b, string memory err) internal {
if (a < b) {
emit log_named_string("Error", err);
assertGe(a, b);
}
}
function assertGeDecimal(int a, int b, uint decimals) internal {
if (a < b) {
emit log("Error: a >= b not satisfied [decimal int]");
emit log_named_decimal_int(" Value a", a, decimals);
emit log_named_decimal_int(" Value b", b, decimals);
fail();
}
}
function assertGeDecimal(int a, int b, uint decimals, string memory err) internal {
if (a < b) {
emit log_named_string("Error", err);
assertGeDecimal(a, b, decimals);
}
}
function assertGeDecimal(uint a, uint b, uint decimals) internal {
if (a < b) {
emit log("Error: a >= b not satisfied [decimal uint]");
emit log_named_decimal_uint(" Value a", a, decimals);
emit log_named_decimal_uint(" Value b", b, decimals);
fail();
}
}
function assertGeDecimal(uint a, uint b, uint decimals, string memory err) internal {
if (a < b) {
emit log_named_string("Error", err);
assertGeDecimal(a, b, decimals);
}
}
function assertLt(uint a, uint b) internal {
if (a >= b) {
emit log("Error: a < b not satisfied [uint]");
emit log_named_uint(" Value a", a);
emit log_named_uint(" Value b", b);
fail();
}
}
function assertLt(uint a, uint b, string memory err) internal {
if (a >= b) {
emit log_named_string("Error", err);
assertLt(a, b);
}
}
function assertLt(int a, int b) internal {
if (a >= b) {
emit log("Error: a < b not satisfied [int]");
emit log_named_int(" Value a", a);
emit log_named_int(" Value b", b);
fail();
}
}
function assertLt(int a, int b, string memory err) internal {
if (a >= b) {
emit log_named_string("Error", err);
assertLt(a, b);
}
}
function assertLtDecimal(int a, int b, uint decimals) internal {
if (a >= b) {
emit log("Error: a < b not satisfied [decimal int]");
emit log_named_decimal_int(" Value a", a, decimals);
emit log_named_decimal_int(" Value b", b, decimals);
fail();
}
}
function assertLtDecimal(int a, int b, uint decimals, string memory err) internal {
if (a >= b) {
emit log_named_string("Error", err);
assertLtDecimal(a, b, decimals);
}
}
function assertLtDecimal(uint a, uint b, uint decimals) internal {
if (a >= b) {
emit log("Error: a < b not satisfied [decimal uint]");
emit log_named_decimal_uint(" Value a", a, decimals);
emit log_named_decimal_uint(" Value b", b, decimals);
fail();
}
}
function assertLtDecimal(uint a, uint b, uint decimals, string memory err) internal {
if (a >= b) {
emit log_named_string("Error", err);
assertLtDecimal(a, b, decimals);
}
}
function assertLe(uint a, uint b) internal {
if (a > b) {
emit log("Error: a <= b not satisfied [uint]");
emit log_named_uint(" Value a", a);
emit log_named_uint(" Value b", b);
fail();
}
}
function assertLe(uint a, uint b, string memory err) internal {
if (a > b) {
emit log_named_string("Error", err);
assertLe(a, b);
}
}
function assertLe(int a, int b) internal {
if (a > b) {
emit log("Error: a <= b not satisfied [int]");
emit log_named_int(" Value a", a);
emit log_named_int(" Value b", b);
fail();
}
}
function assertLe(int a, int b, string memory err) internal {
if (a > b) {
emit log_named_string("Error", err);
assertLe(a, b);
}
}
function assertLeDecimal(int a, int b, uint decimals) internal {
if (a > b) {
emit log("Error: a <= b not satisfied [decimal int]");
emit log_named_decimal_int(" Value a", a, decimals);
emit log_named_decimal_int(" Value b", b, decimals);
fail();
}
}
function assertLeDecimal(int a, int b, uint decimals, string memory err) internal {
if (a > b) {
emit log_named_string("Error", err);
assertLeDecimal(a, b, decimals);
}
}
function assertLeDecimal(uint a, uint b, uint decimals) internal {
if (a > b) {
emit log("Error: a <= b not satisfied [decimal uint]");
emit log_named_decimal_uint(" Value a", a, decimals);
emit log_named_decimal_uint(" Value b", b, decimals);
fail();
}
}
function assertLeDecimal(uint a, uint b, uint decimals, string memory err) internal {
if (a > b) {
emit log_named_string("Error", err);
assertLeDecimal(a, b, decimals);
}
}
function assertEq(string memory a, string memory b) internal {
if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) {
emit log("Error: a == b not satisfied [string]");
emit log_named_string(" Left", a);
emit log_named_string(" Right", b);
fail();
}
}
function assertEq(string memory a, string memory b, string memory err) internal {
if (keccak256(abi.encodePacked(a)) != keccak256(abi.encodePacked(b))) {
emit log_named_string("Error", err);
assertEq(a, b);
}
}
function assertNotEq(string memory a, string memory b) internal {
if (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b))) {
emit log("Error: a != b not satisfied [string]");
emit log_named_string(" Left", a);
emit log_named_string(" Right", b);
fail();
}
}
function assertNotEq(string memory a, string memory b, string memory err) internal {
if (keccak256(abi.encodePacked(a)) == keccak256(abi.encodePacked(b))) {
emit log_named_string("Error", err);
assertNotEq(a, b);
}
}
function checkEq0(bytes memory a, bytes memory b) internal pure returns (bool ok) {
ok = true;
if (a.length == b.length) {
for (uint i = 0; i < a.length; i++) {
if (a[i] != b[i]) {
ok = false;
}
}
} else {
ok = false;
}
}
function assertEq0(bytes memory a, bytes memory b) internal {
if (!checkEq0(a, b)) {
emit log("Error: a == b not satisfied [bytes]");
emit log_named_bytes(" Left", a);
emit log_named_bytes(" Right", b);
fail();
}
}
function assertEq0(bytes memory a, bytes memory b, string memory err) internal {
if (!checkEq0(a, b)) {
emit log_named_string("Error", err);
assertEq0(a, b);
}
}
function assertNotEq0(bytes memory a, bytes memory b) internal {
if (checkEq0(a, b)) {
emit log("Error: a != b not satisfied [bytes]");
emit log_named_bytes(" Left", a);
emit log_named_bytes(" Right", b);
fail();
}
}
function assertNotEq0(bytes memory a, bytes memory b, string memory err) internal {
if (checkEq0(a, b)) {
emit log_named_string("Error", err);
assertNotEq0(a, b);
}
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
import {StdStorage} from "./StdStorage.sol";
import {Vm, VmSafe} from "./Vm.sol";
abstract contract CommonBase {
// Cheat code address, 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D.
address internal constant VM_ADDRESS = address(uint160(uint256(keccak256("hevm cheat code"))));
// console.sol and console2.sol work by executing a staticcall to this address.
address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;
// Used when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.
address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
// Default address for tx.origin and msg.sender, 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38.
address internal constant DEFAULT_SENDER = address(uint160(uint256(keccak256("foundry default caller"))));
// Address of the test contract, deployed by the DEFAULT_SENDER.
address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;
// Deterministic deployment address of the Multicall3 contract.
address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;
// The order of the secp256k1 curve.
uint256 internal constant SECP256K1_ORDER =
115792089237316195423570985008687907852837564279074904382605163141518161494337;
uint256 internal constant UINT256_MAX =
115792089237316195423570985008687907853269984665640564039457584007913129639935;
Vm internal constant vm = Vm(VM_ADDRESS);
StdStorage internal stdstore;
}
abstract contract TestBase is CommonBase {}
abstract contract ScriptBase is CommonBase {
VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
// 💬 ABOUT
// Forge Std's default Script.
// 🧩 MODULES
import {console} from "./console.sol";
import {console2} from "./console2.sol";
import {safeconsole} from "./safeconsole.sol";
import {StdChains} from "./StdChains.sol";
import {StdCheatsSafe} from "./StdCheats.sol";
import {stdJson} from "./StdJson.sol";
import {stdMath} from "./StdMath.sol";
import {StdStorage, stdStorageSafe} from "./StdStorage.sol";
import {StdStyle} from "./StdStyle.sol";
import {StdUtils} from "./StdUtils.sol";
import {VmSafe} from "./Vm.sol";
// 📦 BOILERPLATE
import {ScriptBase} from "./Base.sol";
// ⭐️ SCRIPT
abstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {
// Note: IS_SCRIPT() must return true.
bool public IS_SCRIPT = true;
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
import {DSTest} from "ds-test/test.sol";
import {stdMath} from "./StdMath.sol";
abstract contract StdAssertions is DSTest {
event log_array(uint256[] val);
event log_array(int256[] val);
event log_array(address[] val);
event log_named_array(string key, uint256[] val);
event log_named_array(string key, int256[] val);
event log_named_array(string key, address[] val);
function fail(string memory err) internal virtual {
emit log_named_string("Error", err);
fail();
}
function assertFalse(bool data) internal virtual {
assertTrue(!data);
}
function assertFalse(bool data, string memory err) internal virtual {
assertTrue(!data, err);
}
function assertEq(bool a, bool b) internal virtual {
if (a != b) {
emit log("Error: a == b not satisfied [bool]");
emit log_named_string(" Left", a ? "true" : "false");
emit log_named_string(" Right", b ? "true" : "false");
fail();
}
}
function assertEq(bool a, bool b, string memory err) internal virtual {
if (a != b) {
emit log_named_string("Error", err);
assertEq(a, b);
}
}
function assertEq(bytes memory a, bytes memory b) internal virtual {
assertEq0(a, b);
}
function assertEq(bytes memory a, bytes memory b, string memory err) internal virtual {
assertEq0(a, b, err);
}
function assertEq(uint256[] memory a, uint256[] memory b) internal virtual {
if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
emit log("Error: a == b not satisfied [uint[]]");
emit log_named_array(" Left", a);
emit log_named_array(" Right", b);
fail();
}
}
function assertEq(int256[] memory a, int256[] memory b) internal virtual {
if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
emit log("Error: a == b not satisfied [int[]]");
emit log_named_array(" Left", a);
emit log_named_array(" Right", b);
fail();
}
}
function assertEq(address[] memory a, address[] memory b) internal virtual {
if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
emit log("Error: a == b not satisfied [address[]]");
emit log_named_array(" Left", a);
emit log_named_array(" Right", b);
fail();
}
}
function assertEq(uint256[] memory a, uint256[] memory b, string memory err) internal virtual {
if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
emit log_named_string("Error", err);
assertEq(a, b);
}
}
function assertEq(int256[] memory a, int256[] memory b, string memory err) internal virtual {
if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
emit log_named_string("Error", err);
assertEq(a, b);
}
}
function assertEq(address[] memory a, address[] memory b, string memory err) internal virtual {
if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
emit log_named_string("Error", err);
assertEq(a, b);
}
}
// Legacy helper
function assertEqUint(uint256 a, uint256 b) internal virtual {
assertEq(uint256(a), uint256(b));
}
function assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta) internal virtual {
uint256 delta = stdMath.delta(a, b);
if (delta > maxDelta) {
emit log("Error: a ~= b not satisfied [uint]");
emit log_named_uint(" Left", a);
emit log_named_uint(" Right", b);
emit log_named_uint(" Max Delta", maxDelta);
emit log_named_uint(" Delta", delta);
fail();
}
}
function assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta, string memory err) internal virtual {
uint256 delta = stdMath.delta(a, b);
if (delta > maxDelta) {
emit log_named_string("Error", err);
assertApproxEqAbs(a, b, maxDelta);
}
}
function assertApproxEqAbsDecimal(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals) internal virtual {
uint256 delta = stdMath.delta(a, b);
if (delta > maxDelta) {
emit log("Error: a ~= b not satisfied [uint]");
emit log_named_decimal_uint(" Left", a, decimals);
emit log_named_decimal_uint(" Right", b, decimals);
emit log_named_decimal_uint(" Max Delta", maxDelta, decimals);
emit log_named_decimal_uint(" Delta", delta, decimals);
fail();
}
}
function assertApproxEqAbsDecimal(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals, string memory err)
internal
virtual
{
uint256 delta = stdMath.delta(a, b);
if (delta > maxDelta) {
emit log_named_string("Error", err);
assertApproxEqAbsDecimal(a, b, maxDelta, decimals);
}
}
function assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta) internal virtual {
uint256 delta = stdMath.delta(a, b);
if (delta > maxDelta) {
emit log("Error: a ~= b not satisfied [int]");
emit log_named_int(" Left", a);
emit log_named_int(" Right", b);
emit log_named_uint(" Max Delta", maxDelta);
emit log_named_uint(" Delta", delta);
fail();
}
}
function assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta, string memory err) internal virtual {
uint256 delta = stdMath.delta(a, b);
if (delta > maxDelta) {
emit log_named_string("Error", err);
assertApproxEqAbs(a, b, maxDelta);
}
}
function assertApproxEqAbsDecimal(int256 a, int256 b, uint256 maxDelta, uint256 decimals) internal virtual {
uint256 delta = stdMath.delta(a, b);
if (delta > maxDelta) {
emit log("Error: a ~= b not satisfied [int]");
emit log_named_decimal_int(" Left", a, decimals);
emit log_named_decimal_int(" Right", b, decimals);
emit log_named_decimal_uint(" Max Delta", maxDelta, decimals);
emit log_named_decimal_uint(" Delta", delta, decimals);
fail();
}
}
function assertApproxEqAbsDecimal(int256 a, int256 b, uint256 maxDelta, uint256 decimals, string memory err)
internal
virtual
{
uint256 delta = stdMath.delta(a, b);
if (delta > maxDelta) {
emit log_named_string("Error", err);
assertApproxEqAbsDecimal(a, b, maxDelta, decimals);
}
}
function assertApproxEqRel(
uint256 a,
uint256 b,
uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100%
) internal virtual {
if (b == 0) return assertEq(a, b); // If the left is 0, right must be too.
uint256 percentDelta = stdMath.percentDelta(a, b);
if (percentDelta > maxPercentDelta) {
emit log("Error: a ~= b not satisfied [uint]");
emit log_named_uint(" Left", a);
emit log_named_uint(" Right", b);
emit log_named_decimal_uint(" Max % Delta", maxPercentDelta * 100, 18);
emit log_named_decimal_uint(" % Delta", percentDelta * 100, 18);
fail();
}
}
function assertApproxEqRel(
uint256 a,
uint256 b,
uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
string memory err
) internal virtual {
if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too.
uint256 percentDelta = stdMath.percentDelta(a, b);
if (percentDelta > maxPercentDelta) {
emit log_named_string("Error", err);
assertApproxEqRel(a, b, maxPercentDelta);
}
}
function assertApproxEqRelDecimal(
uint256 a,
uint256 b,
uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
uint256 decimals
) internal virtual {
if (b == 0) return assertEq(a, b); // If the left is 0, right must be too.
uint256 percentDelta = stdMath.percentDelta(a, b);
if (percentDelta > maxPercentDelta) {
emit log("Error: a ~= b not satisfied [uint]");
emit log_named_decimal_uint(" Left", a, decimals);
emit log_named_decimal_uint(" Right", b, decimals);
emit log_named_decimal_uint(" Max % Delta", maxPercentDelta * 100, 18);
emit log_named_decimal_uint(" % Delta", percentDelta * 100, 18);
fail();
}
}
function assertApproxEqRelDecimal(
uint256 a,
uint256 b,
uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
uint256 decimals,
string memory err
) internal virtual {
if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too.
uint256 percentDelta = stdMath.percentDelta(a, b);
if (percentDelta > maxPercentDelta) {
emit log_named_string("Error", err);
assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals);
}
}
function assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta) internal virtual {
if (b == 0) return assertEq(a, b); // If the left is 0, right must be too.
uint256 percentDelta = stdMath.percentDelta(a, b);
if (percentDelta > maxPercentDelta) {
emit log("Error: a ~= b not satisfied [int]");
emit log_named_int(" Left", a);
emit log_named_int(" Right", b);
emit log_named_decimal_uint(" Max % Delta", maxPercentDelta * 100, 18);
emit log_named_decimal_uint(" % Delta", percentDelta * 100, 18);
fail();
}
}
function assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta, string memory err) internal virtual {
if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too.
uint256 percentDelta = stdMath.percentDelta(a, b);
if (percentDelta > maxPercentDelta) {
emit log_named_string("Error", err);
assertApproxEqRel(a, b, maxPercentDelta);
}
}
function assertApproxEqRelDecimal(int256 a, int256 b, uint256 maxPercentDelta, uint256 decimals) internal virtual {
if (b == 0) return assertEq(a, b); // If the left is 0, right must be too.
uint256 percentDelta = stdMath.percentDelta(a, b);
if (percentDelta > maxPercentDelta) {
emit log("Error: a ~= b not satisfied [int]");
emit log_named_decimal_int(" Left", a, decimals);
emit log_named_decimal_int(" Right", b, decimals);
emit log_named_decimal_uint(" Max % Delta", maxPercentDelta * 100, 18);
emit log_named_decimal_uint(" % Delta", percentDelta * 100, 18);
fail();
}
}
function assertApproxEqRelDecimal(int256 a, int256 b, uint256 maxPercentDelta, uint256 decimals, string memory err)
internal
virtual
{
if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too.
uint256 percentDelta = stdMath.percentDelta(a, b);
if (percentDelta > maxPercentDelta) {
emit log_named_string("Error", err);
assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals);
}
}
function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual {
assertEqCall(target, callDataA, target, callDataB, true);
}
function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB)
internal
virtual
{
assertEqCall(targetA, callDataA, targetB, callDataB, true);
}
function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData)
internal
virtual
{
assertEqCall(target, callDataA, target, callDataB, strictRevertData);
}
function assertEqCall(
address targetA,
bytes memory callDataA,
address targetB,
bytes memory callDataB,
bool strictRevertData
) internal virtual {
(bool successA, bytes memory returnDataA) = address(targetA).call(callDataA);
(bool successB, bytes memory returnDataB) = address(targetB).call(callDataB);
if (successA && successB) {
assertEq(returnDataA, returnDataB, "Call return data does not match");
}
if (!successA && !successB && strictRevertData) {
assertEq(returnDataA, returnDataB, "Call revert data does not match");
}
if (!successA && successB) {
emit log("Error: Calls were not equal");
emit log_named_bytes(" Left call revert data", returnDataA);
emit log_named_bytes(" Right call return data", returnDataB);
fail();
}
if (successA && !successB) {
emit log("Error: Calls were not equal");
emit log_named_bytes(" Left call return data", returnDataA);
emit log_named_bytes(" Right call revert data", returnDataB);
fail();
}
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
import {VmSafe} from "./Vm.sol";
/**
* StdChains provides information about EVM compatible chains that can be used in scripts/tests.
* For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are
* identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of
* the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the
* alias used in this contract, which can be found as the first argument to the
* `setChainWithDefaultRpcUrl` call in the `initializeStdChains` function.
*
* There are two main ways to use this contract:
* 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or
* `setChain(string memory chainAlias, Chain memory chain)`
* 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.
*
* The first time either of those are used, chains are initialized with the default set of RPC URLs.
* This is done in `initializeStdChains`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in
* `defaultRpcUrls`.
*
* The `setChain` function is straightforward, and it simply saves off the given chain data.
*
* The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say
* we want to retrieve the RPC URL for `mainnet`:
* - If you have specified data with `setChain`, it will return that.
* - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it
* is valid (e.g. a URL is specified, or an environment variable is given and exists).
* - If neither of the above conditions is met, the default data is returned.
*
* Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.
*/
abstract contract StdChains {
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
bool private stdChainsInitialized;
struct ChainData {
string name;
uint256 chainId;
string rpcUrl;
}
struct Chain {
// The chain name.
string name;
// The chain's Chain ID.
uint256 chainId;
// The chain's alias. (i.e. what gets specified in `foundry.toml`).
string chainAlias;
// A default RPC endpoint for this chain.
// NOTE: This default RPC URL is included for convenience to facilitate quick tests and
// experimentation. Do not use this RPC URL for production test suites, CI, or other heavy
// usage as you will be throttled and this is a disservice to others who need this endpoint.
string rpcUrl;
}
// Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.
mapping(string => Chain) private chains;
// Maps from the chain's alias to it's default RPC URL.
mapping(string => string) private defaultRpcUrls;
// Maps from a chain ID to it's alias.
mapping(uint256 => string) private idToAlias;
bool private fallbackToDefaultRpcUrls = true;
// The RPC URL will be fetched from config or defaultRpcUrls if possible.
function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {
require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string.");
initializeStdChains();
chain = chains[chainAlias];
require(
chain.chainId != 0,
string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found."))
);
chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
}
function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {
require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0.");
initializeStdChains();
string memory chainAlias = idToAlias[chainId];
chain = chains[chainAlias];
require(
chain.chainId != 0,
string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found."))
);
chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
}
// set chain info, with priority to argument's rpcUrl field.
function setChain(string memory chainAlias, ChainData memory chain) internal virtual {
require(
bytes(chainAlias).length != 0,
"StdChains setChain(string,ChainData): Chain alias cannot be the empty string."
);
require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0.");
initializeStdChains();
string memory foundAlias = idToAlias[chain.chainId];
require(
bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),
string(
abi.encodePacked(
"StdChains setChain(string,ChainData): Chain ID ",
vm.toString(chain.chainId),
" already used by \"",
foundAlias,
"\"."
)
)
);
uint256 oldChainId = chains[chainAlias].chainId;
delete idToAlias[oldChainId];
chains[chainAlias] =
Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});
idToAlias[chain.chainId] = chainAlias;
}
// set chain info, with priority to argument's rpcUrl field.
function setChain(string memory chainAlias, Chain memory chain) internal virtual {
setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));
}
function _toUpper(string memory str) private pure returns (string memory) {
bytes memory strb = bytes(str);
bytes memory copy = new bytes(strb.length);
for (uint256 i = 0; i < strb.length; i++) {
bytes1 b = strb[i];
if (b >= 0x61 && b <= 0x7A) {
copy[i] = bytes1(uint8(b) - 32);
} else {
copy[i] = b;
}
}
return string(copy);
}
// lookup rpcUrl, in descending order of priority:
// current -> config (foundry.toml) -> environment variable -> default
function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain) private returns (Chain memory) {
if (bytes(chain.rpcUrl).length == 0) {
try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {
chain.rpcUrl = configRpcUrl;
} catch (bytes memory err) {
string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL"));
if (fallbackToDefaultRpcUrls) {
chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);
} else {
chain.rpcUrl = vm.envString(envName);
}
// Distinguish 'not found' from 'cannot read'
// The upstream error thrown by forge for failing cheats changed so we check both the old and new versions
bytes memory oldNotFoundError =
abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias)));
bytes memory newNotFoundError = abi.encodeWithSignature(
"CheatcodeError(string)", string(abi.encodePacked("invalid rpc url: ", chainAlias))
);
bytes32 errHash = keccak256(err);
if (
(errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))
|| bytes(chain.rpcUrl).length == 0
) {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, err), mload(err))
}
}
}
}
return chain;
}
function setFallbackToDefaultRpcUrls(bool useDefault) internal {
fallbackToDefaultRpcUrls = useDefault;
}
function initializeStdChains() private {
if (stdChainsInitialized) return;
stdChainsInitialized = true;
// If adding an RPC here, make sure to test the default RPC URL in `testRpcs`
setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545"));
setChainWithDefaultRpcUrl(
"mainnet", ChainData("Mainnet", 1, "https://mainnet.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001")
);
setChainWithDefaultRpcUrl(
"goerli", ChainData("Goerli", 5, "https://goerli.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001")
);
setChainWithDefaultRpcUrl(
"sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001")
);
setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io"));
setChainWithDefaultRpcUrl("optimism_goerli", ChainData("Optimism Goerli", 420, "https://goerli.optimism.io"));
setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc"));
setChainWithDefaultRpcUrl(
"arbitrum_one_goerli", ChainData("Arbitrum One Goerli", 421613, "https://goerli-rollup.arbitrum.io/rpc")
);
setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc"));
setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com"));
setChainWithDefaultRpcUrl(
"polygon_mumbai", ChainData("Polygon Mumbai", 80001, "https://rpc-mumbai.maticvigil.com")
);
setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc"));
setChainWithDefaultRpcUrl(
"avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc")
);
setChainWithDefaultRpcUrl(
"bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org")
);
setChainWithDefaultRpcUrl(
"bnb_smart_chain_testnet",
ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel")
);
setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com"));
setChainWithDefaultRpcUrl("moonbeam", ChainData("Moonbeam", 1284, "https://rpc.api.moonbeam.network"));
setChainWithDefaultRpcUrl(
"moonriver", ChainData("Moonriver", 1285, "https://rpc.api.moonriver.moonbeam.network")
);
setChainWithDefaultRpcUrl("moonbase", ChainData("Moonbase", 1287, "https://rpc.testnet.moonbeam.network"));
setChainWithDefaultRpcUrl("base_goerli", ChainData("Base Goerli", 84531, "https://goerli.base.org"));
setChainWithDefaultRpcUrl("base", ChainData("Base", 8453, "https://mainnet.base.org"));
}
// set chain info, with priority to chainAlias' rpc url in foundry.toml
function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {
string memory rpcUrl = chain.rpcUrl;
defaultRpcUrls[chainAlias] = rpcUrl;
chain.rpcUrl = "";
setChain(chainAlias, chain);
chain.rpcUrl = rpcUrl; // restore argument
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
pragma experimental ABIEncoderV2;
import {StdStorage, stdStorage} from "./StdStorage.sol";
import {console2} from "./console2.sol";
import {Vm} from "./Vm.sol";
abstract contract StdCheatsSafe {
Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
uint256 private constant UINT256_MAX =
115792089237316195423570985008687907853269984665640564039457584007913129639935;
bool private gasMeteringOff;
// Data structures to parse Transaction objects from the broadcast artifact
// that conform to EIP1559. The Raw structs is what is parsed from the JSON
// and then converted to the one that is used by the user for better UX.
struct RawTx1559 {
string[] arguments;
address contractAddress;
string contractName;
// json value name = function
string functionSig;
bytes32 hash;
// json value name = tx
RawTx1559Detail txDetail;
// json value name = type
string opcode;
}
struct RawTx1559Detail {
AccessList[] accessList;
bytes data;
address from;
bytes gas;
bytes nonce;
address to;
bytes txType;
bytes value;
}
struct Tx1559 {
string[] arguments;
address contractAddress;
string contractName;
string functionSig;
bytes32 hash;
Tx1559Detail txDetail;
string opcode;
}
struct Tx1559Detail {
AccessList[] accessList;
bytes data;
address from;
uint256 gas;
uint256 nonce;
address to;
uint256 txType;
uint256 value;
}
// Data structures to parse Transaction objects from the broadcast artifact
// that DO NOT conform to EIP1559. The Raw structs is what is parsed from the JSON
// and then converted to the one that is used by the user for better UX.
struct TxLegacy {
string[] arguments;
address contractAddress;
string contractName;
string functionSig;
string hash;
string opcode;
TxDetailLegacy transaction;
}
struct TxDetailLegacy {
AccessList[] accessList;
uint256 chainId;
bytes data;
address from;
uint256 gas;
uint256 gasPrice;
bytes32 hash;
uint256 nonce;
bytes1 opcode;
bytes32 r;
bytes32 s;
uint256 txType;
address to;
uint8 v;
uint256 value;
}
struct AccessList {
address accessAddress;
bytes32[] storageKeys;
}
// Data structures to parse Receipt objects from the broadcast artifact.
// The Raw structs is what is parsed from the JSON
// and then converted to the one that is used by the user for better UX.
struct RawReceipt {
bytes32 blockHash;
bytes blockNumber;
address contractAddress;
bytes cumulativeGasUsed;
bytes effectiveGasPrice;
address from;
bytes gasUsed;
RawReceiptLog[] logs;
bytes logsBloom;
bytes status;
address to;
bytes32 transactionHash;
bytes transactionIndex;
}
struct Receipt {
bytes32 blockHash;
uint256 blockNumber;
address contractAddress;
uint256 cumulativeGasUsed;
uint256 effectiveGasPrice;
address from;
uint256 gasUsed;
ReceiptLog[] logs;
bytes logsBloom;
uint256 status;
address to;
bytes32 transactionHash;
uint256 transactionIndex;
}
// Data structures to parse the entire broadcast artifact, assuming the
// transactions conform to EIP1559.
struct EIP1559ScriptArtifact {
string[] libraries;
string path;
string[] pending;
Receipt[] receipts;
uint256 timestamp;
Tx1559[] transactions;
TxReturn[] txReturns;
}
struct RawEIP1559ScriptArtifact {
string[] libraries;
string path;
string[] pending;
RawReceipt[] receipts;
TxReturn[] txReturns;
uint256 timestamp;
RawTx1559[] transactions;
}
struct RawReceiptLog {
// json value = address
address logAddress;
bytes32 blockHash;
bytes blockNumber;
bytes data;
bytes logIndex;
bool removed;
bytes32[] topics;
bytes32 transactionHash;
bytes transactionIndex;
bytes transactionLogIndex;
}
struct ReceiptLog {
// json value = address
address logAddress;
bytes32 blockHash;
uint256 blockNumber;
bytes data;
uint256 logIndex;
bytes32[] topics;
uint256 transactionIndex;
uint256 transactionLogIndex;
bool removed;
}
struct TxReturn {
string internalType;
string value;
}
struct Account {
address addr;
uint256 key;
}
enum AddressType {
Payable,
NonPayable,
ZeroAddress,
Precompile,
ForgeAddress
}
// Checks that `addr` is not blacklisted by token contracts that have a blacklist.
function assumeNotBlacklisted(address token, address addr) internal view virtual {
// Nothing to check if `token` is not a contract.
uint256 tokenCodeSize;
assembly {
tokenCodeSize := extcodesize(token)
}
require(tokenCodeSize > 0, "StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.");
bool success;
bytes memory returnData;
// 4-byte selector for `isBlacklisted(address)`, used by USDC.
(success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));
vm.assume(!success || abi.decode(returnData, (bool)) == false);
// 4-byte selector for `isBlackListed(address)`, used by USDT.
(success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));
vm.assume(!success || abi.decode(returnData, (bool)) == false);
}
// Checks that `addr` is not blacklisted by token contracts that have a blacklist.
// This is identical to `assumeNotBlacklisted(address,address)` but with a different name, for
// backwards compatibility, since this name was used in the original PR which has already has
// a release. This function can be removed in a future release once we want a breaking change.
function assumeNoBlacklisted(address token, address addr) internal view virtual {
assumeNotBlacklisted(token, addr);
}
function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {
if (addressType == AddressType.Payable) {
assumeNotPayable(addr);
} else if (addressType == AddressType.NonPayable) {
assumePayable(addr);
} else if (addressType == AddressType.ZeroAddress) {
assumeNotZeroAddress(addr);
} else if (addressType == AddressType.Precompile) {
assumeNotPrecompile(addr);
} else if (addressType == AddressType.ForgeAddress) {
assumeNotForgeAddress(addr);
}
}
function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {
assumeAddressIsNot(addr, addressType1);
assumeAddressIsNot(addr, addressType2);
}
function assumeAddressIsNot(
address addr,
AddressType addressType1,
AddressType addressType2,
AddressType addressType3
) internal virtual {
assumeAddressIsNot(addr, addressType1);
assumeAddressIsNot(addr, addressType2);
assumeAddressIsNot(addr, addressType3);
}
function assumeAddressIsNot(
address addr,
AddressType addressType1,
AddressType addressType2,
AddressType addressType3,
AddressType addressType4
) internal virtual {
assumeAddressIsNot(addr, addressType1);
assumeAddressIsNot(addr, addressType2);
assumeAddressIsNot(addr, addressType3);
assumeAddressIsNot(addr, addressType4);
}
// This function checks whether an address, `addr`, is payable. It works by sending 1 wei to
// `addr` and checking the `success` return value.
// NOTE: This function may result in state changes depending on the fallback/receive logic
// implemented by `addr`, which should be taken into account when this function is used.
function _isPayable(address addr) private returns (bool) {
require(
addr.balance < UINT256_MAX,
"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds"
);
uint256 origBalanceTest = address(this).balance;
uint256 origBalanceAddr = address(addr).balance;
vm.deal(address(this), 1);
(bool success,) = payable(addr).call{value: 1}("");
// reset balances
vm.deal(address(this), origBalanceTest);
vm.deal(addr, origBalanceAddr);
return success;
}
// NOTE: This function may result in state changes depending on the fallback/receive logic
// implemented by `addr`, which should be taken into account when this function is used. See the
// `_isPayable` method for more information.
function assumePayable(address addr) internal virtual {
vm.assume(_isPayable(addr));
}
function assumeNotPayable(address addr) internal virtual {
vm.assume(!_isPayable(addr));
}
function assumeNotZeroAddress(address addr) internal pure virtual {
vm.assume(addr != address(0));
}
function assumeNotPrecompile(address addr) internal pure virtual {
assumeNotPrecompile(addr, _pureChainId());
}
function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {
// Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific
// address), but the same rationale for excluding them applies so we include those too.
// These should be present on all EVM-compatible chains.
vm.assume(addr < address(0x1) || addr > address(0x9));
// forgefmt: disable-start
if (chainId == 10 || chainId == 420) {
// https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21
vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));
} else if (chainId == 42161 || chainId == 421613) {
// https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains
vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));
} else if (chainId == 43114 || chainId == 43113) {
// https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59
vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));
vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));
vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));
}
// forgefmt: disable-end
}
function assumeNotForgeAddress(address addr) internal pure virtual {
// vm, console, and Create2Deployer addresses
vm.assume(
addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67
&& addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C
);
}
function readEIP1559ScriptArtifact(string memory path)
internal
view
virtual
returns (EIP1559ScriptArtifact memory)
{
string memory data = vm.readFile(path);
bytes memory parsedData = vm.parseJson(data);
RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));
EIP1559ScriptArtifact memory artifact;
artifact.libraries = rawArtifact.libraries;
artifact.path = rawArtifact.path;
artifact.timestamp = rawArtifact.timestamp;
artifact.pending = rawArtifact.pending;
artifact.txReturns = rawArtifact.txReturns;
artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);
artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);
return artifact;
}
function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {
Tx1559[] memory txs = new Tx1559[](rawTxs.length);
for (uint256 i; i < rawTxs.length; i++) {
txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);
}
return txs;
}
function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {
Tx1559 memory transaction;
transaction.arguments = rawTx.arguments;
transaction.contractName = rawTx.contractName;
transaction.functionSig = rawTx.functionSig;
transaction.hash = rawTx.hash;
transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);
transaction.opcode = rawTx.opcode;
return transaction;
}
function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)
internal
pure
virtual
returns (Tx1559Detail memory)
{
Tx1559Detail memory txDetail;
txDetail.data = rawDetail.data;
txDetail.from = rawDetail.from;
txDetail.to = rawDetail.to;
txDetail.nonce = _bytesToUint(rawDetail.nonce);
txDetail.txType = _bytesToUint(rawDetail.txType);
txDetail.value = _bytesToUint(rawDetail.value);
txDetail.gas = _bytesToUint(rawDetail.gas);
txDetail.accessList = rawDetail.accessList;
return txDetail;
}
function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {
string memory deployData = vm.readFile(path);
bytes memory parsedDeployData = vm.parseJson(deployData, ".transactions");
RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));
return rawToConvertedEIPTx1559s(rawTxs);
}
function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {
string memory deployData = vm.readFile(path);
string memory key = string(abi.encodePacked(".transactions[", vm.toString(index), "]"));
bytes memory parsedDeployData = vm.parseJson(deployData, key);
RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));
return rawToConvertedEIPTx1559(rawTx);
}
// Analogous to readTransactions, but for receipts.
function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {
string memory deployData = vm.readFile(path);
bytes memory parsedDeployData = vm.parseJson(deployData, ".receipts");
RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));
return rawToConvertedReceipts(rawReceipts);
}
function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {
string memory deployData = vm.readFile(path);
string memory key = string(abi.encodePacked(".receipts[", vm.toString(index), "]"));
bytes memory parsedDeployData = vm.parseJson(deployData, key);
RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));
return rawToConvertedReceipt(rawReceipt);
}
function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {
Receipt[] memory receipts = new Receipt[](rawReceipts.length);
for (uint256 i; i < rawReceipts.length; i++) {
receipts[i] = rawToConvertedReceipt(rawReceipts[i]);
}
return receipts;
}
function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {
Receipt memory receipt;
receipt.blockHash = rawReceipt.blockHash;
receipt.to = rawReceipt.to;
receipt.from = rawReceipt.from;
receipt.contractAddress = rawReceipt.contractAddress;
receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);
receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);
receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);
receipt.status = _bytesToUint(rawReceipt.status);
receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);
receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);
receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);
receipt.logsBloom = rawReceipt.logsBloom;
receipt.transactionHash = rawReceipt.transactionHash;
return receipt;
}
function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)
internal
pure
virtual
returns (ReceiptLog[] memory)
{
ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);
for (uint256 i; i < rawLogs.length; i++) {
logs[i].logAddress = rawLogs[i].logAddress;
logs[i].blockHash = rawLogs[i].blockHash;
logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);
logs[i].data = rawLogs[i].data;
logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);
logs[i].topics = rawLogs[i].topics;
logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);
logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);
logs[i].removed = rawLogs[i].removed;
}
return logs;
}
// Deploy a contract by fetching the contract bytecode from
// the artifacts directory
// e.g. `deployCode(code, abi.encode(arg1,arg2,arg3))`
function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {
bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
/// @solidity memory-safe-assembly
assembly {
addr := create(0, add(bytecode, 0x20), mload(bytecode))
}
require(addr != address(0), "StdCheats deployCode(string,bytes): Deployment failed.");
}
function deployCode(string memory what) internal virtual returns (address addr) {
bytes memory bytecode = vm.getCode(what);
/// @solidity memory-safe-assembly
assembly {
addr := create(0, add(bytecode, 0x20), mload(bytecode))
}
require(addr != address(0), "StdCheats deployCode(string): Deployment failed.");
}
/// @dev deploy contract with value on construction
function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {
bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
/// @solidity memory-safe-assembly
assembly {
addr := create(val, add(bytecode, 0x20), mload(bytecode))
}
require(addr != address(0), "StdCheats deployCode(string,bytes,uint256): Deployment failed.");
}
function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {
bytes memory bytecode = vm.getCode(what);
/// @solidity memory-safe-assembly
assembly {
addr := create(val, add(bytecode, 0x20), mload(bytecode))
}
require(addr != address(0), "StdCheats deployCode(string,uint256): Deployment failed.");
}
// creates a labeled address and the corresponding private key
function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {
privateKey = uint256(keccak256(abi.encodePacked(name)));
addr = vm.addr(privateKey);
vm.label(addr, name);
}
// creates a labeled address
function makeAddr(string memory name) internal virtual returns (address addr) {
(addr,) = makeAddrAndKey(name);
}
// Destroys an account immediately, sending the balance to beneficiary.
// Destroying means: balance will be zero, code will be empty, and nonce will be 0
// This is similar to selfdestruct but not identical: selfdestruct destroys code and nonce
// only after tx ends, this will run immediately.
function destroyAccount(address who, address beneficiary) internal virtual {
uint256 currBalance = who.balance;
vm.etch(who, abi.encode());
vm.deal(who, 0);
vm.resetNonce(who);
uint256 beneficiaryBalance = beneficiary.balance;
vm.deal(beneficiary, currBalance + beneficiaryBalance);
}
// creates a struct containing both a labeled address and the corresponding private key
function makeAccount(string memory name) internal virtual returns (Account memory account) {
(account.addr, account.key) = makeAddrAndKey(name);
}
function deriveRememberKey(string memory mnemonic, uint32 index)
internal
virtual
returns (address who, uint256 privateKey)
{
privateKey = vm.deriveKey(mnemonic, index);
who = vm.rememberKey(privateKey);
}
function _bytesToUint(bytes memory b) private pure returns (uint256) {
require(b.length <= 32, "StdCheats _bytesToUint(bytes): Bytes length exceeds 32.");
return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
}
function isFork() internal view virtual returns (bool status) {
try vm.activeFork() {
status = true;
} catch (bytes memory) {}
}
modifier skipWhenForking() {
if (!isFork()) {
_;
}
}
modifier skipWhenNotForking() {
if (isFork()) {
_;
}
}
modifier noGasMetering() {
vm.pauseGasMetering();
// To prevent turning gas monitoring back on with nested functions that use this modifier,
// we check if gasMetering started in the off position. If it did, we don't want to turn
// it back on until we exit the top level function that used the modifier
//
// i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.
// funcA will have `gasStartedOff` as false, funcB will have it as true,
// so we only turn metering back on at the end of the funcA
bool gasStartedOff = gasMeteringOff;
gasMeteringOff = true;
_;
// if gas metering was on when this modifier was called, turn it back on at the end
if (!gasStartedOff) {
gasMeteringOff = false;
vm.resumeGasMetering();
}
}
// We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no
// compiler warnings when accessing chain ID in any solidity version supported by forge-std. We
// can't simply access the chain ID in a normal view or pure function because the solc View Pure
// Checker changed `chainid` from pure to view in 0.8.0.
function _viewChainId() private view returns (uint256 chainId) {
// Assembly required since `block.chainid` was introduced in 0.8.0.
assembly {
chainId := chainid()
}
address(this); // Silence warnings in older Solc versions.
}
function _pureChainId() private pure returns (uint256 chainId) {
function() internal view returns (uint256) fnIn = _viewChainId;
function() internal pure returns (uint256) pureChainId;
assembly {
pureChainId := fnIn
}
chainId = pureChainId();
}
}
// Wrappers around cheatcodes to avoid footguns
abstract contract StdCheats is StdCheatsSafe {
using stdStorage for StdStorage;
StdStorage private stdstore;
Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
// Skip forward or rewind time by the specified number of seconds
function skip(uint256 time) internal virtual {
vm.warp(block.timestamp + time);
}
function rewind(uint256 time) internal virtual {
vm.warp(block.timestamp - time);
}
// Setup a prank from an address that has some ether
function hoax(address msgSender) internal virtual {
vm.deal(msgSender, 1 << 128);
vm.prank(msgSender);
}
function hoax(address msgSender, uint256 give) internal virtual {
vm.deal(msgSender, give);
vm.prank(msgSender);
}
function hoax(address msgSender, address origin) internal virtual {
vm.deal(msgSender, 1 << 128);
vm.prank(msgSender, origin);
}
function hoax(address msgSender, address origin, uint256 give) internal virtual {
vm.deal(msgSender, give);
vm.prank(msgSender, origin);
}
// Start perpetual prank from an address that has some ether
function startHoax(address msgSender) internal virtual {
vm.deal(msgSender, 1 << 128);
vm.startPrank(msgSender);
}
function startHoax(address msgSender, uint256 give) internal virtual {
vm.deal(msgSender, give);
vm.startPrank(msgSender);
}
// Start perpetual prank from an address that has some ether
// tx.origin is set to the origin parameter
function startHoax(address msgSender, address origin) internal virtual {
vm.deal(msgSender, 1 << 128);
vm.startPrank(msgSender, origin);
}
function startHoax(address msgSender, address origin, uint256 give) internal virtual {
vm.deal(msgSender, give);
vm.startPrank(msgSender, origin);
}
function changePrank(address msgSender) internal virtual {
console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead.");
vm.stopPrank();
vm.startPrank(msgSender);
}
function changePrank(address msgSender, address txOrigin) internal virtual {
vm.stopPrank();
vm.startPrank(msgSender, txOrigin);
}
// The same as Vm's `deal`
// Use the alternative signature for ERC20 tokens
function deal(address to, uint256 give) internal virtual {
vm.deal(to, give);
}
// Set the balance of an account for any ERC20 token
// Use the alternative signature to update `totalSupply`
function deal(address token, address to, uint256 give) internal virtual {
deal(token, to, give, false);
}
// Set the balance of an account for any ERC1155 token
// Use the alternative signature to update `totalSupply`
function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {
dealERC1155(token, to, id, give, false);
}
function deal(address token, address to, uint256 give, bool adjust) internal virtual {
// get current balance
(, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
uint256 prevBal = abi.decode(balData, (uint256));
// update balance
stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);
// update total supply
if (adjust) {
(, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));
uint256 totSup = abi.decode(totSupData, (uint256));
if (give < prevBal) {
totSup -= (prevBal - give);
} else {
totSup += (give - prevBal);
}
stdstore.target(token).sig(0x18160ddd).checked_write(totSup);
}
}
function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {
// get current balance
(, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));
uint256 prevBal = abi.decode(balData, (uint256));
// update balance
stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);
// update total supply
if (adjust) {
(, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));
require(
totSupData.length != 0,
"StdCheats deal(address,address,uint,uint,bool): target contract is not ERC1155Supply."
);
uint256 totSup = abi.decode(totSupData, (uint256));
if (give < prevBal) {
totSup -= (prevBal - give);
} else {
totSup += (give - prevBal);
}
stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);
}
}
function dealERC721(address token, address to, uint256 id) internal virtual {
// check if token id is already minted and the actual owner.
(bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));
require(successMinted, "StdCheats deal(address,address,uint,bool): id not minted.");
// get owner current balance
(, bytes memory fromBalData) =
token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));
uint256 fromPrevBal = abi.decode(fromBalData, (uint256));
// get new user current balance
(, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
uint256 toPrevBal = abi.decode(toBalData, (uint256));
// update balances
stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);
stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);
// update owner
stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);
}
function deployCodeTo(string memory what, address where) internal virtual {
deployCodeTo(what, "", 0, where);
}
function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {
deployCodeTo(what, args, 0, where);
}
function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {
bytes memory creationCode = vm.getCode(what);
vm.etch(where, abi.encodePacked(creationCode, args));
(bool success, bytes memory runtimeBytecode) = where.call{value: value}("");
require(success, "StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.");
vm.etch(where, runtimeBytecode);
}
// Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.
function console2_log_StdCheats(string memory p0) private view {
(bool status,) = address(CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature("log(string)", p0));
status;
}
}// SPDX-License-Identifier: MIT
// Panics work for versions >=0.8.0, but we lowered the pragma to make this compatible with Test
pragma solidity >=0.6.2 <0.9.0;
library stdError {
bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01);
bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11);
bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12);
bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21);
bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22);
bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31);
bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32);
bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41);
bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51);
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
pragma experimental ABIEncoderV2;
abstract contract StdInvariant {
struct FuzzSelector {
address addr;
bytes4[] selectors;
}
struct FuzzInterface {
address addr;
string[] artifacts;
}
address[] private _excludedContracts;
address[] private _excludedSenders;
address[] private _targetedContracts;
address[] private _targetedSenders;
string[] private _excludedArtifacts;
string[] private _targetedArtifacts;
FuzzSelector[] private _targetedArtifactSelectors;
FuzzSelector[] private _targetedSelectors;
FuzzInterface[] private _targetedInterfaces;
// Functions for users:
// These are intended to be called in tests.
function excludeContract(address newExcludedContract_) internal {
_excludedContracts.push(newExcludedContract_);
}
function excludeSender(address newExcludedSender_) internal {
_excludedSenders.push(newExcludedSender_);
}
function excludeArtifact(string memory newExcludedArtifact_) internal {
_excludedArtifacts.push(newExcludedArtifact_);
}
function targetArtifact(string memory newTargetedArtifact_) internal {
_targetedArtifacts.push(newTargetedArtifact_);
}
function targetArtifactSelector(FuzzSelector memory newTargetedArtifactSelector_) internal {
_targetedArtifactSelectors.push(newTargetedArtifactSelector_);
}
function targetContract(address newTargetedContract_) internal {
_targetedContracts.push(newTargetedContract_);
}
function targetSelector(FuzzSelector memory newTargetedSelector_) internal {
_targetedSelectors.push(newTargetedSelector_);
}
function targetSender(address newTargetedSender_) internal {
_targetedSenders.push(newTargetedSender_);
}
function targetInterface(FuzzInterface memory newTargetedInterface_) internal {
_targetedInterfaces.push(newTargetedInterface_);
}
// Functions for forge:
// These are called by forge to run invariant tests and don't need to be called in tests.
function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) {
excludedArtifacts_ = _excludedArtifacts;
}
function excludeContracts() public view returns (address[] memory excludedContracts_) {
excludedContracts_ = _excludedContracts;
}
function excludeSenders() public view returns (address[] memory excludedSenders_) {
excludedSenders_ = _excludedSenders;
}
function targetArtifacts() public view returns (string[] memory targetedArtifacts_) {
targetedArtifacts_ = _targetedArtifacts;
}
function targetArtifactSelectors() public view returns (FuzzSelector[] memory targetedArtifactSelectors_) {
targetedArtifactSelectors_ = _targetedArtifactSelectors;
}
function targetContracts() public view returns (address[] memory targetedContracts_) {
targetedContracts_ = _targetedContracts;
}
function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) {
targetedSelectors_ = _targetedSelectors;
}
function targetSenders() public view returns (address[] memory targetedSenders_) {
targetedSenders_ = _targetedSenders;
}
function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_) {
targetedInterfaces_ = _targetedInterfaces;
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.0 <0.9.0;
pragma experimental ABIEncoderV2;
import {VmSafe} from "./Vm.sol";
// Helpers for parsing and writing JSON files
// To parse:
// ```
// using stdJson for string;
// string memory json = vm.readFile("some_peth");
// json.parseUint("<json_path>");
// ```
// To write:
// ```
// using stdJson for string;
// string memory json = "deploymentArtifact";
// Contract contract = new Contract();
// json.serialize("contractAddress", address(contract));
// json = json.serialize("deploymentTimes", uint(1));
// // store the stringified JSON to the 'json' variable we have been using as a key
// // as we won't need it any longer
// string memory json2 = "finalArtifact";
// string memory final = json2.serialize("depArtifact", json);
// final.write("<some_path>");
// ```
library stdJson {
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {
return vm.parseJson(json, key);
}
function readUint(string memory json, string memory key) internal pure returns (uint256) {
return vm.parseJsonUint(json, key);
}
function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {
return vm.parseJsonUintArray(json, key);
}
function readInt(string memory json, string memory key) internal pure returns (int256) {
return vm.parseJsonInt(json, key);
}
function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {
return vm.parseJsonIntArray(json, key);
}
function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {
return vm.parseJsonBytes32(json, key);
}
function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {
return vm.parseJsonBytes32Array(json, key);
}
function readString(string memory json, string memory key) internal pure returns (string memory) {
return vm.parseJsonString(json, key);
}
function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {
return vm.parseJsonStringArray(json, key);
}
function readAddress(string memory json, string memory key) internal pure returns (address) {
return vm.parseJsonAddress(json, key);
}
function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {
return vm.parseJsonAddressArray(json, key);
}
function readBool(string memory json, string memory key) internal pure returns (bool) {
return vm.parseJsonBool(json, key);
}
function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {
return vm.parseJsonBoolArray(json, key);
}
function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {
return vm.parseJsonBytes(json, key);
}
function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {
return vm.parseJsonBytesArray(json, key);
}
function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
return vm.serializeJson(jsonKey, rootObject);
}
function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
return vm.serializeBool(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, bool[] memory value)
internal
returns (string memory)
{
return vm.serializeBool(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
return vm.serializeUint(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, uint256[] memory value)
internal
returns (string memory)
{
return vm.serializeUint(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
return vm.serializeInt(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, int256[] memory value)
internal
returns (string memory)
{
return vm.serializeInt(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
return vm.serializeAddress(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, address[] memory value)
internal
returns (string memory)
{
return vm.serializeAddress(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
return vm.serializeBytes32(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
internal
returns (string memory)
{
return vm.serializeBytes32(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
return vm.serializeBytes(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, bytes[] memory value)
internal
returns (string memory)
{
return vm.serializeBytes(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, string memory value)
internal
returns (string memory)
{
return vm.serializeString(jsonKey, key, value);
}
function serialize(string memory jsonKey, string memory key, string[] memory value)
internal
returns (string memory)
{
return vm.serializeString(jsonKey, key, value);
}
function write(string memory jsonKey, string memory path) internal {
vm.writeJson(jsonKey, path);
}
function write(string memory jsonKey, string memory path, string memory valueKey) internal {
vm.writeJson(jsonKey, path, valueKey);
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
library stdMath {
int256 private constant INT256_MIN = -57896044618658097711785492504343953926634992332820282019728792003956564819968;
function abs(int256 a) internal pure returns (uint256) {
// Required or it will fail when `a = type(int256).min`
if (a == INT256_MIN) {
return 57896044618658097711785492504343953926634992332820282019728792003956564819968;
}
return uint256(a > 0 ? a : -a);
}
function delta(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a - b : b - a;
}
function delta(int256 a, int256 b) internal pure returns (uint256) {
// a and b are of the same sign
// this works thanks to two's complement, the left-most bit is the sign bit
if ((a ^ b) > -1) {
return delta(abs(a), abs(b));
}
// a and b are of opposite signs
return abs(a) + abs(b);
}
function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 absDelta = delta(a, b);
return absDelta * 1e18 / b;
}
function percentDelta(int256 a, int256 b) internal pure returns (uint256) {
uint256 absDelta = delta(a, b);
uint256 absB = abs(b);
return absDelta * 1e18 / absB;
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
import {Vm} from "./Vm.sol";
struct StdStorage {
mapping(address => mapping(bytes4 => mapping(bytes32 => uint256))) slots;
mapping(address => mapping(bytes4 => mapping(bytes32 => bool))) finds;
bytes32[] _keys;
bytes4 _sig;
uint256 _depth;
address _target;
bytes32 _set;
}
library stdStorageSafe {
event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);
event WARNING_UninitedSlot(address who, uint256 slot);
Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
function sigs(string memory sigStr) internal pure returns (bytes4) {
return bytes4(keccak256(bytes(sigStr)));
}
/// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against
// slot complexity:
// if flat, will be bytes32(uint256(uint));
// if map, will be keccak256(abi.encode(key, uint(slot)));
// if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));
// if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);
function find(StdStorage storage self) internal returns (uint256) {
address who = self._target;
bytes4 fsig = self._sig;
uint256 field_depth = self._depth;
bytes32[] memory ins = self._keys;
// calldata to test against
if (self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]) {
return self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))];
}
bytes memory cald = abi.encodePacked(fsig, flatten(ins));
vm.record();
bytes32 fdat;
{
(, bytes memory rdat) = who.staticcall(cald);
fdat = bytesToBytes32(rdat, 32 * field_depth);
}
(bytes32[] memory reads,) = vm.accesses(address(who));
if (reads.length == 1) {
bytes32 curr = vm.load(who, reads[0]);
if (curr == bytes32(0)) {
emit WARNING_UninitedSlot(who, uint256(reads[0]));
}
if (fdat != curr) {
require(
false,
"stdStorage find(StdStorage): Packed slot. This would cause dangerous overwriting and currently isn't supported."
);
}
emit SlotFound(who, fsig, keccak256(abi.encodePacked(ins, field_depth)), uint256(reads[0]));
self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = uint256(reads[0]);
self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = true;
} else if (reads.length > 1) {
for (uint256 i = 0; i < reads.length; i++) {
bytes32 prev = vm.load(who, reads[i]);
if (prev == bytes32(0)) {
emit WARNING_UninitedSlot(who, uint256(reads[i]));
}
if (prev != fdat) {
continue;
}
bytes32 new_val = ~prev;
// store
vm.store(who, reads[i], new_val);
bool success;
{
bytes memory rdat;
(success, rdat) = who.staticcall(cald);
fdat = bytesToBytes32(rdat, 32 * field_depth);
}
if (success && fdat == new_val) {
// we found which of the slots is the actual one
emit SlotFound(who, fsig, keccak256(abi.encodePacked(ins, field_depth)), uint256(reads[i]));
self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = uint256(reads[i]);
self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))] = true;
vm.store(who, reads[i], prev);
break;
}
vm.store(who, reads[i], prev);
}
} else {
revert("stdStorage find(StdStorage): No storage use detected for target.");
}
require(
self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))],
"stdStorage find(StdStorage): Slot(s) not found."
);
delete self._target;
delete self._sig;
delete self._keys;
delete self._depth;
return self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))];
}
function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
self._target = _target;
return self;
}
function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
self._sig = _sig;
return self;
}
function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
self._sig = sigs(_sig);
return self;
}
function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
self._keys.push(bytes32(uint256(uint160(who))));
return self;
}
function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
self._keys.push(bytes32(amt));
return self;
}
function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
self._keys.push(key);
return self;
}
function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
self._depth = _depth;
return self;
}
function read(StdStorage storage self) private returns (bytes memory) {
address t = self._target;
uint256 s = find(self);
return abi.encode(vm.load(t, bytes32(s)));
}
function read_bytes32(StdStorage storage self) internal returns (bytes32) {
return abi.decode(read(self), (bytes32));
}
function read_bool(StdStorage storage self) internal returns (bool) {
int256 v = read_int(self);
if (v == 0) return false;
if (v == 1) return true;
revert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.");
}
function read_address(StdStorage storage self) internal returns (address) {
return abi.decode(read(self), (address));
}
function read_uint(StdStorage storage self) internal returns (uint256) {
return abi.decode(read(self), (uint256));
}
function read_int(StdStorage storage self) internal returns (int256) {
return abi.decode(read(self), (int256));
}
function parent(StdStorage storage self) internal returns (uint256, bytes32) {
address who = self._target;
uint256 field_depth = self._depth;
vm.startMappingRecording();
uint256 child = find(self) - field_depth;
(bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
if (!found) {
revert(
"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
);
}
return (uint256(parent_slot), key);
}
function root(StdStorage storage self) internal returns (uint256) {
address who = self._target;
uint256 field_depth = self._depth;
vm.startMappingRecording();
uint256 child = find(self) - field_depth;
bool found;
bytes32 root_slot;
bytes32 parent_slot;
(found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
if (!found) {
revert(
"stdStorage read_bool(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
);
}
while (found) {
root_slot = parent_slot;
(found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));
}
return uint256(root_slot);
}
function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {
bytes32 out;
uint256 max = b.length > 32 ? 32 : b.length;
for (uint256 i = 0; i < max; i++) {
out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);
}
return out;
}
function flatten(bytes32[] memory b) private pure returns (bytes memory) {
bytes memory result = new bytes(b.length * 32);
for (uint256 i = 0; i < b.length; i++) {
bytes32 k = b[i];
/// @solidity memory-safe-assembly
assembly {
mstore(add(result, add(32, mul(32, i))), k)
}
}
return result;
}
}
library stdStorage {
Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
function sigs(string memory sigStr) internal pure returns (bytes4) {
return stdStorageSafe.sigs(sigStr);
}
function find(StdStorage storage self) internal returns (uint256) {
return stdStorageSafe.find(self);
}
function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
return stdStorageSafe.target(self, _target);
}
function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
return stdStorageSafe.sig(self, _sig);
}
function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
return stdStorageSafe.sig(self, _sig);
}
function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
return stdStorageSafe.with_key(self, who);
}
function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
return stdStorageSafe.with_key(self, amt);
}
function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
return stdStorageSafe.with_key(self, key);
}
function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
return stdStorageSafe.depth(self, _depth);
}
function checked_write(StdStorage storage self, address who) internal {
checked_write(self, bytes32(uint256(uint160(who))));
}
function checked_write(StdStorage storage self, uint256 amt) internal {
checked_write(self, bytes32(amt));
}
function checked_write_int(StdStorage storage self, int256 val) internal {
checked_write(self, bytes32(uint256(val)));
}
function checked_write(StdStorage storage self, bool write) internal {
bytes32 t;
/// @solidity memory-safe-assembly
assembly {
t := write
}
checked_write(self, t);
}
function checked_write(StdStorage storage self, bytes32 set) internal {
address who = self._target;
bytes4 fsig = self._sig;
uint256 field_depth = self._depth;
bytes32[] memory ins = self._keys;
bytes memory cald = abi.encodePacked(fsig, flatten(ins));
if (!self.finds[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]) {
find(self);
}
bytes32 slot = bytes32(self.slots[who][fsig][keccak256(abi.encodePacked(ins, field_depth))]);
bytes32 fdat;
{
(, bytes memory rdat) = who.staticcall(cald);
fdat = bytesToBytes32(rdat, 32 * field_depth);
}
bytes32 curr = vm.load(who, slot);
if (fdat != curr) {
require(
false,
"stdStorage find(StdStorage): Packed slot. This would cause dangerous overwriting and currently isn't supported."
);
}
vm.store(who, slot, set);
delete self._target;
delete self._sig;
delete self._keys;
delete self._depth;
}
function read_bytes32(StdStorage storage self) internal returns (bytes32) {
return stdStorageSafe.read_bytes32(self);
}
function read_bool(StdStorage storage self) internal returns (bool) {
return stdStorageSafe.read_bool(self);
}
function read_address(StdStorage storage self) internal returns (address) {
return stdStorageSafe.read_address(self);
}
function read_uint(StdStorage storage self) internal returns (uint256) {
return stdStorageSafe.read_uint(self);
}
function read_int(StdStorage storage self) internal returns (int256) {
return stdStorageSafe.read_int(self);
}
function parent(StdStorage storage self) internal returns (uint256, bytes32) {
return stdStorageSafe.parent(self);
}
function root(StdStorage storage self) internal returns (uint256) {
return stdStorageSafe.root(self);
}
// Private function so needs to be copied over
function bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {
bytes32 out;
uint256 max = b.length > 32 ? 32 : b.length;
for (uint256 i = 0; i < max; i++) {
out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);
}
return out;
}
// Private function so needs to be copied over
function flatten(bytes32[] memory b) private pure returns (bytes memory) {
bytes memory result = new bytes(b.length * 32);
for (uint256 i = 0; i < b.length; i++) {
bytes32 k = b[i];
/// @solidity memory-safe-assembly
assembly {
mstore(add(result, add(32, mul(32, i))), k)
}
}
return result;
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
import {VmSafe} from "./Vm.sol";
library StdStyle {
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
string constant RED = "\u001b[91m";
string constant GREEN = "\u001b[92m";
string constant YELLOW = "\u001b[93m";
string constant BLUE = "\u001b[94m";
string constant MAGENTA = "\u001b[95m";
string constant CYAN = "\u001b[96m";
string constant BOLD = "\u001b[1m";
string constant DIM = "\u001b[2m";
string constant ITALIC = "\u001b[3m";
string constant UNDERLINE = "\u001b[4m";
string constant INVERSE = "\u001b[7m";
string constant RESET = "\u001b[0m";
function styleConcat(string memory style, string memory self) private pure returns (string memory) {
return string(abi.encodePacked(style, self, RESET));
}
function red(string memory self) internal pure returns (string memory) {
return styleConcat(RED, self);
}
function red(uint256 self) internal pure returns (string memory) {
return red(vm.toString(self));
}
function red(int256 self) internal pure returns (string memory) {
return red(vm.toString(self));
}
function red(address self) internal pure returns (string memory) {
return red(vm.toString(self));
}
function red(bool self) internal pure returns (string memory) {
return red(vm.toString(self));
}
function redBytes(bytes memory self) internal pure returns (string memory) {
return red(vm.toString(self));
}
function redBytes32(bytes32 self) internal pure returns (string memory) {
return red(vm.toString(self));
}
function green(string memory self) internal pure returns (string memory) {
return styleConcat(GREEN, self);
}
function green(uint256 self) internal pure returns (string memory) {
return green(vm.toString(self));
}
function green(int256 self) internal pure returns (string memory) {
return green(vm.toString(self));
}
function green(address self) internal pure returns (string memory) {
return green(vm.toString(self));
}
function green(bool self) internal pure returns (string memory) {
return green(vm.toString(self));
}
function greenBytes(bytes memory self) internal pure returns (string memory) {
return green(vm.toString(self));
}
function greenBytes32(bytes32 self) internal pure returns (string memory) {
return green(vm.toString(self));
}
function yellow(string memory self) internal pure returns (string memory) {
return styleConcat(YELLOW, self);
}
function yellow(uint256 self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
function yellow(int256 self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
function yellow(address self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
function yellow(bool self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
function yellowBytes(bytes memory self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
function yellowBytes32(bytes32 self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
function blue(string memory self) internal pure returns (string memory) {
return styleConcat(BLUE, self);
}
function blue(uint256 self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
function blue(int256 self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
function blue(address self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
function blue(bool self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
function blueBytes(bytes memory self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
function blueBytes32(bytes32 self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
function magenta(string memory self) internal pure returns (string memory) {
return styleConcat(MAGENTA, self);
}
function magenta(uint256 self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
function magenta(int256 self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
function magenta(address self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
function magenta(bool self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
function magentaBytes(bytes memory self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
function magentaBytes32(bytes32 self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
function cyan(string memory self) internal pure returns (string memory) {
return styleConcat(CYAN, self);
}
function cyan(uint256 self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
function cyan(int256 self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
function cyan(address self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
function cyan(bool self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
function cyanBytes(bytes memory self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
function cyanBytes32(bytes32 self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
function bold(string memory self) internal pure returns (string memory) {
return styleConcat(BOLD, self);
}
function bold(uint256 self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
function bold(int256 self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
function bold(address self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
function bold(bool self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
function boldBytes(bytes memory self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
function boldBytes32(bytes32 self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
function dim(string memory self) internal pure returns (string memory) {
return styleConcat(DIM, self);
}
function dim(uint256 self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
function dim(int256 self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
function dim(address self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
function dim(bool self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
function dimBytes(bytes memory self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
function dimBytes32(bytes32 self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
function italic(string memory self) internal pure returns (string memory) {
return styleConcat(ITALIC, self);
}
function italic(uint256 self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
function italic(int256 self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
function italic(address self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
function italic(bool self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
function italicBytes(bytes memory self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
function italicBytes32(bytes32 self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
function underline(string memory self) internal pure returns (string memory) {
return styleConcat(UNDERLINE, self);
}
function underline(uint256 self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
function underline(int256 self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
function underline(address self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
function underline(bool self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
function underlineBytes(bytes memory self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
function underlineBytes32(bytes32 self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
function inverse(string memory self) internal pure returns (string memory) {
return styleConcat(INVERSE, self);
}
function inverse(uint256 self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
function inverse(int256 self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
function inverse(address self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
function inverse(bool self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
function inverseBytes(bytes memory self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
function inverseBytes32(bytes32 self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
pragma experimental ABIEncoderV2;
import {IMulticall3} from "./interfaces/IMulticall3.sol";
import {MockERC20} from "./mocks/MockERC20.sol";
import {MockERC721} from "./mocks/MockERC721.sol";
import {VmSafe} from "./Vm.sol";
abstract contract StdUtils {
/*//////////////////////////////////////////////////////////////////////////
CONSTANTS
//////////////////////////////////////////////////////////////////////////*/
IMulticall3 private constant multicall = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
address private constant CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
uint256 private constant INT256_MIN_ABS =
57896044618658097711785492504343953926634992332820282019728792003956564819968;
uint256 private constant SECP256K1_ORDER =
115792089237316195423570985008687907852837564279074904382605163141518161494337;
uint256 private constant UINT256_MAX =
115792089237316195423570985008687907853269984665640564039457584007913129639935;
// Used by default when deploying with create2, https://github.com/Arachnid/deterministic-deployment-proxy.
address private constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
/*//////////////////////////////////////////////////////////////////////////
INTERNAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
require(min <= max, "StdUtils bound(uint256,uint256,uint256): Max is less than min.");
// If x is between min and max, return x directly. This is to ensure that dictionary values
// do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188
if (x >= min && x <= max) return x;
uint256 size = max - min + 1;
// If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the UINT256_MAX side.
// This helps ensure coverage of the min/max values.
if (x <= 3 && size > x) return min + x;
if (x >= UINT256_MAX - 3 && size > UINT256_MAX - x) return max - (UINT256_MAX - x);
// Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.
if (x > max) {
uint256 diff = x - max;
uint256 rem = diff % size;
if (rem == 0) return max;
result = min + rem - 1;
} else if (x < min) {
uint256 diff = min - x;
uint256 rem = diff % size;
if (rem == 0) return min;
result = max - rem + 1;
}
}
function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
result = _bound(x, min, max);
console2_log_StdUtils("Bound Result", result);
}
function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
require(min <= max, "StdUtils bound(int256,int256,int256): Max is less than min.");
// Shifting all int256 values to uint256 to use _bound function. The range of two types are:
// int256 : -(2**255) ~ (2**255 - 1)
// uint256: 0 ~ (2**256 - 1)
// So, add 2**255, INT256_MIN_ABS to the integer values.
//
// If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.
// So, use `~uint256(x) + 1` instead.
uint256 _x = x < 0 ? (INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + INT256_MIN_ABS);
uint256 _min = min < 0 ? (INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + INT256_MIN_ABS);
uint256 _max = max < 0 ? (INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + INT256_MIN_ABS);
uint256 y = _bound(_x, _min, _max);
// To move it back to int256 value, subtract INT256_MIN_ABS at here.
result = y < INT256_MIN_ABS ? int256(~(INT256_MIN_ABS - y) + 1) : int256(y - INT256_MIN_ABS);
}
function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
result = _bound(x, min, max);
console2_log_StdUtils("Bound result", vm.toString(result));
}
function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {
result = _bound(privateKey, 1, SECP256K1_ORDER - 1);
}
function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {
require(b.length <= 32, "StdUtils bytesToUint(bytes): Bytes length exceeds 32.");
return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
}
/// @dev Compute the address a contract will be deployed at for a given deployer address and nonce
/// @notice adapted from Solmate implementation (https://github.com/Rari-Capital/solmate/blob/main/src/utils/LibRLP.sol)
function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {
console2_log_StdUtils("computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.");
return vm.computeCreateAddress(deployer, nonce);
}
function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)
internal
pure
virtual
returns (address)
{
console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
return vm.computeCreate2Address(salt, initcodeHash, deployer);
}
/// @dev returns the address of a contract created with CREATE2 using the default CREATE2 deployer
function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {
console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
return vm.computeCreate2Address(salt, initCodeHash);
}
/// @dev returns an initialized mock ERC20 contract
function deployMockERC20(string memory name, string memory symbol, uint8 decimals)
internal
returns (MockERC20 mock)
{
mock = new MockERC20();
mock.initialize(name, symbol, decimals);
}
/// @dev returns an initialized mock ERC721 contract
function deployMockERC721(string memory name, string memory symbol) internal returns (MockERC721 mock) {
mock = new MockERC721();
mock.initialize(name, symbol);
}
/// @dev returns the hash of the init code (creation code + no args) used in CREATE2 with no constructor arguments
/// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {
return hashInitCode(creationCode, "");
}
/// @dev returns the hash of the init code (creation code + ABI-encoded args) used in CREATE2
/// @param creationCode the creation code of a contract C, as returned by type(C).creationCode
/// @param args the ABI-encoded arguments to the constructor of C
function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(creationCode, args));
}
// Performs a single call with Multicall3 to query the ERC-20 token balances of the given addresses.
function getTokenBalances(address token, address[] memory addresses)
internal
virtual
returns (uint256[] memory balances)
{
uint256 tokenCodeSize;
assembly {
tokenCodeSize := extcodesize(token)
}
require(tokenCodeSize > 0, "StdUtils getTokenBalances(address,address[]): Token address is not a contract.");
// ABI encode the aggregate call to Multicall3.
uint256 length = addresses.length;
IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);
for (uint256 i = 0; i < length; ++i) {
// 0x70a08231 = bytes4("balanceOf(address)"))
calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});
}
// Make the aggregate call.
(, bytes[] memory returnData) = multicall.aggregate(calls);
// ABI decode the return data and return the balances.
balances = new uint256[](length);
for (uint256 i = 0; i < length; ++i) {
balances[i] = abi.decode(returnData[i], (uint256));
}
}
/*//////////////////////////////////////////////////////////////////////////
PRIVATE FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
function addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {
return address(uint160(uint256(bytesValue)));
}
// This section is used to prevent the compilation of console, which shortens the compilation time when console is
// not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid
// any breaking changes to function signatures.
function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)
internal
pure
returns (function(bytes memory) internal pure fnOut)
{
assembly {
fnOut := fnIn
}
}
function _sendLogPayload(bytes memory payload) internal pure {
_castLogPayloadViewToPure(_sendLogPayloadView)(payload);
}
function _sendLogPayloadView(bytes memory payload) private view {
uint256 payloadLength = payload.length;
address consoleAddress = CONSOLE2_ADDRESS;
/// @solidity memory-safe-assembly
assembly {
let payloadStart := add(payload, 32)
let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
}
}
function console2_log_StdUtils(string memory p0) private pure {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function console2_log_StdUtils(string memory p0, uint256 p1) private pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
}
function console2_log_StdUtils(string memory p0, string memory p1) private pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
pragma experimental ABIEncoderV2;
// 💬 ABOUT
// Forge Std's default Test.
// 🧩 MODULES
import {console} from "./console.sol";
import {console2} from "./console2.sol";
import {safeconsole} from "./safeconsole.sol";
import {StdAssertions} from "./StdAssertions.sol";
import {StdChains} from "./StdChains.sol";
import {StdCheats} from "./StdCheats.sol";
import {stdError} from "./StdError.sol";
import {StdInvariant} from "./StdInvariant.sol";
import {stdJson} from "./StdJson.sol";
import {stdMath} from "./StdMath.sol";
import {StdStorage, stdStorage} from "./StdStorage.sol";
import {StdStyle} from "./StdStyle.sol";
import {StdUtils} from "./StdUtils.sol";
import {Vm} from "./Vm.sol";
// 📦 BOILERPLATE
import {TestBase} from "./Base.sol";
import {DSTest} from "ds-test/test.sol";
// ⭐️ TEST
abstract contract Test is TestBase, DSTest, StdAssertions, StdChains, StdCheats, StdInvariant, StdUtils {
// Note: IS_TEST() must return true.
// Note: Must have failure system, https://github.com/dapphub/ds-test/blob/cd98eff28324bfac652e63a239a60632a761790b/src/test.sol#L39-L76.
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
pragma experimental ABIEncoderV2;
// Cheatcodes are marked as view/pure/none using the following rules:
// 0. A call's observable behaviour includes its return value, logs, reverts and state writes,
// 1. If you can influence a later call's observable behaviour, you're neither `view` nor `pure (you are modifying some state be it the EVM, interpreter, filesystem, etc),
// 2. Otherwise if you can be influenced by an earlier call, or if reading some state, you're `view`,
// 3. Otherwise you're `pure`.
// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may
// result in Script simulations differing from on-chain execution. It is recommended to only use
// these cheats in scripts.
interface VmSafe {
// ======== Types ========
enum CallerMode {
None,
Broadcast,
RecurrentBroadcast,
Prank,
RecurrentPrank
}
enum AccountAccessKind {
Call,
DelegateCall,
CallCode,
StaticCall,
Create,
SelfDestruct,
Resume,
Balance,
Extcodesize,
Extcodehash,
Extcodecopy
}
struct Log {
bytes32[] topics;
bytes data;
address emitter;
}
struct Rpc {
string key;
string url;
}
struct EthGetLogs {
address emitter;
bytes32[] topics;
bytes data;
bytes32 blockHash;
uint64 blockNumber;
bytes32 transactionHash;
uint64 transactionIndex;
uint256 logIndex;
bool removed;
}
struct DirEntry {
string errorMessage;
string path;
uint64 depth;
bool isDir;
bool isSymlink;
}
struct FsMetadata {
bool isDir;
bool isSymlink;
uint256 length;
bool readOnly;
uint256 modified;
uint256 accessed;
uint256 created;
}
struct Wallet {
address addr;
uint256 publicKeyX;
uint256 publicKeyY;
uint256 privateKey;
}
struct FfiResult {
int32 exitCode;
bytes stdout;
bytes stderr;
}
struct ChainInfo {
uint256 forkId;
uint256 chainId;
}
struct AccountAccess {
ChainInfo chainInfo;
AccountAccessKind kind;
address account;
address accessor;
bool initialized;
uint256 oldBalance;
uint256 newBalance;
bytes deployedCode;
uint256 value;
bytes data;
bool reverted;
StorageAccess[] storageAccesses;
}
struct StorageAccess {
address account;
bytes32 slot;
bool isWrite;
bytes32 previousValue;
bytes32 newValue;
bool reverted;
}
// ======== EVM ========
// Gets the address for a given private key
function addr(uint256 privateKey) external pure returns (address keyAddr);
// Gets the nonce of an account.
// See `getNonce(Wallet memory wallet)` for an alternative way to manage users and get their nonces.
function getNonce(address account) external view returns (uint64 nonce);
// Loads a storage slot from an address
function load(address target, bytes32 slot) external view returns (bytes32 data);
// Signs data
function sign(uint256 privateKey, bytes32 digest) external pure returns (uint8 v, bytes32 r, bytes32 s);
// -------- Record Storage --------
// Records all storage reads and writes
function record() external;
// Gets all accessed reads and write slot from a `vm.record` session, for a given address
function accesses(address target) external returns (bytes32[] memory readSlots, bytes32[] memory writeSlots);
// Record all account accesses as part of CREATE, CALL or SELFDESTRUCT opcodes in order,
// along with the context of the calls.
function startStateDiffRecording() external;
// Returns an ordered array of all account accesses from a `vm.startStateDiffRecording` session.
function stopAndReturnStateDiff() external returns (AccountAccess[] memory accountAccesses);
// -------- Recording Map Writes --------
// Starts recording all map SSTOREs for later retrieval.
function startMappingRecording() external;
// Stops recording all map SSTOREs for later retrieval and clears the recorded data.
function stopMappingRecording() external;
// Gets the number of elements in the mapping at the given slot, for a given address.
function getMappingLength(address target, bytes32 mappingSlot) external returns (uint256 length);
// Gets the elements at index idx of the mapping at the given slot, for a given address. The
// index must be less than the length of the mapping (i.e. the number of keys in the mapping).
function getMappingSlotAt(address target, bytes32 mappingSlot, uint256 idx) external returns (bytes32 value);
// Gets the map key and parent of a mapping at a given slot, for a given address.
function getMappingKeyAndParentOf(address target, bytes32 elementSlot)
external
returns (bool found, bytes32 key, bytes32 parent);
// -------- Record Logs --------
// Record all the transaction logs
function recordLogs() external;
// Gets all the recorded logs
function getRecordedLogs() external returns (Log[] memory logs);
// -------- Gas Metering --------
// It's recommend to use the `noGasMetering` modifier included with forge-std, instead of
// using these functions directly.
// Pauses gas metering (i.e. gas usage is not counted). Noop if already paused.
function pauseGasMetering() external;
// Resumes gas metering (i.e. gas usage is counted again). Noop if already on.
function resumeGasMetering() external;
// -------- RPC Methods --------
/// Gets all the logs according to specified filter.
function eth_getLogs(uint256 fromBlock, uint256 toBlock, address target, bytes32[] calldata topics)
external
returns (EthGetLogs[] memory logs);
// Performs an Ethereum JSON-RPC request to the current fork URL.
function rpc(string calldata method, string calldata params) external returns (bytes memory data);
// ======== Test Configuration ========
// If the condition is false, discard this run's fuzz inputs and generate new ones.
function assume(bool condition) external pure;
// Writes a breakpoint to jump to in the debugger
function breakpoint(string calldata char) external;
// Writes a conditional breakpoint to jump to in the debugger
function breakpoint(string calldata char, bool value) external;
// Returns the RPC url for the given alias
function rpcUrl(string calldata rpcAlias) external view returns (string memory json);
// Returns all rpc urls and their aliases `[alias, url][]`
function rpcUrls() external view returns (string[2][] memory urls);
// Returns all rpc urls and their aliases as structs.
function rpcUrlStructs() external view returns (Rpc[] memory urls);
// Suspends execution of the main thread for `duration` milliseconds
function sleep(uint256 duration) external;
// ======== OS and Filesystem ========
// -------- Metadata --------
// Returns true if the given path points to an existing entity, else returns false
function exists(string calldata path) external returns (bool result);
// Given a path, query the file system to get information about a file, directory, etc.
function fsMetadata(string calldata path) external view returns (FsMetadata memory metadata);
// Returns true if the path exists on disk and is pointing at a directory, else returns false
function isDir(string calldata path) external returns (bool result);
// Returns true if the path exists on disk and is pointing at a regular file, else returns false
function isFile(string calldata path) external returns (bool result);
// Get the path of the current project root.
function projectRoot() external view returns (string memory path);
// Returns the time since unix epoch in milliseconds
function unixTime() external returns (uint256 milliseconds);
// -------- Reading and writing --------
// Closes file for reading, resetting the offset and allowing to read it from beginning with readLine.
// `path` is relative to the project root.
function closeFile(string calldata path) external;
// Copies the contents of one file to another. This function will **overwrite** the contents of `to`.
// On success, the total number of bytes copied is returned and it is equal to the length of the `to` file as reported by `metadata`.
// Both `from` and `to` are relative to the project root.
function copyFile(string calldata from, string calldata to) external returns (uint64 copied);
// Creates a new, empty directory at the provided path.
// This cheatcode will revert in the following situations, but is not limited to just these cases:
// - User lacks permissions to modify `path`.
// - A parent of the given path doesn't exist and `recursive` is false.
// - `path` already exists and `recursive` is false.
// `path` is relative to the project root.
function createDir(string calldata path, bool recursive) external;
// Reads the directory at the given path recursively, up to `max_depth`.
// `max_depth` defaults to 1, meaning only the direct children of the given directory will be returned.
// Follows symbolic links if `follow_links` is true.
function readDir(string calldata path) external view returns (DirEntry[] memory entries);
function readDir(string calldata path, uint64 maxDepth) external view returns (DirEntry[] memory entries);
function readDir(string calldata path, uint64 maxDepth, bool followLinks)
external
view
returns (DirEntry[] memory entries);
// Reads the entire content of file to string. `path` is relative to the project root.
function readFile(string calldata path) external view returns (string memory data);
// Reads the entire content of file as binary. `path` is relative to the project root.
function readFileBinary(string calldata path) external view returns (bytes memory data);
// Reads next line of file to string.
function readLine(string calldata path) external view returns (string memory line);
// Reads a symbolic link, returning the path that the link points to.
// This cheatcode will revert in the following situations, but is not limited to just these cases:
// - `path` is not a symbolic link.
// - `path` does not exist.
function readLink(string calldata linkPath) external view returns (string memory targetPath);
// Removes a directory at the provided path.
// This cheatcode will revert in the following situations, but is not limited to just these cases:
// - `path` doesn't exist.
// - `path` isn't a directory.
// - User lacks permissions to modify `path`.
// - The directory is not empty and `recursive` is false.
// `path` is relative to the project root.
function removeDir(string calldata path, bool recursive) external;
// Removes a file from the filesystem.
// This cheatcode will revert in the following situations, but is not limited to just these cases:
// - `path` points to a directory.
// - The file doesn't exist.
// - The user lacks permissions to remove the file.
// `path` is relative to the project root.
function removeFile(string calldata path) external;
// Writes data to file, creating a file if it does not exist, and entirely replacing its contents if it does.
// `path` is relative to the project root.
function writeFile(string calldata path, string calldata data) external;
// Writes binary data to a file, creating a file if it does not exist, and entirely replacing its contents if it does.
// `path` is relative to the project root.
function writeFileBinary(string calldata path, bytes calldata data) external;
// Writes line to file, creating a file if it does not exist.
// `path` is relative to the project root.
function writeLine(string calldata path, string calldata data) external;
// -------- Foreign Function Interface --------
// Performs a foreign function call via the terminal
function ffi(string[] calldata commandInput) external returns (bytes memory result);
// Performs a foreign function call via terminal and returns the exit code, stdout, and stderr
function tryFfi(string[] calldata commandInput) external returns (FfiResult memory result);
// ======== Environment Variables ========
// Sets environment variables
function setEnv(string calldata name, string calldata value) external;
// Reads environment variables, (name) => (value)
function envBool(string calldata name) external view returns (bool value);
function envUint(string calldata name) external view returns (uint256 value);
function envInt(string calldata name) external view returns (int256 value);
function envAddress(string calldata name) external view returns (address value);
function envBytes32(string calldata name) external view returns (bytes32 value);
function envString(string calldata name) external view returns (string memory value);
function envBytes(string calldata name) external view returns (bytes memory value);
// Reads environment variables as arrays
function envBool(string calldata name, string calldata delim) external view returns (bool[] memory value);
function envUint(string calldata name, string calldata delim) external view returns (uint256[] memory value);
function envInt(string calldata name, string calldata delim) external view returns (int256[] memory value);
function envAddress(string calldata name, string calldata delim) external view returns (address[] memory value);
function envBytes32(string calldata name, string calldata delim) external view returns (bytes32[] memory value);
function envString(string calldata name, string calldata delim) external view returns (string[] memory value);
function envBytes(string calldata name, string calldata delim) external view returns (bytes[] memory value);
// Read environment variables with default value
function envOr(string calldata name, bool defaultValue) external returns (bool value);
function envOr(string calldata name, uint256 defaultValue) external returns (uint256 value);
function envOr(string calldata name, int256 defaultValue) external returns (int256 value);
function envOr(string calldata name, address defaultValue) external returns (address value);
function envOr(string calldata name, bytes32 defaultValue) external returns (bytes32 value);
function envOr(string calldata name, string calldata defaultValue) external returns (string memory value);
function envOr(string calldata name, bytes calldata defaultValue) external returns (bytes memory value);
// Read environment variables as arrays with default value
function envOr(string calldata name, string calldata delim, bool[] calldata defaultValue)
external
returns (bool[] memory value);
function envOr(string calldata name, string calldata delim, uint256[] calldata defaultValue)
external
returns (uint256[] memory value);
function envOr(string calldata name, string calldata delim, int256[] calldata defaultValue)
external
returns (int256[] memory value);
function envOr(string calldata name, string calldata delim, address[] calldata defaultValue)
external
returns (address[] memory value);
function envOr(string calldata name, string calldata delim, bytes32[] calldata defaultValue)
external
returns (bytes32[] memory value);
function envOr(string calldata name, string calldata delim, string[] calldata defaultValue)
external
returns (string[] memory value);
function envOr(string calldata name, string calldata delim, bytes[] calldata defaultValue)
external
returns (bytes[] memory value);
// ======== User Management ========
// Derives a private key from the name, labels the account with that name, and returns the wallet
function createWallet(string calldata walletLabel) external returns (Wallet memory wallet);
// Generates a wallet from the private key and returns the wallet
function createWallet(uint256 privateKey) external returns (Wallet memory wallet);
// Generates a wallet from the private key, labels the account with that name, and returns the wallet
function createWallet(uint256 privateKey, string calldata walletLabel) external returns (Wallet memory wallet);
// Gets the label for the specified address
function getLabel(address account) external returns (string memory currentLabel);
// Get nonce for a Wallet.
// See `getNonce(address account)` for an alternative way to get a nonce.
function getNonce(Wallet calldata wallet) external returns (uint64 nonce);
// Labels an address in call traces
function label(address account, string calldata newLabel) external;
// Signs data, (Wallet, digest) => (v, r, s)
function sign(Wallet calldata wallet, bytes32 digest) external returns (uint8 v, bytes32 r, bytes32 s);
// ======== Scripts ========
// -------- Broadcasting Transactions --------
// Using the address that calls the test contract, has the next call (at this call depth only) create a transaction that can later be signed and sent onchain
function broadcast() external;
// Has the next call (at this call depth only) create a transaction with the address provided as the sender that can later be signed and sent onchain
function broadcast(address signer) external;
// Has the next call (at this call depth only) create a transaction with the private key provided as the sender that can later be signed and sent onchain
function broadcast(uint256 privateKey) external;
// Using the address that calls the test contract, has all subsequent calls (at this call depth only) create transactions that can later be signed and sent onchain
function startBroadcast() external;
// Has all subsequent calls (at this call depth only) create transactions with the address provided that can later be signed and sent onchain
function startBroadcast(address signer) external;
// Has all subsequent calls (at this call depth only) create transactions with the private key provided that can later be signed and sent onchain
function startBroadcast(uint256 privateKey) external;
// Stops collecting onchain transactions
function stopBroadcast() external;
// -------- Key Management --------
// Derive a private key from a provided mnenomic string (or mnenomic file path) at the derivation path m/44'/60'/0'/0/{index}
function deriveKey(string calldata mnemonic, uint32 index) external pure returns (uint256 privateKey);
// Derive a private key from a provided mnenomic string (or mnenomic file path) at {derivationPath}{index}
function deriveKey(string calldata mnemonic, string calldata derivationPath, uint32 index)
external
pure
returns (uint256 privateKey);
// Adds a private key to the local forge wallet and returns the address
function rememberKey(uint256 privateKey) external returns (address keyAddr);
// ======== Utilities ========
// Convert values to a string
function toString(address value) external pure returns (string memory stringifiedValue);
function toString(bytes calldata value) external pure returns (string memory stringifiedValue);
function toString(bytes32 value) external pure returns (string memory stringifiedValue);
function toString(bool value) external pure returns (string memory stringifiedValue);
function toString(uint256 value) external pure returns (string memory stringifiedValue);
function toString(int256 value) external pure returns (string memory stringifiedValue);
// Convert values from a string
function parseBytes(string calldata stringifiedValue) external pure returns (bytes memory parsedValue);
function parseAddress(string calldata stringifiedValue) external pure returns (address parsedValue);
function parseUint(string calldata stringifiedValue) external pure returns (uint256 parsedValue);
function parseInt(string calldata stringifiedValue) external pure returns (int256 parsedValue);
function parseBytes32(string calldata stringifiedValue) external pure returns (bytes32 parsedValue);
function parseBool(string calldata stringifiedValue) external pure returns (bool parsedValue);
// Gets the creation bytecode from an artifact file. Takes in the relative path to the json file
function getCode(string calldata artifactPath) external view returns (bytes memory creationBytecode);
// Gets the deployed bytecode from an artifact file. Takes in the relative path to the json file
function getDeployedCode(string calldata artifactPath) external view returns (bytes memory runtimeBytecode);
// Compute the address a contract will be deployed at for a given deployer address and nonce.
function computeCreateAddress(address deployer, uint256 nonce) external pure returns (address);
// Compute the address of a contract created with CREATE2 using the given CREATE2 deployer.
function computeCreate2Address(bytes32 salt, bytes32 initCodeHash, address deployer)
external
pure
returns (address);
// Compute the address of a contract created with CREATE2 using foundry's default CREATE2
// deployer: 0x4e59b44847b379578588920cA78FbF26c0B4956C, https://github.com/Arachnid/deterministic-deployment-proxy
function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) external pure returns (address);
// ======== JSON Parsing and Manipulation ========
// -------- Reading --------
// NOTE: Please read https://book.getfoundry.sh/cheatcodes/parse-json to understand the
// limitations and caveats of the JSON parsing cheats.
// Checks if a key exists in a JSON object.
function keyExists(string calldata json, string calldata key) external view returns (bool);
// Given a string of JSON, return it as ABI-encoded
function parseJson(string calldata json, string calldata key) external pure returns (bytes memory abiEncodedData);
function parseJson(string calldata json) external pure returns (bytes memory abiEncodedData);
// The following parseJson cheatcodes will do type coercion, for the type that they indicate.
// For example, parseJsonUint will coerce all values to a uint256. That includes stringified numbers '12'
// and hex numbers '0xEF'.
// Type coercion works ONLY for discrete values or arrays. That means that the key must return a value or array, not
// a JSON object.
function parseJsonUint(string calldata json, string calldata key) external pure returns (uint256);
function parseJsonUintArray(string calldata json, string calldata key) external pure returns (uint256[] memory);
function parseJsonInt(string calldata json, string calldata key) external pure returns (int256);
function parseJsonIntArray(string calldata json, string calldata key) external pure returns (int256[] memory);
function parseJsonBool(string calldata json, string calldata key) external pure returns (bool);
function parseJsonBoolArray(string calldata json, string calldata key) external pure returns (bool[] memory);
function parseJsonAddress(string calldata json, string calldata key) external pure returns (address);
function parseJsonAddressArray(string calldata json, string calldata key)
external
pure
returns (address[] memory);
function parseJsonString(string calldata json, string calldata key) external pure returns (string memory);
function parseJsonStringArray(string calldata json, string calldata key) external pure returns (string[] memory);
function parseJsonBytes(string calldata json, string calldata key) external pure returns (bytes memory);
function parseJsonBytesArray(string calldata json, string calldata key) external pure returns (bytes[] memory);
function parseJsonBytes32(string calldata json, string calldata key) external pure returns (bytes32);
function parseJsonBytes32Array(string calldata json, string calldata key)
external
pure
returns (bytes32[] memory);
// Returns array of keys for a JSON object
function parseJsonKeys(string calldata json, string calldata key) external pure returns (string[] memory keys);
// -------- Writing --------
// NOTE: Please read https://book.getfoundry.sh/cheatcodes/serialize-json to understand how
// to use the serialization cheats.
// Serialize a key and value to a JSON object stored in-memory that can be later written to a file
// It returns the stringified version of the specific JSON file up to that moment.
function serializeJson(string calldata objectKey, string calldata value) external returns (string memory json);
function serializeBool(string calldata objectKey, string calldata valueKey, bool value)
external
returns (string memory json);
function serializeUint(string calldata objectKey, string calldata valueKey, uint256 value)
external
returns (string memory json);
function serializeInt(string calldata objectKey, string calldata valueKey, int256 value)
external
returns (string memory json);
function serializeAddress(string calldata objectKey, string calldata valueKey, address value)
external
returns (string memory json);
function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32 value)
external
returns (string memory json);
function serializeString(string calldata objectKey, string calldata valueKey, string calldata value)
external
returns (string memory json);
function serializeBytes(string calldata objectKey, string calldata valueKey, bytes calldata value)
external
returns (string memory json);
function serializeBool(string calldata objectKey, string calldata valueKey, bool[] calldata values)
external
returns (string memory json);
function serializeUint(string calldata objectKey, string calldata valueKey, uint256[] calldata values)
external
returns (string memory json);
function serializeInt(string calldata objectKey, string calldata valueKey, int256[] calldata values)
external
returns (string memory json);
function serializeAddress(string calldata objectKey, string calldata valueKey, address[] calldata values)
external
returns (string memory json);
function serializeBytes32(string calldata objectKey, string calldata valueKey, bytes32[] calldata values)
external
returns (string memory json);
function serializeString(string calldata objectKey, string calldata valueKey, string[] calldata values)
external
returns (string memory json);
function serializeBytes(string calldata objectKey, string calldata valueKey, bytes[] calldata values)
external
returns (string memory json);
// NOTE: Please read https://book.getfoundry.sh/cheatcodes/write-json to understand how
// to use the JSON writing cheats.
// Write a serialized JSON object to a file. If the file exists, it will be overwritten.
function writeJson(string calldata json, string calldata path) external;
// Write a serialized JSON object to an **existing** JSON file, replacing a value with key = <value_key>
// This is useful to replace a specific value of a JSON file, without having to parse the entire thing
function writeJson(string calldata json, string calldata path, string calldata valueKey) external;
}
// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used
// in tests, but it is not recommended to use these cheats in scripts.
interface Vm is VmSafe {
// ======== EVM ========
// -------- Block and Transaction Properties --------
// Sets block.chainid
function chainId(uint256 newChainId) external;
// Sets block.coinbase
function coinbase(address newCoinbase) external;
// Sets block.difficulty
// Not available on EVM versions from Paris onwards. Use `prevrandao` instead.
// If used on unsupported EVM versions it will revert.
function difficulty(uint256 newDifficulty) external;
// Sets block.basefee
function fee(uint256 newBasefee) external;
// Sets block.prevrandao
// Not available on EVM versions before Paris. Use `difficulty` instead.
// If used on unsupported EVM versions it will revert.
function prevrandao(bytes32 newPrevrandao) external;
// Sets block.height
function roll(uint256 newHeight) external;
// Sets tx.gasprice
function txGasPrice(uint256 newGasPrice) external;
// Sets block.timestamp
function warp(uint256 newTimestamp) external;
// -------- Account State --------
// Sets an address' balance
function deal(address account, uint256 newBalance) external;
// Sets an address' code
function etch(address target, bytes calldata newRuntimeBytecode) external;
// Load a genesis JSON file's `allocs` into the in-memory state.
function loadAllocs(string calldata pathToAllocsJson) external;
// Resets the nonce of an account to 0 for EOAs and 1 for contract accounts
function resetNonce(address account) external;
// Sets the nonce of an account; must be higher than the current nonce of the account
function setNonce(address account, uint64 newNonce) external;
// Sets the nonce of an account to an arbitrary value
function setNonceUnsafe(address account, uint64 newNonce) external;
// Stores a value to an address' storage slot.
function store(address target, bytes32 slot, bytes32 value) external;
// -------- Call Manipulation --------
// --- Mocks ---
// Clears all mocked calls
function clearMockedCalls() external;
// Mocks a call to an address, returning specified data.
// Calldata can either be strict or a partial match, e.g. if you only
// pass a Solidity selector to the expected calldata, then the entire Solidity
// function will be mocked.
function mockCall(address callee, bytes calldata data, bytes calldata returnData) external;
// Mocks a call to an address with a specific msg.value, returning specified data.
// Calldata match takes precedence over msg.value in case of ambiguity.
function mockCall(address callee, uint256 msgValue, bytes calldata data, bytes calldata returnData) external;
// Reverts a call to an address with specified revert data.
function mockCallRevert(address callee, bytes calldata data, bytes calldata revertData) external;
// Reverts a call to an address with a specific msg.value, with specified revert data.
function mockCallRevert(address callee, uint256 msgValue, bytes calldata data, bytes calldata revertData)
external;
// --- Impersonation (pranks) ---
// Sets the *next* call's msg.sender to be the input address
function prank(address msgSender) external;
// Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
function startPrank(address msgSender) external;
// Sets the *next* call's msg.sender to be the input address, and the tx.origin to be the second input
function prank(address msgSender, address txOrigin) external;
// Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called, and the tx.origin to be the second input
function startPrank(address msgSender, address txOrigin) external;
// Resets subsequent calls' msg.sender to be `address(this)`
function stopPrank() external;
// Reads the current `msg.sender` and `tx.origin` from state and reports if there is any active caller modification
function readCallers() external returns (CallerMode callerMode, address msgSender, address txOrigin);
// -------- State Snapshots --------
// Snapshot the current state of the evm.
// Returns the id of the snapshot that was created.
// To revert a snapshot use `revertTo`
function snapshot() external returns (uint256 snapshotId);
// Revert the state of the EVM to a previous snapshot
// Takes the snapshot id to revert to.
// Returns true if the revert succeeded, false otherwise.
//
// This does not automatically delete the snapshot. To delete the snapshot use `deleteSnapshot` or `revertToAndDelete`
function revertTo(uint256 snapshotId) external returns (bool success);
// Deletes the snapshot.
// Returns true if the snapshot existed, false otherwise.
//
// This does not revert to the state of the snapshot, only deletes it.
function deleteSnapshot(uint256 snapshotId) external returns (bool success);
// Deletes all snapshots.
function deleteSnapshots() external;
// Revert the state of the EVM to a previous snapshot
// Takes the snapshot id to revert to.
//
// This also deletes the snapshot after reverting to its state.
function revertToAndDelete(uint256 snapshotId) external returns (bool success);
// -------- Forking --------
// --- Creation and Selection ---
// Returns the identifier of the currently active fork. Reverts if no fork is currently active.
function activeFork() external view returns (uint256 forkId);
// Creates a new fork with the given endpoint and block and returns the identifier of the fork
function createFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
// Creates a new fork with the given endpoint and the _latest_ block and returns the identifier of the fork
function createFork(string calldata urlOrAlias) external returns (uint256 forkId);
// Creates a new fork with the given endpoint and at the block the given transaction was mined in, replays all transaction mined in the block before the transaction,
// and returns the identifier of the fork
function createFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
// Creates and also selects a new fork with the given endpoint and block and returns the identifier of the fork
function createSelectFork(string calldata urlOrAlias, uint256 blockNumber) external returns (uint256 forkId);
// Creates and also selects new fork with the given endpoint and at the block the given transaction was mined in, replays all transaction mined in the block before
// the transaction, returns the identifier of the fork
function createSelectFork(string calldata urlOrAlias, bytes32 txHash) external returns (uint256 forkId);
// Creates and also selects a new fork with the given endpoint and the latest block and returns the identifier of the fork
function createSelectFork(string calldata urlOrAlias) external returns (uint256 forkId);
// Updates the currently active fork to given block number
// This is similar to `roll` but for the currently active fork
function rollFork(uint256 blockNumber) external;
// Updates the currently active fork to given transaction
// this will `rollFork` with the number of the block the transaction was mined in and replays all transaction mined before it in the block
function rollFork(bytes32 txHash) external;
// Updates the given fork to given block number
function rollFork(uint256 forkId, uint256 blockNumber) external;
// Updates the given fork to block number of the given transaction and replays all transaction mined before it in the block
function rollFork(uint256 forkId, bytes32 txHash) external;
// Takes a fork identifier created by `createFork` and sets the corresponding forked state as active.
function selectFork(uint256 forkId) external;
// Fetches the given transaction from the active fork and executes it on the current state
function transact(bytes32 txHash) external;
// Fetches the given transaction from the given fork and executes it on the current state
function transact(uint256 forkId, bytes32 txHash) external;
// --- Behavior ---
// In forking mode, explicitly grant the given address cheatcode access
function allowCheatcodes(address account) external;
// Marks that the account(s) should use persistent storage across fork swaps in a multifork setup
// Meaning, changes made to the state of this account will be kept when switching forks
function makePersistent(address account) external;
function makePersistent(address account0, address account1) external;
function makePersistent(address account0, address account1, address account2) external;
function makePersistent(address[] calldata accounts) external;
// Revokes persistent status from the address, previously added via `makePersistent`
function revokePersistent(address account) external;
function revokePersistent(address[] calldata accounts) external;
// Returns true if the account is marked as persistent
function isPersistent(address account) external view returns (bool persistent);
// ======== Test Assertions and Utilities ========
// Expects a call to an address with the specified calldata.
// Calldata can either be a strict or a partial match
function expectCall(address callee, bytes calldata data) external;
// Expects given number of calls to an address with the specified calldata.
function expectCall(address callee, bytes calldata data, uint64 count) external;
// Expects a call to an address with the specified msg.value and calldata
function expectCall(address callee, uint256 msgValue, bytes calldata data) external;
// Expects given number of calls to an address with the specified msg.value and calldata
function expectCall(address callee, uint256 msgValue, bytes calldata data, uint64 count) external;
// Expect a call to an address with the specified msg.value, gas, and calldata.
function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data) external;
// Expects given number of calls to an address with the specified msg.value, gas, and calldata.
function expectCall(address callee, uint256 msgValue, uint64 gas, bytes calldata data, uint64 count) external;
// Expect a call to an address with the specified msg.value and calldata, and a *minimum* amount of gas.
function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data) external;
// Expect given number of calls to an address with the specified msg.value and calldata, and a *minimum* amount of gas.
function expectCallMinGas(address callee, uint256 msgValue, uint64 minGas, bytes calldata data, uint64 count)
external;
// Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData).
// Call this function, then emit an event, then call a function. Internally after the call, we check if
// logs were emitted in the expected order with the expected topics and data (as specified by the booleans).
function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData) external;
// Same as the previous method, but also checks supplied address against emitting contract.
function expectEmit(bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData, address emitter)
external;
// Prepare an expected log with all topic and data checks enabled.
// Call this function, then emit an event, then call a function. Internally after the call, we check if
// logs were emitted in the expected order with the expected topics and data.
function expectEmit() external;
// Same as the previous method, but also checks supplied address against emitting contract.
function expectEmit(address emitter) external;
// Expects an error on next call that exactly matches the revert data.
function expectRevert(bytes calldata revertData) external;
// Expects an error on next call that starts with the revert data.
function expectRevert(bytes4 revertData) external;
// Expects an error on next call with any revert data.
function expectRevert() external;
// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the current subcontext. If any other
// memory is written to, the test will fail. Can be called multiple times to add more ranges to the set.
function expectSafeMemory(uint64 min, uint64 max) external;
// Only allows memory writes to offsets [0x00, 0x60) ∪ [min, max) in the next created subcontext.
// If any other memory is written to, the test will fail. Can be called multiple times to add more ranges
// to the set.
function expectSafeMemoryCall(uint64 min, uint64 max) external;
// Marks a test as skipped. Must be called at the top of the test.
function skip(bool skipTest) external;
}// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
library console {
address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);
function _sendLogPayload(bytes memory payload) private view {
uint256 payloadLength = payload.length;
address consoleAddress = CONSOLE_ADDRESS;
/// @solidity memory-safe-assembly
assembly {
let payloadStart := add(payload, 32)
let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
}
}
function log() internal view {
_sendLogPayload(abi.encodeWithSignature("log()"));
}
function logInt(int p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(int)", p0));
}
function logUint(uint p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
}
function logString(string memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function logBool(bool p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function logAddress(address p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function logBytes(bytes memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
}
function logBytes1(bytes1 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
}
function logBytes2(bytes2 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
}
function logBytes3(bytes3 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
}
function logBytes4(bytes4 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
}
function logBytes5(bytes5 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
}
function logBytes6(bytes6 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
}
function logBytes7(bytes7 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
}
function logBytes8(bytes8 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
}
function logBytes9(bytes9 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
}
function logBytes10(bytes10 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
}
function logBytes11(bytes11 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
}
function logBytes12(bytes12 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
}
function logBytes13(bytes13 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
}
function logBytes14(bytes14 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
}
function logBytes15(bytes15 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
}
function logBytes16(bytes16 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
}
function logBytes17(bytes17 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
}
function logBytes18(bytes18 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
}
function logBytes19(bytes19 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
}
function logBytes20(bytes20 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
}
function logBytes21(bytes21 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
}
function logBytes22(bytes22 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
}
function logBytes23(bytes23 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
}
function logBytes24(bytes24 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
}
function logBytes25(bytes25 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
}
function logBytes26(bytes26 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
}
function logBytes27(bytes27 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
}
function logBytes28(bytes28 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
}
function logBytes29(bytes29 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
}
function logBytes30(bytes30 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
}
function logBytes31(bytes31 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
}
function logBytes32(bytes32 p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
}
function log(uint p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint)", p0));
}
function log(string memory p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function log(bool p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function log(address p0) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function log(uint p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1));
}
function log(uint p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1));
}
function log(uint p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1));
}
function log(uint p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1));
}
function log(string memory p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1));
}
function log(string memory p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
}
function log(string memory p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
}
function log(string memory p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
}
function log(bool p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1));
}
function log(bool p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
}
function log(bool p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
}
function log(bool p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
}
function log(address p0, uint p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1));
}
function log(address p0, string memory p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
}
function log(address p0, bool p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
}
function log(address p0, address p1) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
}
function log(uint p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2));
}
function log(uint p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2));
}
function log(uint p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2));
}
function log(uint p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2));
}
function log(uint p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2));
}
function log(uint p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2));
}
function log(uint p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2));
}
function log(uint p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2));
}
function log(uint p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2));
}
function log(uint p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2));
}
function log(uint p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2));
}
function log(uint p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2));
}
function log(uint p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2));
}
function log(uint p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2));
}
function log(uint p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2));
}
function log(uint p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2));
}
function log(string memory p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2));
}
function log(string memory p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2));
}
function log(string memory p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2));
}
function log(string memory p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2));
}
function log(string memory p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2));
}
function log(string memory p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
}
function log(string memory p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
}
function log(string memory p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
}
function log(string memory p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2));
}
function log(string memory p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
}
function log(string memory p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
}
function log(string memory p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
}
function log(string memory p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2));
}
function log(string memory p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
}
function log(string memory p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
}
function log(string memory p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
}
function log(bool p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2));
}
function log(bool p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2));
}
function log(bool p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2));
}
function log(bool p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2));
}
function log(bool p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2));
}
function log(bool p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
}
function log(bool p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
}
function log(bool p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
}
function log(bool p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2));
}
function log(bool p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
}
function log(bool p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
}
function log(bool p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
}
function log(bool p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2));
}
function log(bool p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
}
function log(bool p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
}
function log(bool p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
}
function log(address p0, uint p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2));
}
function log(address p0, uint p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2));
}
function log(address p0, uint p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2));
}
function log(address p0, uint p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2));
}
function log(address p0, string memory p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2));
}
function log(address p0, string memory p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
}
function log(address p0, string memory p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
}
function log(address p0, string memory p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
}
function log(address p0, bool p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2));
}
function log(address p0, bool p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
}
function log(address p0, bool p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
}
function log(address p0, bool p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
}
function log(address p0, address p1, uint p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2));
}
function log(address p0, address p1, string memory p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
}
function log(address p0, address p1, bool p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
}
function log(address p0, address p1, address p2) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
}
function log(uint p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,string,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,string)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,uint,address,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,string,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,string)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,string,address,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,string,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,string)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,bool,address,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,uint,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,string,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,bool,address)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,uint)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,string)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,bool)", p0, p1, p2, p3));
}
function log(uint p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(uint,address,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,uint,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,string,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,string)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint,address,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,uint,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,string,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,bool,address)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,uint)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,string)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,bool)", p0, p1, p2, p3));
}
function log(address p0, uint p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,uint,address,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, uint p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, string memory p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, bool p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, address p3) internal view {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.4.22 <0.9.0;
/// @dev The original console.sol uses `int` and `uint` for computing function selectors, but it should
/// use `int256` and `uint256`. This modified version fixes that. This version is recommended
/// over `console.sol` if you don't need compatibility with Hardhat as the logs will show up in
/// forge stack traces. If you do need compatibility with Hardhat, you must use `console.sol`.
/// Reference: https://github.com/NomicFoundation/hardhat/issues/2178
library console2 {
address constant CONSOLE_ADDRESS = address(0x000000000000000000636F6e736F6c652e6c6f67);
function _castLogPayloadViewToPure(
function(bytes memory) internal view fnIn
) internal pure returns (function(bytes memory) internal pure fnOut) {
assembly {
fnOut := fnIn
}
}
function _sendLogPayload(bytes memory payload) internal pure {
_castLogPayloadViewToPure(_sendLogPayloadView)(payload);
}
function _sendLogPayloadView(bytes memory payload) private view {
uint256 payloadLength = payload.length;
address consoleAddress = CONSOLE_ADDRESS;
/// @solidity memory-safe-assembly
assembly {
let payloadStart := add(payload, 32)
let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
}
}
function log() internal pure {
_sendLogPayload(abi.encodeWithSignature("log()"));
}
function logInt(int256 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
}
function logUint(uint256 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
}
function logString(string memory p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function logBool(bool p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function logAddress(address p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function logBytes(bytes memory p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes)", p0));
}
function logBytes1(bytes1 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0));
}
function logBytes2(bytes2 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0));
}
function logBytes3(bytes3 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0));
}
function logBytes4(bytes4 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0));
}
function logBytes5(bytes5 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0));
}
function logBytes6(bytes6 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0));
}
function logBytes7(bytes7 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0));
}
function logBytes8(bytes8 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0));
}
function logBytes9(bytes9 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0));
}
function logBytes10(bytes10 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0));
}
function logBytes11(bytes11 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0));
}
function logBytes12(bytes12 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0));
}
function logBytes13(bytes13 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0));
}
function logBytes14(bytes14 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0));
}
function logBytes15(bytes15 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0));
}
function logBytes16(bytes16 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0));
}
function logBytes17(bytes17 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0));
}
function logBytes18(bytes18 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0));
}
function logBytes19(bytes19 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0));
}
function logBytes20(bytes20 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0));
}
function logBytes21(bytes21 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0));
}
function logBytes22(bytes22 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0));
}
function logBytes23(bytes23 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0));
}
function logBytes24(bytes24 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0));
}
function logBytes25(bytes25 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0));
}
function logBytes26(bytes26 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0));
}
function logBytes27(bytes27 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0));
}
function logBytes28(bytes28 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0));
}
function logBytes29(bytes29 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0));
}
function logBytes30(bytes30 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0));
}
function logBytes31(bytes31 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0));
}
function logBytes32(bytes32 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0));
}
function log(uint256 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256)", p0));
}
function log(int256 p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(int256)", p0));
}
function log(string memory p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function log(bool p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool)", p0));
}
function log(address p0) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address)", p0));
}
function log(uint256 p0, uint256 p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256)", p0, p1));
}
function log(uint256 p0, string memory p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string)", p0, p1));
}
function log(uint256 p0, bool p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool)", p0, p1));
}
function log(uint256 p0, address p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address)", p0, p1));
}
function log(string memory p0, uint256 p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
}
function log(string memory p0, int256 p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,int256)", p0, p1));
}
function log(string memory p0, string memory p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
}
function log(string memory p0, bool p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1));
}
function log(string memory p0, address p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1));
}
function log(bool p0, uint256 p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256)", p0, p1));
}
function log(bool p0, string memory p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1));
}
function log(bool p0, bool p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1));
}
function log(bool p0, address p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1));
}
function log(address p0, uint256 p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256)", p0, p1));
}
function log(address p0, string memory p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1));
}
function log(address p0, bool p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1));
}
function log(address p0, address p1) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address)", p0, p1));
}
function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256)", p0, p1, p2));
}
function log(uint256 p0, uint256 p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string)", p0, p1, p2));
}
function log(uint256 p0, uint256 p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool)", p0, p1, p2));
}
function log(uint256 p0, uint256 p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address)", p0, p1, p2));
}
function log(uint256 p0, string memory p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256)", p0, p1, p2));
}
function log(uint256 p0, string memory p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string)", p0, p1, p2));
}
function log(uint256 p0, string memory p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool)", p0, p1, p2));
}
function log(uint256 p0, string memory p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address)", p0, p1, p2));
}
function log(uint256 p0, bool p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256)", p0, p1, p2));
}
function log(uint256 p0, bool p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string)", p0, p1, p2));
}
function log(uint256 p0, bool p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool)", p0, p1, p2));
}
function log(uint256 p0, bool p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address)", p0, p1, p2));
}
function log(uint256 p0, address p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256)", p0, p1, p2));
}
function log(uint256 p0, address p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string)", p0, p1, p2));
}
function log(uint256 p0, address p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool)", p0, p1, p2));
}
function log(uint256 p0, address p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address)", p0, p1, p2));
}
function log(string memory p0, uint256 p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256)", p0, p1, p2));
}
function log(string memory p0, uint256 p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string)", p0, p1, p2));
}
function log(string memory p0, uint256 p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool)", p0, p1, p2));
}
function log(string memory p0, uint256 p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address)", p0, p1, p2));
}
function log(string memory p0, string memory p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256)", p0, p1, p2));
}
function log(string memory p0, string memory p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string)", p0, p1, p2));
}
function log(string memory p0, string memory p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2));
}
function log(string memory p0, string memory p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address)", p0, p1, p2));
}
function log(string memory p0, bool p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256)", p0, p1, p2));
}
function log(string memory p0, bool p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2));
}
function log(string memory p0, bool p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2));
}
function log(string memory p0, bool p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2));
}
function log(string memory p0, address p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256)", p0, p1, p2));
}
function log(string memory p0, address p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string)", p0, p1, p2));
}
function log(string memory p0, address p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2));
}
function log(string memory p0, address p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address)", p0, p1, p2));
}
function log(bool p0, uint256 p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256)", p0, p1, p2));
}
function log(bool p0, uint256 p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string)", p0, p1, p2));
}
function log(bool p0, uint256 p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool)", p0, p1, p2));
}
function log(bool p0, uint256 p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address)", p0, p1, p2));
}
function log(bool p0, string memory p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256)", p0, p1, p2));
}
function log(bool p0, string memory p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2));
}
function log(bool p0, string memory p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2));
}
function log(bool p0, string memory p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2));
}
function log(bool p0, bool p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256)", p0, p1, p2));
}
function log(bool p0, bool p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2));
}
function log(bool p0, bool p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2));
}
function log(bool p0, bool p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2));
}
function log(bool p0, address p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256)", p0, p1, p2));
}
function log(bool p0, address p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2));
}
function log(bool p0, address p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2));
}
function log(bool p0, address p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2));
}
function log(address p0, uint256 p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256)", p0, p1, p2));
}
function log(address p0, uint256 p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string)", p0, p1, p2));
}
function log(address p0, uint256 p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool)", p0, p1, p2));
}
function log(address p0, uint256 p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address)", p0, p1, p2));
}
function log(address p0, string memory p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256)", p0, p1, p2));
}
function log(address p0, string memory p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string)", p0, p1, p2));
}
function log(address p0, string memory p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2));
}
function log(address p0, string memory p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address)", p0, p1, p2));
}
function log(address p0, bool p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256)", p0, p1, p2));
}
function log(address p0, bool p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2));
}
function log(address p0, bool p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2));
}
function log(address p0, bool p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2));
}
function log(address p0, address p1, uint256 p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256)", p0, p1, p2));
}
function log(address p0, address p1, string memory p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string)", p0, p1, p2));
}
function log(address p0, address p1, bool p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2));
}
function log(address p0, address p1, address p2) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address)", p0, p1, p2));
}
function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,string)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,uint256,address)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,string)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,string,address)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,string)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,bool,address)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,string)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,uint256,address,address)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,string)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,uint256,address)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,string)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,string,address)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,string)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,bool,address)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,string)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, string memory p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,string,address,address)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,string)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,uint256,address)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,string)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,string,address)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,string)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,bool,address)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,string)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, bool p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,bool,address,address)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,string)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,uint256,address)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,string)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,string,address)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,string)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,bool,address)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,uint256)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,string)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,bool)", p0, p1, p2, p3));
}
function log(uint256 p0, address p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(uint256,address,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,uint256,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, uint256 p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,uint256,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, string memory p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,uint256,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, bool p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,bool,address,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,uint256,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,string,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,bool,address)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,uint256)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,string)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,bool)", p0, p1, p2, p3));
}
function log(string memory p0, address p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(string,address,address,address)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,uint256)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,string)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,uint256,address)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,uint256)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,string)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,string,address)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,uint256)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,uint256)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,string)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, uint256 p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,uint256,address,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,uint256)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,uint256,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,uint256)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,string,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,uint256)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,uint256)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,string)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, string memory p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,string,address,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,uint256)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,uint256,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,uint256)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,string,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,uint256)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,uint256)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,string)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, bool p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,bool,address,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,uint256)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,uint256,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,uint256)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,string,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,uint256)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,bool,address)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,uint256)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,string)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,bool)", p0, p1, p2, p3));
}
function log(bool p0, address p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(bool,address,address,address)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,uint256)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,string)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,bool)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,uint256,address)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,uint256)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,string)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,bool)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,string,address)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,uint256)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,string)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,bool,address)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,uint256)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,string)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,bool)", p0, p1, p2, p3));
}
function log(address p0, uint256 p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,uint256,address,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,uint256)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,uint256,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,uint256)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,string,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,uint256)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,bool,address)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,uint256)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,string)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,bool)", p0, p1, p2, p3));
}
function log(address p0, string memory p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,string,address,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,uint256)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,uint256,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,uint256)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,string,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,uint256)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,bool,address)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,uint256)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,string)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,bool)", p0, p1, p2, p3));
}
function log(address p0, bool p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,bool,address,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,uint256)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint256 p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint256 p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, uint256 p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,uint256,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,uint256)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, string memory p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,string,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,uint256)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, bool p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,bool,address)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, uint256 p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,uint256)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, string memory p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,string)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, bool p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,bool)", p0, p1, p2, p3));
}
function log(address p0, address p1, address p2, address p3) internal pure {
_sendLogPayload(abi.encodeWithSignature("log(address,address,address,address)", p0, p1, p2, p3));
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
pragma experimental ABIEncoderV2;
interface IMulticall3 {
struct Call {
address target;
bytes callData;
}
struct Call3 {
address target;
bool allowFailure;
bytes callData;
}
struct Call3Value {
address target;
bool allowFailure;
uint256 value;
bytes callData;
}
struct Result {
bool success;
bytes returnData;
}
function aggregate(Call[] calldata calls)
external
payable
returns (uint256 blockNumber, bytes[] memory returnData);
function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);
function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);
function blockAndAggregate(Call[] calldata calls)
external
payable
returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
function getBasefee() external view returns (uint256 basefee);
function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);
function getBlockNumber() external view returns (uint256 blockNumber);
function getChainId() external view returns (uint256 chainid);
function getCurrentBlockCoinbase() external view returns (address coinbase);
function getCurrentBlockDifficulty() external view returns (uint256 difficulty);
function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);
function getCurrentBlockTimestamp() external view returns (uint256 timestamp);
function getEthBalance(address addr) external view returns (uint256 balance);
function getLastBlockHash() external view returns (bytes32 blockHash);
function tryAggregate(bool requireSuccess, Call[] calldata calls)
external
payable
returns (Result[] memory returnData);
function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)
external
payable
returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
/// @notice This is a mock contract of the ERC20 standard for testing purposes only, it SHOULD NOT be used in production.
/// @dev Forked from: https://github.com/transmissions11/solmate/blob/0384dbaaa4fcb5715738a9254a7c0a4cb62cf458/src/tokens/ERC20.sol
contract MockERC20 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 amount);
event Approval(address indexed owner, address indexed spender, uint256 amount);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
uint8 public decimals;
/*//////////////////////////////////////////////////////////////
ERC20 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
/*//////////////////////////////////////////////////////////////
EIP-2612 STORAGE
//////////////////////////////////////////////////////////////*/
uint256 internal INITIAL_CHAIN_ID;
bytes32 internal INITIAL_DOMAIN_SEPARATOR;
mapping(address => uint256) public nonces;
/*//////////////////////////////////////////////////////////////
INITIALIZE
//////////////////////////////////////////////////////////////*/
/// @dev A bool to track whether the contract has been initialized.
bool private initialized;
/// @dev To hide constructor warnings across solc versions due to different constructor visibility requirements and
/// syntaxes, we add an initialization function that can be called only once.
function initialize(string memory _name, string memory _symbol, uint8 _decimals) public {
require(!initialized, "ALREADY_INITIALIZED");
name = _name;
symbol = _symbol;
decimals = _decimals;
INITIAL_CHAIN_ID = _pureChainId();
INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
initialized = true;
}
/*//////////////////////////////////////////////////////////////
ERC20 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 amount) public virtual returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) public virtual returns (bool) {
balanceOf[msg.sender] = _sub(balanceOf[msg.sender], amount);
balanceOf[to] = _add(balanceOf[to], amount);
emit Transfer(msg.sender, to, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
if (allowed != ~uint256(0)) allowance[from][msg.sender] = _sub(allowed, amount);
balanceOf[from] = _sub(balanceOf[from], amount);
balanceOf[to] = _add(balanceOf[to], amount);
emit Transfer(from, to, amount);
return true;
}
/*//////////////////////////////////////////////////////////////
EIP-2612 LOGIC
//////////////////////////////////////////////////////////////*/
function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)
public
virtual
{
require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
address recoveredAddress = ecrecover(
keccak256(
abi.encodePacked(
"\x19\x01",
DOMAIN_SEPARATOR(),
keccak256(
abi.encode(
keccak256(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
),
owner,
spender,
value,
nonces[owner]++,
deadline
)
)
)
),
v,
r,
s
);
require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
allowance[recoveredAddress][spender] = value;
emit Approval(owner, spender, value);
}
function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
return _pureChainId() == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
}
function computeDomainSeparator() internal view virtual returns (bytes32) {
return keccak256(
abi.encode(
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
keccak256(bytes(name)),
keccak256("1"),
_pureChainId(),
address(this)
)
);
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 amount) internal virtual {
totalSupply = _add(totalSupply, amount);
balanceOf[to] = _add(balanceOf[to], amount);
emit Transfer(address(0), to, amount);
}
function _burn(address from, uint256 amount) internal virtual {
balanceOf[from] = _sub(balanceOf[from], amount);
totalSupply = _sub(totalSupply, amount);
emit Transfer(from, address(0), amount);
}
/*//////////////////////////////////////////////////////////////
INTERNAL SAFE MATH LOGIC
//////////////////////////////////////////////////////////////*/
function _add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "ERC20: addition overflow");
return c;
}
function _sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(a >= b, "ERC20: subtraction underflow");
return a - b;
}
/*//////////////////////////////////////////////////////////////
HELPERS
//////////////////////////////////////////////////////////////*/
// We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no
// compiler warnings when accessing chain ID in any solidity version supported by forge-std. We
// can't simply access the chain ID in a normal view or pure function because the solc View Pure
// Checker changed `chainid` from pure to view in 0.8.0.
function _viewChainId() private view returns (uint256 chainId) {
// Assembly required since `block.chainid` was introduced in 0.8.0.
assembly {
chainId := chainid()
}
address(this); // Silence warnings in older Solc versions.
}
function _pureChainId() private pure returns (uint256 chainId) {
function() internal view returns (uint256) fnIn = _viewChainId;
function() internal pure returns (uint256) pureChainId;
assembly {
pureChainId := fnIn
}
chainId = pureChainId();
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
/// @notice This is a mock contract of the ERC721 standard for testing purposes only, it SHOULD NOT be used in production.
/// @dev Forked from: https://github.com/transmissions11/solmate/blob/0384dbaaa4fcb5715738a9254a7c0a4cb62cf458/src/tokens/ERC721.sol
contract MockERC721 {
/*//////////////////////////////////////////////////////////////
EVENTS
//////////////////////////////////////////////////////////////*/
event Transfer(address indexed from, address indexed to, uint256 indexed id);
event Approval(address indexed owner, address indexed spender, uint256 indexed id);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/*//////////////////////////////////////////////////////////////
METADATA STORAGE/LOGIC
//////////////////////////////////////////////////////////////*/
string public name;
string public symbol;
function tokenURI(uint256 id) public view virtual returns (string memory) {}
/*//////////////////////////////////////////////////////////////
ERC721 BALANCE/OWNER STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) internal _ownerOf;
mapping(address => uint256) internal _balanceOf;
function ownerOf(uint256 id) public view virtual returns (address owner) {
require((owner = _ownerOf[id]) != address(0), "NOT_MINTED");
}
function balanceOf(address owner) public view virtual returns (uint256) {
require(owner != address(0), "ZERO_ADDRESS");
return _balanceOf[owner];
}
/*//////////////////////////////////////////////////////////////
ERC721 APPROVAL STORAGE
//////////////////////////////////////////////////////////////*/
mapping(uint256 => address) public getApproved;
mapping(address => mapping(address => bool)) public isApprovedForAll;
/*//////////////////////////////////////////////////////////////
INITIALIZE
//////////////////////////////////////////////////////////////*/
/// @dev A bool to track whether the contract has been initialized.
bool private initialized;
/// @dev To hide constructor warnings across solc versions due to different constructor visibility requirements and
/// syntaxes, we add an initialization function that can be called only once.
function initialize(string memory _name, string memory _symbol) public {
require(!initialized, "ALREADY_INITIALIZED");
name = _name;
symbol = _symbol;
initialized = true;
}
/*//////////////////////////////////////////////////////////////
ERC721 LOGIC
//////////////////////////////////////////////////////////////*/
function approve(address spender, uint256 id) public virtual {
address owner = _ownerOf[id];
require(msg.sender == owner || isApprovedForAll[owner][msg.sender], "NOT_AUTHORIZED");
getApproved[id] = spender;
emit Approval(owner, spender, id);
}
function setApprovalForAll(address operator, bool approved) public virtual {
isApprovedForAll[msg.sender][operator] = approved;
emit ApprovalForAll(msg.sender, operator, approved);
}
function transferFrom(address from, address to, uint256 id) public virtual {
require(from == _ownerOf[id], "WRONG_FROM");
require(to != address(0), "INVALID_RECIPIENT");
require(
msg.sender == from || isApprovedForAll[from][msg.sender] || msg.sender == getApproved[id], "NOT_AUTHORIZED"
);
// Underflow of the sender's balance is impossible because we check for
// ownership above and the recipient's balance can't realistically overflow.
_balanceOf[from]--;
_balanceOf[to]++;
_ownerOf[id] = to;
delete getApproved[id];
emit Transfer(from, to, id);
}
function safeTransferFrom(address from, address to, uint256 id) public virtual {
transferFrom(from, to, id);
require(
!_isContract(to)
|| IERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, "")
== IERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT"
);
}
function safeTransferFrom(address from, address to, uint256 id, bytes memory data) public virtual {
transferFrom(from, to, id);
require(
!_isContract(to)
|| IERC721TokenReceiver(to).onERC721Received(msg.sender, from, id, data)
== IERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT"
);
}
/*//////////////////////////////////////////////////////////////
ERC165 LOGIC
//////////////////////////////////////////////////////////////*/
function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
return interfaceId == 0x01ffc9a7 // ERC165 Interface ID for ERC165
|| interfaceId == 0x80ac58cd // ERC165 Interface ID for ERC721
|| interfaceId == 0x5b5e139f; // ERC165 Interface ID for ERC721Metadata
}
/*//////////////////////////////////////////////////////////////
INTERNAL MINT/BURN LOGIC
//////////////////////////////////////////////////////////////*/
function _mint(address to, uint256 id) internal virtual {
require(to != address(0), "INVALID_RECIPIENT");
require(_ownerOf[id] == address(0), "ALREADY_MINTED");
// Counter overflow is incredibly unrealistic.
_balanceOf[to]++;
_ownerOf[id] = to;
emit Transfer(address(0), to, id);
}
function _burn(uint256 id) internal virtual {
address owner = _ownerOf[id];
require(owner != address(0), "NOT_MINTED");
_balanceOf[owner]--;
delete _ownerOf[id];
delete getApproved[id];
emit Transfer(owner, address(0), id);
}
/*//////////////////////////////////////////////////////////////
INTERNAL SAFE MINT LOGIC
//////////////////////////////////////////////////////////////*/
function _safeMint(address to, uint256 id) internal virtual {
_mint(to, id);
require(
!_isContract(to)
|| IERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, "")
== IERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT"
);
}
function _safeMint(address to, uint256 id, bytes memory data) internal virtual {
_mint(to, id);
require(
!_isContract(to)
|| IERC721TokenReceiver(to).onERC721Received(msg.sender, address(0), id, data)
== IERC721TokenReceiver.onERC721Received.selector,
"UNSAFE_RECIPIENT"
);
}
/*//////////////////////////////////////////////////////////////
HELPERS
//////////////////////////////////////////////////////////////*/
function _isContract(address _addr) private view returns (bool) {
uint256 codeLength;
// Assembly required for versions < 0.8.0 to check extcodesize.
assembly {
codeLength := extcodesize(_addr)
}
return codeLength > 0;
}
}
interface IERC721TokenReceiver {
function onERC721Received(address, address, uint256, bytes calldata) external returns (bytes4);
}// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2 <0.9.0;
/// @author philogy <https://github.com/philogy>
/// @dev Code generated automatically by script.
library safeconsole {
uint256 constant CONSOLE_ADDR = 0x000000000000000000000000000000000000000000636F6e736F6c652e6c6f67;
// Credit to [0age](https://twitter.com/z0age/status/1654922202930888704) and [0xdapper](https://github.com/foundry-rs/forge-std/pull/374)
// for the view-to-pure log trick.
function _sendLogPayload(uint256 offset, uint256 size) private pure {
function(uint256, uint256) internal view fnIn = _sendLogPayloadView;
function(uint256, uint256) internal pure pureSendLogPayload;
assembly {
pureSendLogPayload := fnIn
}
pureSendLogPayload(offset, size);
}
function _sendLogPayloadView(uint256 offset, uint256 size) private view {
assembly {
pop(staticcall(gas(), CONSOLE_ADDR, offset, size, 0x0, 0x0))
}
}
function _memcopy(uint256 fromOffset, uint256 toOffset, uint256 length) private pure {
function(uint256, uint256, uint256) internal view fnIn = _memcopyView;
function(uint256, uint256, uint256) internal pure pureMemcopy;
assembly {
pureMemcopy := fnIn
}
pureMemcopy(fromOffset, toOffset, length);
}
function _memcopyView(uint256 fromOffset, uint256 toOffset, uint256 length) private view {
assembly {
pop(staticcall(gas(), 0x4, fromOffset, length, toOffset, length))
}
}
function logMemory(uint256 offset, uint256 length) internal pure {
if (offset >= 0x60) {
// Sufficient memory before slice to prepare call header.
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(sub(offset, 0x60))
m1 := mload(sub(offset, 0x40))
m2 := mload(sub(offset, 0x20))
// Selector of `logBytes(bytes)`.
mstore(sub(offset, 0x60), 0xe17bf956)
mstore(sub(offset, 0x40), 0x20)
mstore(sub(offset, 0x20), length)
}
_sendLogPayload(offset - 0x44, length + 0x44);
assembly {
mstore(sub(offset, 0x60), m0)
mstore(sub(offset, 0x40), m1)
mstore(sub(offset, 0x20), m2)
}
} else {
// Insufficient space, so copy slice forward, add header and reverse.
bytes32 m0;
bytes32 m1;
bytes32 m2;
uint256 endOffset = offset + length;
assembly {
m0 := mload(add(endOffset, 0x00))
m1 := mload(add(endOffset, 0x20))
m2 := mload(add(endOffset, 0x40))
}
_memcopy(offset, offset + 0x60, length);
assembly {
// Selector of `logBytes(bytes)`.
mstore(add(offset, 0x00), 0xe17bf956)
mstore(add(offset, 0x20), 0x20)
mstore(add(offset, 0x40), length)
}
_sendLogPayload(offset + 0x1c, length + 0x44);
_memcopy(offset + 0x60, offset, length);
assembly {
mstore(add(endOffset, 0x00), m0)
mstore(add(endOffset, 0x20), m1)
mstore(add(endOffset, 0x40), m2)
}
}
}
function log(address p0) internal pure {
bytes32 m0;
bytes32 m1;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
// Selector of `log(address)`.
mstore(0x00, 0x2c2ecbc2)
mstore(0x20, p0)
}
_sendLogPayload(0x1c, 0x24);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
}
}
function log(bool p0) internal pure {
bytes32 m0;
bytes32 m1;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
// Selector of `log(bool)`.
mstore(0x00, 0x32458eed)
mstore(0x20, p0)
}
_sendLogPayload(0x1c, 0x24);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
}
}
function log(uint256 p0) internal pure {
bytes32 m0;
bytes32 m1;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
// Selector of `log(uint256)`.
mstore(0x00, 0xf82c50f1)
mstore(0x20, p0)
}
_sendLogPayload(0x1c, 0x24);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
}
}
function log(bytes32 p0) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(string)`.
mstore(0x00, 0x41304fac)
mstore(0x20, 0x20)
writeString(0x40, p0)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, address p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
// Selector of `log(address,address)`.
mstore(0x00, 0xdaf0d4aa)
mstore(0x20, p0)
mstore(0x40, p1)
}
_sendLogPayload(0x1c, 0x44);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
}
}
function log(address p0, bool p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
// Selector of `log(address,bool)`.
mstore(0x00, 0x75b605d3)
mstore(0x20, p0)
mstore(0x40, p1)
}
_sendLogPayload(0x1c, 0x44);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
}
}
function log(address p0, uint256 p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
// Selector of `log(address,uint256)`.
mstore(0x00, 0x8309e8a8)
mstore(0x20, p0)
mstore(0x40, p1)
}
_sendLogPayload(0x1c, 0x44);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
}
}
function log(address p0, bytes32 p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,string)`.
mstore(0x00, 0x759f86bb)
mstore(0x20, p0)
mstore(0x40, 0x40)
writeString(0x60, p1)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
// Selector of `log(bool,address)`.
mstore(0x00, 0x853c4849)
mstore(0x20, p0)
mstore(0x40, p1)
}
_sendLogPayload(0x1c, 0x44);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
}
}
function log(bool p0, bool p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
// Selector of `log(bool,bool)`.
mstore(0x00, 0x2a110e83)
mstore(0x20, p0)
mstore(0x40, p1)
}
_sendLogPayload(0x1c, 0x44);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
}
}
function log(bool p0, uint256 p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
// Selector of `log(bool,uint256)`.
mstore(0x00, 0x399174d3)
mstore(0x20, p0)
mstore(0x40, p1)
}
_sendLogPayload(0x1c, 0x44);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
}
}
function log(bool p0, bytes32 p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,string)`.
mstore(0x00, 0x8feac525)
mstore(0x20, p0)
mstore(0x40, 0x40)
writeString(0x60, p1)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
// Selector of `log(uint256,address)`.
mstore(0x00, 0x69276c86)
mstore(0x20, p0)
mstore(0x40, p1)
}
_sendLogPayload(0x1c, 0x44);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
}
}
function log(uint256 p0, bool p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
// Selector of `log(uint256,bool)`.
mstore(0x00, 0x1c9d7eb3)
mstore(0x20, p0)
mstore(0x40, p1)
}
_sendLogPayload(0x1c, 0x44);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
}
}
function log(uint256 p0, uint256 p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
// Selector of `log(uint256,uint256)`.
mstore(0x00, 0xf666715a)
mstore(0x20, p0)
mstore(0x40, p1)
}
_sendLogPayload(0x1c, 0x44);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
}
}
function log(uint256 p0, bytes32 p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,string)`.
mstore(0x00, 0x643fd0df)
mstore(0x20, p0)
mstore(0x40, 0x40)
writeString(0x60, p1)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bytes32 p0, address p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(string,address)`.
mstore(0x00, 0x319af333)
mstore(0x20, 0x40)
mstore(0x40, p1)
writeString(0x60, p0)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bytes32 p0, bool p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(string,bool)`.
mstore(0x00, 0xc3b55635)
mstore(0x20, 0x40)
mstore(0x40, p1)
writeString(0x60, p0)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bytes32 p0, uint256 p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(string,uint256)`.
mstore(0x00, 0xb60e72cc)
mstore(0x20, 0x40)
mstore(0x40, p1)
writeString(0x60, p0)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bytes32 p0, bytes32 p1) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,string)`.
mstore(0x00, 0x4b5c4277)
mstore(0x20, 0x40)
mstore(0x40, 0x80)
writeString(0x60, p0)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, address p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(address,address,address)`.
mstore(0x00, 0x018c84c2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, address p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(address,address,bool)`.
mstore(0x00, 0xf2a66286)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, address p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(address,address,uint256)`.
mstore(0x00, 0x17fe6185)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, address p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(address,address,string)`.
mstore(0x00, 0x007150be)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x60)
writeString(0x80, p2)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(address p0, bool p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(address,bool,address)`.
mstore(0x00, 0xf11699ed)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, bool p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(address,bool,bool)`.
mstore(0x00, 0xeb830c92)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, bool p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(address,bool,uint256)`.
mstore(0x00, 0x9c4f99fb)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, bool p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(address,bool,string)`.
mstore(0x00, 0x212255cc)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x60)
writeString(0x80, p2)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(address p0, uint256 p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(address,uint256,address)`.
mstore(0x00, 0x7bc0d848)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, uint256 p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(address,uint256,bool)`.
mstore(0x00, 0x678209a8)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, uint256 p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(address,uint256,uint256)`.
mstore(0x00, 0xb69bcaf6)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(address p0, uint256 p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(address,uint256,string)`.
mstore(0x00, 0xa1f2e8aa)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x60)
writeString(0x80, p2)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(address p0, bytes32 p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(address,string,address)`.
mstore(0x00, 0xf08744e8)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, p2)
writeString(0x80, p1)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(address p0, bytes32 p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(address,string,bool)`.
mstore(0x00, 0xcf020fb1)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, p2)
writeString(0x80, p1)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(address p0, bytes32 p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(address,string,uint256)`.
mstore(0x00, 0x67dd6ff1)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, p2)
writeString(0x80, p1)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(address p0, bytes32 p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
// Selector of `log(address,string,string)`.
mstore(0x00, 0xfb772265)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, 0xa0)
writeString(0x80, p1)
writeString(0xc0, p2)
}
_sendLogPayload(0x1c, 0xe4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
}
}
function log(bool p0, address p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(bool,address,address)`.
mstore(0x00, 0xd2763667)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(bool p0, address p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(bool,address,bool)`.
mstore(0x00, 0x18c9c746)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(bool p0, address p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(bool,address,uint256)`.
mstore(0x00, 0x5f7b9afb)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(bool p0, address p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(bool,address,string)`.
mstore(0x00, 0xde9a9270)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x60)
writeString(0x80, p2)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bool p0, bool p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(bool,bool,address)`.
mstore(0x00, 0x1078f68d)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(bool p0, bool p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(bool,bool,bool)`.
mstore(0x00, 0x50709698)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(bool p0, bool p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(bool,bool,uint256)`.
mstore(0x00, 0x12f21602)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(bool p0, bool p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(bool,bool,string)`.
mstore(0x00, 0x2555fa46)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x60)
writeString(0x80, p2)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bool p0, uint256 p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(bool,uint256,address)`.
mstore(0x00, 0x088ef9d2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(bool p0, uint256 p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(bool,uint256,bool)`.
mstore(0x00, 0xe8defba9)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(bool p0, uint256 p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(bool,uint256,uint256)`.
mstore(0x00, 0x37103367)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(bool p0, uint256 p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(bool,uint256,string)`.
mstore(0x00, 0xc3fc3970)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x60)
writeString(0x80, p2)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bool p0, bytes32 p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(bool,string,address)`.
mstore(0x00, 0x9591b953)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, p2)
writeString(0x80, p1)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bool p0, bytes32 p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(bool,string,bool)`.
mstore(0x00, 0xdbb4c247)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, p2)
writeString(0x80, p1)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bool p0, bytes32 p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(bool,string,uint256)`.
mstore(0x00, 0x1093ee11)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, p2)
writeString(0x80, p1)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bool p0, bytes32 p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
// Selector of `log(bool,string,string)`.
mstore(0x00, 0xb076847f)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, 0xa0)
writeString(0x80, p1)
writeString(0xc0, p2)
}
_sendLogPayload(0x1c, 0xe4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
}
}
function log(uint256 p0, address p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(uint256,address,address)`.
mstore(0x00, 0xbcfd9be0)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(uint256 p0, address p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(uint256,address,bool)`.
mstore(0x00, 0x9b6ec042)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(uint256 p0, address p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(uint256,address,uint256)`.
mstore(0x00, 0x5a9b5ed5)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(uint256 p0, address p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(uint256,address,string)`.
mstore(0x00, 0x63cb41f9)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x60)
writeString(0x80, p2)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(uint256 p0, bool p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(uint256,bool,address)`.
mstore(0x00, 0x35085f7b)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(uint256 p0, bool p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(uint256,bool,bool)`.
mstore(0x00, 0x20718650)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(uint256 p0, bool p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(uint256,bool,uint256)`.
mstore(0x00, 0x20098014)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(uint256 p0, bool p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(uint256,bool,string)`.
mstore(0x00, 0x85775021)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x60)
writeString(0x80, p2)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(uint256 p0, uint256 p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(uint256,uint256,address)`.
mstore(0x00, 0x5c96b331)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(uint256 p0, uint256 p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(uint256,uint256,bool)`.
mstore(0x00, 0x4766da72)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(uint256 p0, uint256 p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
// Selector of `log(uint256,uint256,uint256)`.
mstore(0x00, 0xd1ed7a3c)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
}
_sendLogPayload(0x1c, 0x64);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
}
}
function log(uint256 p0, uint256 p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(uint256,uint256,string)`.
mstore(0x00, 0x71d04af2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x60)
writeString(0x80, p2)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(uint256 p0, bytes32 p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(uint256,string,address)`.
mstore(0x00, 0x7afac959)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, p2)
writeString(0x80, p1)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(uint256 p0, bytes32 p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(uint256,string,bool)`.
mstore(0x00, 0x4ceda75a)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, p2)
writeString(0x80, p1)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(uint256 p0, bytes32 p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(uint256,string,uint256)`.
mstore(0x00, 0x37aa7d4c)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, p2)
writeString(0x80, p1)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(uint256 p0, bytes32 p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
// Selector of `log(uint256,string,string)`.
mstore(0x00, 0xb115611f)
mstore(0x20, p0)
mstore(0x40, 0x60)
mstore(0x60, 0xa0)
writeString(0x80, p1)
writeString(0xc0, p2)
}
_sendLogPayload(0x1c, 0xe4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
}
}
function log(bytes32 p0, address p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(string,address,address)`.
mstore(0x00, 0xfcec75e0)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, p2)
writeString(0x80, p0)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bytes32 p0, address p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(string,address,bool)`.
mstore(0x00, 0xc91d5ed4)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, p2)
writeString(0x80, p0)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bytes32 p0, address p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(string,address,uint256)`.
mstore(0x00, 0x0d26b925)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, p2)
writeString(0x80, p0)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bytes32 p0, address p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
// Selector of `log(string,address,string)`.
mstore(0x00, 0xe0e9ad4f)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, 0xa0)
writeString(0x80, p0)
writeString(0xc0, p2)
}
_sendLogPayload(0x1c, 0xe4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
}
}
function log(bytes32 p0, bool p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(string,bool,address)`.
mstore(0x00, 0x932bbb38)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, p2)
writeString(0x80, p0)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bytes32 p0, bool p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(string,bool,bool)`.
mstore(0x00, 0x850b7ad6)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, p2)
writeString(0x80, p0)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bytes32 p0, bool p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(string,bool,uint256)`.
mstore(0x00, 0xc95958d6)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, p2)
writeString(0x80, p0)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bytes32 p0, bool p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
// Selector of `log(string,bool,string)`.
mstore(0x00, 0xe298f47d)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, 0xa0)
writeString(0x80, p0)
writeString(0xc0, p2)
}
_sendLogPayload(0x1c, 0xe4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
}
}
function log(bytes32 p0, uint256 p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(string,uint256,address)`.
mstore(0x00, 0x1c7ec448)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, p2)
writeString(0x80, p0)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bytes32 p0, uint256 p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(string,uint256,bool)`.
mstore(0x00, 0xca7733b1)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, p2)
writeString(0x80, p0)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bytes32 p0, uint256 p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
// Selector of `log(string,uint256,uint256)`.
mstore(0x00, 0xca47c4eb)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, p2)
writeString(0x80, p0)
}
_sendLogPayload(0x1c, 0xa4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
}
}
function log(bytes32 p0, uint256 p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
// Selector of `log(string,uint256,string)`.
mstore(0x00, 0x5970e089)
mstore(0x20, 0x60)
mstore(0x40, p1)
mstore(0x60, 0xa0)
writeString(0x80, p0)
writeString(0xc0, p2)
}
_sendLogPayload(0x1c, 0xe4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
}
}
function log(bytes32 p0, bytes32 p1, address p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
// Selector of `log(string,string,address)`.
mstore(0x00, 0x95ed0195)
mstore(0x20, 0x60)
mstore(0x40, 0xa0)
mstore(0x60, p2)
writeString(0x80, p0)
writeString(0xc0, p1)
}
_sendLogPayload(0x1c, 0xe4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
}
}
function log(bytes32 p0, bytes32 p1, bool p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
// Selector of `log(string,string,bool)`.
mstore(0x00, 0xb0e0f9b5)
mstore(0x20, 0x60)
mstore(0x40, 0xa0)
mstore(0x60, p2)
writeString(0x80, p0)
writeString(0xc0, p1)
}
_sendLogPayload(0x1c, 0xe4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
}
}
function log(bytes32 p0, bytes32 p1, uint256 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
// Selector of `log(string,string,uint256)`.
mstore(0x00, 0x5821efa1)
mstore(0x20, 0x60)
mstore(0x40, 0xa0)
mstore(0x60, p2)
writeString(0x80, p0)
writeString(0xc0, p1)
}
_sendLogPayload(0x1c, 0xe4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
}
}
function log(bytes32 p0, bytes32 p1, bytes32 p2) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
// Selector of `log(string,string,string)`.
mstore(0x00, 0x2ced7cef)
mstore(0x20, 0x60)
mstore(0x40, 0xa0)
mstore(0x60, 0xe0)
writeString(0x80, p0)
writeString(0xc0, p1)
writeString(0x100, p2)
}
_sendLogPayload(0x1c, 0x124);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
}
}
function log(address p0, address p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,address,address,address)`.
mstore(0x00, 0x665bf134)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, address p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,address,address,bool)`.
mstore(0x00, 0x0e378994)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, address p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,address,address,uint256)`.
mstore(0x00, 0x94250d77)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, address p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,address,address,string)`.
mstore(0x00, 0xf808da20)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, address p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,address,bool,address)`.
mstore(0x00, 0x9f1bc36e)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, address p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,address,bool,bool)`.
mstore(0x00, 0x2cd4134a)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, address p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,address,bool,uint256)`.
mstore(0x00, 0x3971e78c)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, address p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,address,bool,string)`.
mstore(0x00, 0xaa6540c8)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, address p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,address,uint256,address)`.
mstore(0x00, 0x8da6def5)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, address p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,address,uint256,bool)`.
mstore(0x00, 0x9b4254e2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,address,uint256,uint256)`.
mstore(0x00, 0xbe553481)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, address p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,address,uint256,string)`.
mstore(0x00, 0xfdb4f990)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, address p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,address,string,address)`.
mstore(0x00, 0x8f736d16)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, address p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,address,string,bool)`.
mstore(0x00, 0x6f1a594e)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, address p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,address,string,uint256)`.
mstore(0x00, 0xef1cefe7)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, address p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(address,address,string,string)`.
mstore(0x00, 0x21bdaf25)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, 0xc0)
writeString(0xa0, p2)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(address p0, bool p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,bool,address,address)`.
mstore(0x00, 0x660375dd)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, bool p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,bool,address,bool)`.
mstore(0x00, 0xa6f50b0f)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, bool p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,bool,address,uint256)`.
mstore(0x00, 0xa75c59de)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, bool p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,bool,address,string)`.
mstore(0x00, 0x2dd778e6)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bool p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,bool,bool,address)`.
mstore(0x00, 0xcf394485)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, bool p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,bool,bool,bool)`.
mstore(0x00, 0xcac43479)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, bool p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,bool,bool,uint256)`.
mstore(0x00, 0x8c4e5de6)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, bool p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,bool,bool,string)`.
mstore(0x00, 0xdfc4a2e8)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bool p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,bool,uint256,address)`.
mstore(0x00, 0xccf790a1)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, bool p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,bool,uint256,bool)`.
mstore(0x00, 0xc4643e20)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,bool,uint256,uint256)`.
mstore(0x00, 0x386ff5f4)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, bool p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,bool,uint256,string)`.
mstore(0x00, 0x0aa6cfad)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bool p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,bool,string,address)`.
mstore(0x00, 0x19fd4956)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bool p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,bool,string,bool)`.
mstore(0x00, 0x50ad461d)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bool p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,bool,string,uint256)`.
mstore(0x00, 0x80e6a20b)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(address,bool,string,string)`.
mstore(0x00, 0x475c5c33)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, 0xc0)
writeString(0xa0, p2)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(address p0, uint256 p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,uint256,address,address)`.
mstore(0x00, 0x478d1c62)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, uint256 p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,uint256,address,bool)`.
mstore(0x00, 0xa1bcc9b3)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,uint256,address,uint256)`.
mstore(0x00, 0x100f650e)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, uint256 p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,uint256,address,string)`.
mstore(0x00, 0x1da986ea)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, uint256 p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,uint256,bool,address)`.
mstore(0x00, 0xa31bfdcc)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, uint256 p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,uint256,bool,bool)`.
mstore(0x00, 0x3bf5e537)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,uint256,bool,uint256)`.
mstore(0x00, 0x22f6b999)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, uint256 p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,uint256,bool,string)`.
mstore(0x00, 0xc5ad85f9)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,uint256,uint256,address)`.
mstore(0x00, 0x20e3984d)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,uint256,uint256,bool)`.
mstore(0x00, 0x66f1bc67)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(address,uint256,uint256,uint256)`.
mstore(0x00, 0x34f0e636)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(address p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,uint256,uint256,string)`.
mstore(0x00, 0x4a28c017)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, uint256 p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,uint256,string,address)`.
mstore(0x00, 0x5c430d47)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, uint256 p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,uint256,string,bool)`.
mstore(0x00, 0xcf18105c)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,uint256,string,uint256)`.
mstore(0x00, 0xbf01f891)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(address,uint256,string,string)`.
mstore(0x00, 0x88a8c406)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, 0xc0)
writeString(0xa0, p2)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(address p0, bytes32 p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,string,address,address)`.
mstore(0x00, 0x0d36fa20)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bytes32 p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,string,address,bool)`.
mstore(0x00, 0x0df12b76)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bytes32 p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,string,address,uint256)`.
mstore(0x00, 0x457fe3cf)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bytes32 p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(address,string,address,string)`.
mstore(0x00, 0xf7e36245)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p1)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(address p0, bytes32 p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,string,bool,address)`.
mstore(0x00, 0x205871c2)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bytes32 p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,string,bool,bool)`.
mstore(0x00, 0x5f1d5c9f)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bytes32 p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,string,bool,uint256)`.
mstore(0x00, 0x515e38b6)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(address,string,bool,string)`.
mstore(0x00, 0xbc0b61fe)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p1)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(address p0, bytes32 p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,string,uint256,address)`.
mstore(0x00, 0x63183678)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bytes32 p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,string,uint256,bool)`.
mstore(0x00, 0x0ef7e050)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(address,string,uint256,uint256)`.
mstore(0x00, 0x1dc8e1b8)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(address p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(address,string,uint256,string)`.
mstore(0x00, 0x448830a8)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p1)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(address p0, bytes32 p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(address,string,string,address)`.
mstore(0x00, 0xa04e2f87)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p1)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(address p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(address,string,string,bool)`.
mstore(0x00, 0x35a5071f)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p1)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(address p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(address,string,string,uint256)`.
mstore(0x00, 0x159f8927)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p1)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(address p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(address,string,string,string)`.
mstore(0x00, 0x5d02c50b)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, 0x100)
writeString(0xa0, p1)
writeString(0xe0, p2)
writeString(0x120, p3)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bool p0, address p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,address,address,address)`.
mstore(0x00, 0x1d14d001)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,address,address,bool)`.
mstore(0x00, 0x46600be0)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,address,address,uint256)`.
mstore(0x00, 0x0c66d1be)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,address,address,string)`.
mstore(0x00, 0xd812a167)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, address p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,address,bool,address)`.
mstore(0x00, 0x1c41a336)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,address,bool,bool)`.
mstore(0x00, 0x6a9c478b)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,address,bool,uint256)`.
mstore(0x00, 0x07831502)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,address,bool,string)`.
mstore(0x00, 0x4a66cb34)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, address p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,address,uint256,address)`.
mstore(0x00, 0x136b05dd)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,address,uint256,bool)`.
mstore(0x00, 0xd6019f1c)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,address,uint256,uint256)`.
mstore(0x00, 0x7bf181a1)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, address p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,address,uint256,string)`.
mstore(0x00, 0x51f09ff8)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, address p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,address,string,address)`.
mstore(0x00, 0x6f7c603e)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, address p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,address,string,bool)`.
mstore(0x00, 0xe2bfd60b)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, address p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,address,string,uint256)`.
mstore(0x00, 0xc21f64c7)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, address p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(bool,address,string,string)`.
mstore(0x00, 0xa73c1db6)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, 0xc0)
writeString(0xa0, p2)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bool p0, bool p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,bool,address,address)`.
mstore(0x00, 0xf4880ea4)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, bool p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,bool,address,bool)`.
mstore(0x00, 0xc0a302d8)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, bool p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,bool,address,uint256)`.
mstore(0x00, 0x4c123d57)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, bool p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,bool,address,string)`.
mstore(0x00, 0xa0a47963)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bool p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,bool,bool,address)`.
mstore(0x00, 0x8c329b1a)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, bool p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,bool,bool,bool)`.
mstore(0x00, 0x3b2a5ce0)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,bool,bool,uint256)`.
mstore(0x00, 0x6d7045c1)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, bool p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,bool,bool,string)`.
mstore(0x00, 0x2ae408d4)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bool p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,bool,uint256,address)`.
mstore(0x00, 0x54a7a9a0)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,bool,uint256,bool)`.
mstore(0x00, 0x619e4d0e)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,bool,uint256,uint256)`.
mstore(0x00, 0x0bb00eab)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, bool p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,bool,uint256,string)`.
mstore(0x00, 0x7dd4d0e0)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bool p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,bool,string,address)`.
mstore(0x00, 0xf9ad2b89)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bool p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,bool,string,bool)`.
mstore(0x00, 0xb857163a)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bool p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,bool,string,uint256)`.
mstore(0x00, 0xe3a9ca2f)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(bool,bool,string,string)`.
mstore(0x00, 0x6d1e8751)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, 0xc0)
writeString(0xa0, p2)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bool p0, uint256 p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,uint256,address,address)`.
mstore(0x00, 0x26f560a8)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, uint256 p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,uint256,address,bool)`.
mstore(0x00, 0xb4c314ff)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,uint256,address,uint256)`.
mstore(0x00, 0x1537dc87)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, uint256 p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,uint256,address,string)`.
mstore(0x00, 0x1bb3b09a)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, uint256 p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,uint256,bool,address)`.
mstore(0x00, 0x9acd3616)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,uint256,bool,bool)`.
mstore(0x00, 0xceb5f4d7)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,uint256,bool,uint256)`.
mstore(0x00, 0x7f9bbca2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, uint256 p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,uint256,bool,string)`.
mstore(0x00, 0x9143dbb1)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,uint256,uint256,address)`.
mstore(0x00, 0x00dd87b9)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,uint256,uint256,bool)`.
mstore(0x00, 0xbe984353)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(bool,uint256,uint256,uint256)`.
mstore(0x00, 0x374bb4b2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(bool p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,uint256,uint256,string)`.
mstore(0x00, 0x8e69fb5d)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, uint256 p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,uint256,string,address)`.
mstore(0x00, 0xfedd1fff)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, uint256 p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,uint256,string,bool)`.
mstore(0x00, 0xe5e70b2b)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,uint256,string,uint256)`.
mstore(0x00, 0x6a1199e2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(bool,uint256,string,string)`.
mstore(0x00, 0xf5bc2249)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, 0xc0)
writeString(0xa0, p2)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bool p0, bytes32 p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,string,address,address)`.
mstore(0x00, 0x2b2b18dc)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bytes32 p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,string,address,bool)`.
mstore(0x00, 0x6dd434ca)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bytes32 p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,string,address,uint256)`.
mstore(0x00, 0xa5cada94)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bytes32 p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(bool,string,address,string)`.
mstore(0x00, 0x12d6c788)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p1)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bool p0, bytes32 p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,string,bool,address)`.
mstore(0x00, 0x538e06ab)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bytes32 p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,string,bool,bool)`.
mstore(0x00, 0xdc5e935b)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bytes32 p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,string,bool,uint256)`.
mstore(0x00, 0x1606a393)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(bool,string,bool,string)`.
mstore(0x00, 0x483d0416)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p1)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bool p0, bytes32 p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,string,uint256,address)`.
mstore(0x00, 0x1596a1ce)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bytes32 p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,string,uint256,bool)`.
mstore(0x00, 0x6b0e5d53)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(bool,string,uint256,uint256)`.
mstore(0x00, 0x28863fcb)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bool p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(bool,string,uint256,string)`.
mstore(0x00, 0x1ad96de6)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p1)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bool p0, bytes32 p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(bool,string,string,address)`.
mstore(0x00, 0x97d394d8)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p1)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bool p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(bool,string,string,bool)`.
mstore(0x00, 0x1e4b87e5)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p1)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bool p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(bool,string,string,uint256)`.
mstore(0x00, 0x7be0c3eb)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p1)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bool p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(bool,string,string,string)`.
mstore(0x00, 0x1762e32a)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, 0x100)
writeString(0xa0, p1)
writeString(0xe0, p2)
writeString(0x120, p3)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(uint256 p0, address p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,address,address,address)`.
mstore(0x00, 0x2488b414)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,address,address,bool)`.
mstore(0x00, 0x091ffaf5)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,address,address,uint256)`.
mstore(0x00, 0x736efbb6)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,address,address,string)`.
mstore(0x00, 0x031c6f73)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, address p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,address,bool,address)`.
mstore(0x00, 0xef72c513)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,address,bool,bool)`.
mstore(0x00, 0xe351140f)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,address,bool,uint256)`.
mstore(0x00, 0x5abd992a)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,address,bool,string)`.
mstore(0x00, 0x90fb06aa)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,address,uint256,address)`.
mstore(0x00, 0x15c127b5)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,address,uint256,bool)`.
mstore(0x00, 0x5f743a7c)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,address,uint256,uint256)`.
mstore(0x00, 0x0c9cd9c1)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, address p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,address,uint256,string)`.
mstore(0x00, 0xddb06521)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, address p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,address,string,address)`.
mstore(0x00, 0x9cba8fff)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, address p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,address,string,bool)`.
mstore(0x00, 0xcc32ab07)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, address p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,address,string,uint256)`.
mstore(0x00, 0x46826b5d)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(uint256,address,string,string)`.
mstore(0x00, 0x3e128ca3)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, 0xc0)
writeString(0xa0, p2)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(uint256 p0, bool p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,bool,address,address)`.
mstore(0x00, 0xa1ef4cbb)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, bool p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,bool,address,bool)`.
mstore(0x00, 0x454d54a5)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,bool,address,uint256)`.
mstore(0x00, 0x078287f5)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, bool p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,bool,address,string)`.
mstore(0x00, 0xade052c7)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bool p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,bool,bool,address)`.
mstore(0x00, 0x69640b59)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,bool,bool,bool)`.
mstore(0x00, 0xb6f577a1)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,bool,bool,uint256)`.
mstore(0x00, 0x7464ce23)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, bool p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,bool,bool,string)`.
mstore(0x00, 0xdddb9561)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,bool,uint256,address)`.
mstore(0x00, 0x88cb6041)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,bool,uint256,bool)`.
mstore(0x00, 0x91a02e2a)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,bool,uint256,uint256)`.
mstore(0x00, 0xc6acc7a8)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,bool,uint256,string)`.
mstore(0x00, 0xde03e774)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bool p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,bool,string,address)`.
mstore(0x00, 0xef529018)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bool p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,bool,string,bool)`.
mstore(0x00, 0xeb928d7f)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,bool,string,uint256)`.
mstore(0x00, 0x2c1d0746)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(uint256,bool,string,string)`.
mstore(0x00, 0x68c8b8bd)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, 0xc0)
writeString(0xa0, p2)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,uint256,address,address)`.
mstore(0x00, 0x56a5d1b1)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,uint256,address,bool)`.
mstore(0x00, 0x15cac476)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,uint256,address,uint256)`.
mstore(0x00, 0x88f6e4b2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, uint256 p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,uint256,address,string)`.
mstore(0x00, 0x6cde40b8)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,uint256,bool,address)`.
mstore(0x00, 0x9a816a83)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,uint256,bool,bool)`.
mstore(0x00, 0xab085ae6)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,uint256,bool,uint256)`.
mstore(0x00, 0xeb7f6fd2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,uint256,bool,string)`.
mstore(0x00, 0xa5b4fc99)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,uint256,uint256,address)`.
mstore(0x00, 0xfa8185af)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,uint256,uint256,bool)`.
mstore(0x00, 0xc598d185)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
assembly {
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
// Selector of `log(uint256,uint256,uint256,uint256)`.
mstore(0x00, 0x193fb800)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
}
_sendLogPayload(0x1c, 0x84);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
}
}
function log(uint256 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,uint256,uint256,string)`.
mstore(0x00, 0x59cfcbe3)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0x80)
writeString(0xa0, p3)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, uint256 p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,uint256,string,address)`.
mstore(0x00, 0x42d21db7)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,uint256,string,bool)`.
mstore(0x00, 0x7af6ab25)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,uint256,string,uint256)`.
mstore(0x00, 0x5da297eb)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, p3)
writeString(0xa0, p2)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(uint256,uint256,string,string)`.
mstore(0x00, 0x27d8afd2)
mstore(0x20, p0)
mstore(0x40, p1)
mstore(0x60, 0x80)
mstore(0x80, 0xc0)
writeString(0xa0, p2)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(uint256 p0, bytes32 p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,string,address,address)`.
mstore(0x00, 0x6168ed61)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bytes32 p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,string,address,bool)`.
mstore(0x00, 0x90c30a56)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bytes32 p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,string,address,uint256)`.
mstore(0x00, 0xe8d3018d)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(uint256,string,address,string)`.
mstore(0x00, 0x9c3adfa1)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p1)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(uint256 p0, bytes32 p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,string,bool,address)`.
mstore(0x00, 0xae2ec581)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bytes32 p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,string,bool,bool)`.
mstore(0x00, 0xba535d9c)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,string,bool,uint256)`.
mstore(0x00, 0xcf009880)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(uint256,string,bool,string)`.
mstore(0x00, 0xd2d423cd)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p1)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(uint256 p0, bytes32 p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,string,uint256,address)`.
mstore(0x00, 0x3b2279b4)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,string,uint256,bool)`.
mstore(0x00, 0x691a8f74)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(uint256,string,uint256,uint256)`.
mstore(0x00, 0x82c25b74)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p1)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(uint256 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(uint256,string,uint256,string)`.
mstore(0x00, 0xb7b914ca)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p1)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(uint256 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(uint256,string,string,address)`.
mstore(0x00, 0xd583c602)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p1)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(uint256 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(uint256,string,string,bool)`.
mstore(0x00, 0xb3a6b6bd)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p1)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(uint256 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(uint256,string,string,uint256)`.
mstore(0x00, 0xb028c9bd)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p1)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(uint256 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(uint256,string,string,string)`.
mstore(0x00, 0x21ad0683)
mstore(0x20, p0)
mstore(0x40, 0x80)
mstore(0x60, 0xc0)
mstore(0x80, 0x100)
writeString(0xa0, p1)
writeString(0xe0, p2)
writeString(0x120, p3)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, address p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,address,address,address)`.
mstore(0x00, 0xed8f28f6)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, address p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,address,address,bool)`.
mstore(0x00, 0xb59dbd60)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, address p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,address,address,uint256)`.
mstore(0x00, 0x8ef3f399)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, address p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,address,address,string)`.
mstore(0x00, 0x800a1c67)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p0)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, address p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,address,bool,address)`.
mstore(0x00, 0x223603bd)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, address p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,address,bool,bool)`.
mstore(0x00, 0x79884c2b)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, address p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,address,bool,uint256)`.
mstore(0x00, 0x3e9f866a)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, address p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,address,bool,string)`.
mstore(0x00, 0x0454c079)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p0)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, address p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,address,uint256,address)`.
mstore(0x00, 0x63fb8bc5)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, address p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,address,uint256,bool)`.
mstore(0x00, 0xfc4845f0)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, address p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,address,uint256,uint256)`.
mstore(0x00, 0xf8f51b1e)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, address p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,address,uint256,string)`.
mstore(0x00, 0x5a477632)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p0)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, address p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,address,string,address)`.
mstore(0x00, 0xaabc9a31)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, address p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,address,string,bool)`.
mstore(0x00, 0x5f15d28c)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, address p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,address,string,uint256)`.
mstore(0x00, 0x91d1112e)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, address p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(string,address,string,string)`.
mstore(0x00, 0x245986f2)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, 0x100)
writeString(0xa0, p0)
writeString(0xe0, p2)
writeString(0x120, p3)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, bool p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,bool,address,address)`.
mstore(0x00, 0x33e9dd1d)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, bool p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,bool,address,bool)`.
mstore(0x00, 0x958c28c6)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, bool p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,bool,address,uint256)`.
mstore(0x00, 0x5d08bb05)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, bool p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,bool,address,string)`.
mstore(0x00, 0x2d8e33a4)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p0)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bool p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,bool,bool,address)`.
mstore(0x00, 0x7190a529)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, bool p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,bool,bool,bool)`.
mstore(0x00, 0x895af8c5)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, bool p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,bool,bool,uint256)`.
mstore(0x00, 0x8e3f78a9)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, bool p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,bool,bool,string)`.
mstore(0x00, 0x9d22d5dd)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p0)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bool p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,bool,uint256,address)`.
mstore(0x00, 0x935e09bf)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, bool p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,bool,uint256,bool)`.
mstore(0x00, 0x8af7cf8a)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, bool p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,bool,uint256,uint256)`.
mstore(0x00, 0x64b5bb67)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, bool p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,bool,uint256,string)`.
mstore(0x00, 0x742d6ee7)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p0)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bool p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,bool,string,address)`.
mstore(0x00, 0xe0625b29)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bool p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,bool,string,bool)`.
mstore(0x00, 0x3f8a701d)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bool p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,bool,string,uint256)`.
mstore(0x00, 0x24f91465)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bool p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(string,bool,string,string)`.
mstore(0x00, 0xa826caeb)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, 0x100)
writeString(0xa0, p0)
writeString(0xe0, p2)
writeString(0x120, p3)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, uint256 p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,uint256,address,address)`.
mstore(0x00, 0x5ea2b7ae)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, uint256 p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,uint256,address,bool)`.
mstore(0x00, 0x82112a42)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, uint256 p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,uint256,address,uint256)`.
mstore(0x00, 0x4f04fdc6)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, uint256 p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,uint256,address,string)`.
mstore(0x00, 0x9ffb2f93)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p0)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, uint256 p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,uint256,bool,address)`.
mstore(0x00, 0xe0e95b98)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, uint256 p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,uint256,bool,bool)`.
mstore(0x00, 0x354c36d6)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, uint256 p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,uint256,bool,uint256)`.
mstore(0x00, 0xe41b6f6f)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, uint256 p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,uint256,bool,string)`.
mstore(0x00, 0xabf73a98)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p0)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, uint256 p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,uint256,uint256,address)`.
mstore(0x00, 0xe21de278)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, uint256 p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,uint256,uint256,bool)`.
mstore(0x00, 0x7626db92)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
// Selector of `log(string,uint256,uint256,uint256)`.
mstore(0x00, 0xa7a87853)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
}
_sendLogPayload(0x1c, 0xc4);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
}
}
function log(bytes32 p0, uint256 p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,uint256,uint256,string)`.
mstore(0x00, 0x854b3496)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, p2)
mstore(0x80, 0xc0)
writeString(0xa0, p0)
writeString(0xe0, p3)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, uint256 p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,uint256,string,address)`.
mstore(0x00, 0x7c4632a4)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, uint256 p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,uint256,string,bool)`.
mstore(0x00, 0x7d24491d)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, uint256 p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,uint256,string,uint256)`.
mstore(0x00, 0xc67ea9d1)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p2)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, uint256 p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(string,uint256,string,string)`.
mstore(0x00, 0x5ab84e1f)
mstore(0x20, 0x80)
mstore(0x40, p1)
mstore(0x60, 0xc0)
mstore(0x80, 0x100)
writeString(0xa0, p0)
writeString(0xe0, p2)
writeString(0x120, p3)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, bytes32 p1, address p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,string,address,address)`.
mstore(0x00, 0x439c7bef)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bytes32 p1, address p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,string,address,bool)`.
mstore(0x00, 0x5ccd4e37)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bytes32 p1, address p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,string,address,uint256)`.
mstore(0x00, 0x7cc3c607)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bytes32 p1, address p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(string,string,address,string)`.
mstore(0x00, 0xeb1bff80)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, 0x100)
writeString(0xa0, p0)
writeString(0xe0, p1)
writeString(0x120, p3)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, bytes32 p1, bool p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,string,bool,address)`.
mstore(0x00, 0xc371c7db)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bytes32 p1, bool p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,string,bool,bool)`.
mstore(0x00, 0x40785869)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bytes32 p1, bool p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,string,bool,uint256)`.
mstore(0x00, 0xd6aefad2)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bytes32 p1, bool p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(string,string,bool,string)`.
mstore(0x00, 0x5e84b0ea)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, 0x100)
writeString(0xa0, p0)
writeString(0xe0, p1)
writeString(0x120, p3)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, bytes32 p1, uint256 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,string,uint256,address)`.
mstore(0x00, 0x1023f7b2)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bytes32 p1, uint256 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,string,uint256,bool)`.
mstore(0x00, 0xc3a8a654)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bytes32 p1, uint256 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
// Selector of `log(string,string,uint256,uint256)`.
mstore(0x00, 0xf45d7d2c)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
}
_sendLogPayload(0x1c, 0x104);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
}
}
function log(bytes32 p0, bytes32 p1, uint256 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(string,string,uint256,string)`.
mstore(0x00, 0x5d1a971a)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, p2)
mstore(0x80, 0x100)
writeString(0xa0, p0)
writeString(0xe0, p1)
writeString(0x120, p3)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, bytes32 p1, bytes32 p2, address p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(string,string,string,address)`.
mstore(0x00, 0x6d572f44)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, 0x100)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
writeString(0x120, p2)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, bytes32 p1, bytes32 p2, bool p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(string,string,string,bool)`.
mstore(0x00, 0x2c1754ed)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, 0x100)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
writeString(0x120, p2)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, bytes32 p1, bytes32 p2, uint256 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
// Selector of `log(string,string,string,uint256)`.
mstore(0x00, 0x8eafb02b)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, 0x100)
mstore(0x80, p3)
writeString(0xa0, p0)
writeString(0xe0, p1)
writeString(0x120, p2)
}
_sendLogPayload(0x1c, 0x144);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
}
}
function log(bytes32 p0, bytes32 p1, bytes32 p2, bytes32 p3) internal pure {
bytes32 m0;
bytes32 m1;
bytes32 m2;
bytes32 m3;
bytes32 m4;
bytes32 m5;
bytes32 m6;
bytes32 m7;
bytes32 m8;
bytes32 m9;
bytes32 m10;
bytes32 m11;
bytes32 m12;
assembly {
function writeString(pos, w) {
let length := 0
for {} lt(length, 0x20) { length := add(length, 1) } { if iszero(byte(length, w)) { break } }
mstore(pos, length)
let shift := sub(256, shl(3, length))
mstore(add(pos, 0x20), shl(shift, shr(shift, w)))
}
m0 := mload(0x00)
m1 := mload(0x20)
m2 := mload(0x40)
m3 := mload(0x60)
m4 := mload(0x80)
m5 := mload(0xa0)
m6 := mload(0xc0)
m7 := mload(0xe0)
m8 := mload(0x100)
m9 := mload(0x120)
m10 := mload(0x140)
m11 := mload(0x160)
m12 := mload(0x180)
// Selector of `log(string,string,string,string)`.
mstore(0x00, 0xde68f20a)
mstore(0x20, 0x80)
mstore(0x40, 0xc0)
mstore(0x60, 0x100)
mstore(0x80, 0x140)
writeString(0xa0, p0)
writeString(0xe0, p1)
writeString(0x120, p2)
writeString(0x160, p3)
}
_sendLogPayload(0x1c, 0x184);
assembly {
mstore(0x00, m0)
mstore(0x20, m1)
mstore(0x40, m2)
mstore(0x60, m3)
mstore(0x80, m4)
mstore(0xa0, m5)
mstore(0xc0, m6)
mstore(0xe0, m7)
mstore(0x100, m8)
mstore(0x120, m9)
mstore(0x140, m10)
mstore(0x160, m11)
mstore(0x180, m12)
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)
pragma solidity ^0.8.20;
import {IAccessControl} from "./IAccessControl.sol";
import {Context} from "../utils/Context.sol";
import {ERC165} from "../utils/introspection/ERC165.sol";
/**
* @dev Contract module that allows children to implement role-based access
* control mechanisms. This is a lightweight version that doesn't allow enumerating role
* members except through off-chain means by accessing the contract event logs. Some
* applications may benefit from on-chain enumerability, for those cases see
* {AccessControlEnumerable}.
*
* Roles are referred to by their `bytes32` identifier. These should be exposed
* in the external API and be unique. The best way to achieve this is by
* using `public constant` hash digests:
*
* ```solidity
* bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
* ```
*
* Roles can be used to represent a set of permissions. To restrict access to a
* function call, use {hasRole}:
*
* ```solidity
* function foo() public {
* require(hasRole(MY_ROLE, msg.sender));
* ...
* }
* ```
*
* Roles can be granted and revoked dynamically via the {grantRole} and
* {revokeRole} functions. Each role has an associated admin role, and only
* accounts that have a role's admin role can call {grantRole} and {revokeRole}.
*
* By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
* that only accounts with this role will be able to grant or revoke other
* roles. More complex role relationships can be created by using
* {_setRoleAdmin}.
*
* WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
* grant and revoke this role. Extra precautions should be taken to secure
* accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
* to enforce additional security measures for this role.
*/
abstract contract AccessControl is Context, IAccessControl, ERC165 {
struct RoleData {
mapping(address account => bool) hasRole;
bytes32 adminRole;
}
mapping(bytes32 role => RoleData) private _roles;
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
/**
* @dev Modifier that checks that an account has a specific role. Reverts
* with an {AccessControlUnauthorizedAccount} error including the required role.
*/
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) public view virtual returns (bool) {
return _roles[role].hasRole[account];
}
/**
* @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
* is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
*/
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
/**
* @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
* is missing `role`.
*/
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert AccessControlUnauthorizedAccount(account, role);
}
}
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
return _roles[role].adminRole;
}
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleGranted} event.
*/
function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*
* May emit a {RoleRevoked} event.
*/
function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been revoked `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `callerConfirmation`.
*
* May emit a {RoleRevoked} event.
*/
function renounceRole(bytes32 role, address callerConfirmation) public virtual {
if (callerConfirmation != _msgSender()) {
revert AccessControlBadConfirmation();
}
_revokeRole(role, callerConfirmation);
}
/**
* @dev Sets `adminRole` as ``role``'s admin role.
*
* Emits a {RoleAdminChanged} event.
*/
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
bytes32 previousAdminRole = getRoleAdmin(role);
_roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
/**
* @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
*
* Internal function without access restriction.
*
* May emit a {RoleGranted} event.
*/
function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
if (!hasRole(role, account)) {
_roles[role].hasRole[account] = true;
emit RoleGranted(role, account, _msgSender());
return true;
} else {
return false;
}
}
/**
* @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
*
* Internal function without access restriction.
*
* May emit a {RoleRevoked} event.
*/
function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
if (hasRole(role, account)) {
_roles[role].hasRole[account] = false;
emit RoleRevoked(role, account, _msgSender());
return true;
} else {
return false;
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/IAccessControl.sol)
pragma solidity ^0.8.20;
/**
* @dev External interface of AccessControl declared to support ERC165 detection.
*/
interface IAccessControl {
/**
* @dev The `account` is missing a role.
*/
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
/**
* @dev The caller of a function is not the expected one.
*
* NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
*/
error AccessControlBadConfirmation();
/**
* @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
*
* `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
* {RoleAdminChanged} not being emitted signaling this.
*/
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
/**
* @dev Emitted when `account` is granted `role`.
*
* `sender` is the account that originated the contract call, an admin role
* bearer except when using {AccessControl-_setupRole}.
*/
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Emitted when `account` is revoked `role`.
*
* `sender` is the account that originated the contract call:
* - if using `revokeRole`, it is the admin role bearer
* - if using `renounceRole`, it is the role bearer (i.e. `account`)
*/
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
/**
* @dev Returns `true` if `account` has been granted `role`.
*/
function hasRole(bytes32 role, address account) external view returns (bool);
/**
* @dev Returns the admin role that controls `role`. See {grantRole} and
* {revokeRole}.
*
* To change a role's admin, use {AccessControl-_setRoleAdmin}.
*/
function getRoleAdmin(bytes32 role) external view returns (bytes32);
/**
* @dev Grants `role` to `account`.
*
* If `account` had not been already granted `role`, emits a {RoleGranted}
* event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function grantRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from `account`.
*
* If `account` had been granted `role`, emits a {RoleRevoked} event.
*
* Requirements:
*
* - the caller must have ``role``'s admin role.
*/
function revokeRole(bytes32 role, address account) external;
/**
* @dev Revokes `role` from the calling account.
*
* Roles are often managed via {grantRole} and {revokeRole}: this function's
* purpose is to provide a mechanism for accounts to lose their privileges
* if they are compromised (such as when a trusted device is misplaced).
*
* If the calling account had been granted `role`, emits a {RoleRevoked}
* event.
*
* Requirements:
*
* - the caller must be `callerConfirmation`.
*/
function renounceRole(bytes32 role, address callerConfirmation) external;
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC1271.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC1271 standard signature validation method for
* contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
*/
interface IERC1271 {
/**
* @dev Should return whether the signature provided is valid for the provided data
* @param hash Hash of the data to be signed
* @param signature Signature byte array associated with _data
*/
function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../utils/introspection/IERC165.sol";// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC4906.sol)
pragma solidity ^0.8.20;
import {IERC165} from "./IERC165.sol";
import {IERC721} from "./IERC721.sol";
/// @title EIP-721 Metadata Update Extension
interface IERC4906 is IERC165, IERC721 {
/// @dev This event emits when the metadata of a token is changed.
/// So that the third-party platforms such as NFT market could
/// timely update the images and related attributes of the NFT.
event MetadataUpdate(uint256 _tokenId);
/// @dev This event emits when the metadata of a range of tokens is changed.
/// So that the third-party platforms such as NFT market could
/// timely update the images and related attributes of the NFTs.
event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC5267.sol)
pragma solidity ^0.8.20;
interface IERC5267 {
/**
* @dev MAY be emitted to signal that the domain could have changed.
*/
event EIP712DomainChanged();
/**
* @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
* signature.
*/
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC721.sol)
pragma solidity ^0.8.20;
import {IERC721} from "../token/ERC721/IERC721.sol";// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard ERC20 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
*/
interface IERC20Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC20InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC20InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
* @param spender Address that may be allowed to operate on tokens without being their owner.
* @param allowance Amount of tokens a `spender` is allowed to operate with.
* @param needed Minimum amount required to perform a transfer.
*/
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC20InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `spender` to be approved. Used in approvals.
* @param spender Address that may be allowed to operate on tokens without being their owner.
*/
error ERC20InvalidSpender(address spender);
}
/**
* @dev Standard ERC721 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
*/
interface IERC721Errors {
/**
* @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
* Used in balance queries.
* @param owner Address of the current owner of a token.
*/
error ERC721InvalidOwner(address owner);
/**
* @dev Indicates a `tokenId` whose `owner` is the zero address.
* @param tokenId Identifier number of a token.
*/
error ERC721NonexistentToken(uint256 tokenId);
/**
* @dev Indicates an error related to the ownership over a particular token. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param tokenId Identifier number of a token.
* @param owner Address of the current owner of a token.
*/
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC721InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC721InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param tokenId Identifier number of a token.
*/
error ERC721InsufficientApproval(address operator, uint256 tokenId);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC721InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC721InvalidOperator(address operator);
}
/**
* @dev Standard ERC1155 Errors
* Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
*/
interface IERC1155Errors {
/**
* @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
* @param balance Current balance for the interacting account.
* @param needed Minimum amount required to perform a transfer.
* @param tokenId Identifier number of a token.
*/
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
/**
* @dev Indicates a failure with the token `sender`. Used in transfers.
* @param sender Address whose tokens are being transferred.
*/
error ERC1155InvalidSender(address sender);
/**
* @dev Indicates a failure with the token `receiver`. Used in transfers.
* @param receiver Address to which tokens are being transferred.
*/
error ERC1155InvalidReceiver(address receiver);
/**
* @dev Indicates a failure with the `operator`’s approval. Used in transfers.
* @param operator Address that may be allowed to operate on tokens without being their owner.
* @param owner Address of the current owner of a token.
*/
error ERC1155MissingApprovalForAll(address operator, address owner);
/**
* @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
* @param approver Address initiating an approval operation.
*/
error ERC1155InvalidApprover(address approver);
/**
* @dev Indicates a failure with the `operator` to be approved. Used in approvals.
* @param operator Address that may be allowed to operate on tokens without being their owner.
*/
error ERC1155InvalidOperator(address operator);
/**
* @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
* Used in batch transfers.
* @param idsLength Length of the array of token identifiers
* @param valuesLength Length of the array of token amounts
*/
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*/
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `value`.
*/
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `value`.
* - the caller must have allowance for ``from``'s tokens of at least
* `value`.
*/
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
/**
* @dev Moves a `value` amount of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
/**
* @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
* (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
* this function.
*
* Emits a {Transfer} event.
*/
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
// Overflow check required: The rest of the code assumes that totalSupply never overflows
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
// Overflow not possible: value <= fromBalance <= totalSupply.
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
// Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
_totalSupply -= value;
}
} else {
unchecked {
// Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
/**
* @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
* Relies on the `_update` mechanism
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead.
*/
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
* Relies on the `_update` mechanism.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* NOTE: This function is not virtual, {_update} should be overridden instead
*/
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
/**
* @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
/**
* @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
*
* By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
* `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
* `Approval` event during `transferFrom` operations.
*
* Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
* true using the following override:
* ```
* function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
* super._approve(owner, spender, value, true);
* }
* ```
*
* Requirements are the same as {_approve}.
*/
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `value`.
*
* Does not update the allowance value in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Does not emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Burnable.sol)
pragma solidity ^0.8.20;
import {ERC20} from "../ERC20.sol";
import {Context} from "../../../utils/Context.sol";
/**
* @dev Extension of {ERC20} that allows token holders to destroy both their own
* tokens and those that they have an allowance for, in a way that can be
* recognized off-chain (via event analysis).
*/
abstract contract ERC20Burnable is Context, ERC20 {
/**
* @dev Destroys a `value` amount of tokens from the caller.
*
* See {ERC20-_burn}.
*/
function burn(uint256 value) public virtual {
_burn(_msgSender(), value);
}
/**
* @dev Destroys a `value` amount of tokens from `account`, deducting from
* the caller's allowance.
*
* See {ERC20-_burn} and {ERC20-allowance}.
*
* Requirements:
*
* - the caller must have allowance for ``accounts``'s tokens of at least
* `value`.
*/
function burnFrom(address account, uint256 value) public virtual {
_spendAllowance(account, _msgSender(), value);
_burn(account, value);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/ERC20Capped.sol)
pragma solidity ^0.8.20;
import {ERC20} from "../ERC20.sol";
/**
* @dev Extension of {ERC20} that adds a cap to the supply of tokens.
*/
abstract contract ERC20Capped is ERC20 {
uint256 private immutable _cap;
/**
* @dev Total supply cap has been exceeded.
*/
error ERC20ExceededCap(uint256 increasedSupply, uint256 cap);
/**
* @dev The supplied cap is not a valid cap.
*/
error ERC20InvalidCap(uint256 cap);
/**
* @dev Sets the value of the `cap`. This value is immutable, it can only be
* set once during construction.
*/
constructor(uint256 cap_) {
if (cap_ == 0) {
revert ERC20InvalidCap(0);
}
_cap = cap_;
}
/**
* @dev Returns the cap on the token's total supply.
*/
function cap() public view virtual returns (uint256) {
return _cap;
}
/**
* @dev See {ERC20-_update}.
*/
function _update(address from, address to, uint256 value) internal virtual override {
super._update(from, to, value);
if (from == address(0)) {
uint256 maxSupply = cap();
uint256 supply = totalSupply();
if (supply > maxSupply) {
revert ERC20ExceededCap(supply, maxSupply);
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
/**
* @dev Interface for the optional metadata functions from the ERC20 standard.
*/
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/ERC721.sol)
pragma solidity ^0.8.20;
import {IERC721} from "./IERC721.sol";
import {IERC721Receiver} from "./IERC721Receiver.sol";
import {IERC721Metadata} from "./extensions/IERC721Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {Strings} from "../../utils/Strings.sol";
import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol";
import {IERC721Errors} from "../../interfaces/draft-IERC6093.sol";
/**
* @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
* the Metadata extension, but not including the Enumerable extension, which is available separately as
* {ERC721Enumerable}.
*/
abstract contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Errors {
using Strings for uint256;
// Token name
string private _name;
// Token symbol
string private _symbol;
mapping(uint256 tokenId => address) private _owners;
mapping(address owner => uint256) private _balances;
mapping(uint256 tokenId => address) private _tokenApprovals;
mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;
/**
* @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
return
interfaceId == type(IERC721).interfaceId ||
interfaceId == type(IERC721Metadata).interfaceId ||
super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721-balanceOf}.
*/
function balanceOf(address owner) public view virtual returns (uint256) {
if (owner == address(0)) {
revert ERC721InvalidOwner(address(0));
}
return _balances[owner];
}
/**
* @dev See {IERC721-ownerOf}.
*/
function ownerOf(uint256 tokenId) public view virtual returns (address) {
return _requireOwned(tokenId);
}
/**
* @dev See {IERC721Metadata-name}.
*/
function name() public view virtual returns (string memory) {
return _name;
}
/**
* @dev See {IERC721Metadata-symbol}.
*/
function symbol() public view virtual returns (string memory) {
return _symbol;
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
_requireOwned(tokenId);
string memory baseURI = _baseURI();
return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
}
/**
* @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
* token will be the concatenation of the `baseURI` and the `tokenId`. Empty
* by default, can be overridden in child contracts.
*/
function _baseURI() internal view virtual returns (string memory) {
return "";
}
/**
* @dev See {IERC721-approve}.
*/
function approve(address to, uint256 tokenId) public virtual {
_approve(to, tokenId, _msgSender());
}
/**
* @dev See {IERC721-getApproved}.
*/
function getApproved(uint256 tokenId) public view virtual returns (address) {
_requireOwned(tokenId);
return _getApproved(tokenId);
}
/**
* @dev See {IERC721-setApprovalForAll}.
*/
function setApprovalForAll(address operator, bool approved) public virtual {
_setApprovalForAll(_msgSender(), operator, approved);
}
/**
* @dev See {IERC721-isApprovedForAll}.
*/
function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
return _operatorApprovals[owner][operator];
}
/**
* @dev See {IERC721-transferFrom}.
*/
function transferFrom(address from, address to, uint256 tokenId) public virtual {
if (to == address(0)) {
revert ERC721InvalidReceiver(address(0));
}
// Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
// (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
address previousOwner = _update(to, tokenId, _msgSender());
if (previousOwner != from) {
revert ERC721IncorrectOwner(from, tokenId, previousOwner);
}
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) public {
safeTransferFrom(from, to, tokenId, "");
}
/**
* @dev See {IERC721-safeTransferFrom}.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
transferFrom(from, to, tokenId);
_checkOnERC721Received(from, to, tokenId, data);
}
/**
* @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
*
* IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
* core ERC721 logic MUST be matched with the use of {_increaseBalance} to keep balances
* consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
* `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
*/
function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
return _owners[tokenId];
}
/**
* @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
*/
function _getApproved(uint256 tokenId) internal view virtual returns (address) {
return _tokenApprovals[tokenId];
}
/**
* @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
* particular (ignoring whether it is owned by `owner`).
*
* WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
* assumption.
*/
function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
return
spender != address(0) &&
(owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
}
/**
* @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
* Reverts if `spender` does not have approval from the provided `owner` for the given token or for all its assets
* the `spender` for the specific `tokenId`.
*
* WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
* assumption.
*/
function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
if (!_isAuthorized(owner, spender, tokenId)) {
if (owner == address(0)) {
revert ERC721NonexistentToken(tokenId);
} else {
revert ERC721InsufficientApproval(spender, tokenId);
}
}
}
/**
* @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
*
* NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
* a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
*
* WARNING: Increasing an account's balance using this function tends to be paired with an override of the
* {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
* remain consistent with one another.
*/
function _increaseBalance(address account, uint128 value) internal virtual {
unchecked {
_balances[account] += value;
}
}
/**
* @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
* (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
*
* The `auth` argument is optional. If the value passed is non 0, then this function will check that
* `auth` is either the owner of the token, or approved to operate on the token (by the owner).
*
* Emits a {Transfer} event.
*
* NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
*/
function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
address from = _ownerOf(tokenId);
// Perform (optional) operator check
if (auth != address(0)) {
_checkAuthorized(from, auth, tokenId);
}
// Execute the update
if (from != address(0)) {
// Clear approval. No need to re-authorize or emit the Approval event
_approve(address(0), tokenId, address(0), false);
unchecked {
_balances[from] -= 1;
}
}
if (to != address(0)) {
unchecked {
_balances[to] += 1;
}
}
_owners[tokenId] = to;
emit Transfer(from, to, tokenId);
return from;
}
/**
* @dev Mints `tokenId` and transfers it to `to`.
*
* WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
*
* Requirements:
*
* - `tokenId` must not exist.
* - `to` cannot be the zero address.
*
* Emits a {Transfer} event.
*/
function _mint(address to, uint256 tokenId) internal {
if (to == address(0)) {
revert ERC721InvalidReceiver(address(0));
}
address previousOwner = _update(to, tokenId, address(0));
if (previousOwner != address(0)) {
revert ERC721InvalidSender(address(0));
}
}
/**
* @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
*
* Requirements:
*
* - `tokenId` must not exist.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeMint(address to, uint256 tokenId) internal {
_safeMint(to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
_mint(to, tokenId);
_checkOnERC721Received(address(0), to, tokenId, data);
}
/**
* @dev Destroys `tokenId`.
* The approval is cleared when the token is burned.
* This is an internal function that does not check if the sender is authorized to operate on the token.
*
* Requirements:
*
* - `tokenId` must exist.
*
* Emits a {Transfer} event.
*/
function _burn(uint256 tokenId) internal {
address previousOwner = _update(address(0), tokenId, address(0));
if (previousOwner == address(0)) {
revert ERC721NonexistentToken(tokenId);
}
}
/**
* @dev Transfers `tokenId` from `from` to `to`.
* As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
*
* Emits a {Transfer} event.
*/
function _transfer(address from, address to, uint256 tokenId) internal {
if (to == address(0)) {
revert ERC721InvalidReceiver(address(0));
}
address previousOwner = _update(to, tokenId, address(0));
if (previousOwner == address(0)) {
revert ERC721NonexistentToken(tokenId);
} else if (previousOwner != from) {
revert ERC721IncorrectOwner(from, tokenId, previousOwner);
}
}
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
* are aware of the ERC721 standard to prevent tokens from being forever locked.
*
* `data` is additional data, it has no specified format and it is sent in call to `to`.
*
* This internal function is like {safeTransferFrom} in the sense that it invokes
* {IERC721Receiver-onERC721Received} on the receiver, and can be used to e.g.
* implement alternative mechanisms to perform token transfer, such as signature-based.
*
* Requirements:
*
* - `tokenId` token must exist and be owned by `from`.
* - `to` cannot be the zero address.
* - `from` cannot be the zero address.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
*
* Emits a {Transfer} event.
*/
function _safeTransfer(address from, address to, uint256 tokenId) internal {
_safeTransfer(from, to, tokenId, "");
}
/**
* @dev Same as {xref-ERC721-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
* forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
*/
function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
_transfer(from, to, tokenId);
_checkOnERC721Received(from, to, tokenId, data);
}
/**
* @dev Approve `to` to operate on `tokenId`
*
* The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
* either the owner of the token, or approved to operate on all tokens held by this owner.
*
* Emits an {Approval} event.
*
* Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
*/
function _approve(address to, uint256 tokenId, address auth) internal {
_approve(to, tokenId, auth, true);
}
/**
* @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
* emitted in the context of transfers.
*/
function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
// Avoid reading the owner unless necessary
if (emitEvent || auth != address(0)) {
address owner = _requireOwned(tokenId);
// We do not use _isAuthorized because single-token approvals should not be able to call approve
if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
revert ERC721InvalidApprover(auth);
}
if (emitEvent) {
emit Approval(owner, to, tokenId);
}
}
_tokenApprovals[tokenId] = to;
}
/**
* @dev Approve `operator` to operate on all of `owner` tokens
*
* Requirements:
* - operator can't be the address zero.
*
* Emits an {ApprovalForAll} event.
*/
function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
if (operator == address(0)) {
revert ERC721InvalidOperator(operator);
}
_operatorApprovals[owner][operator] = approved;
emit ApprovalForAll(owner, operator, approved);
}
/**
* @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
* Returns the owner.
*
* Overrides to ownership logic should be done to {_ownerOf}.
*/
function _requireOwned(uint256 tokenId) internal view returns (address) {
address owner = _ownerOf(tokenId);
if (owner == address(0)) {
revert ERC721NonexistentToken(tokenId);
}
return owner;
}
/**
* @dev Private function to invoke {IERC721Receiver-onERC721Received} on a target address. This will revert if the
* recipient doesn't accept the token transfer. The call is not executed if the target address is not a contract.
*
* @param from address representing the previous owner of the given token ID
* @param to target address that will receive the tokens
* @param tokenId uint256 ID of the token to be transferred
* @param data bytes optional data to send along with the call
*/
function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory data) private {
if (to.code.length > 0) {
try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
if (retval != IERC721Receiver.onERC721Received.selector) {
revert ERC721InvalidReceiver(to);
}
} catch (bytes memory reason) {
if (reason.length == 0) {
revert ERC721InvalidReceiver(to);
} else {
/// @solidity memory-safe-assembly
assembly {
revert(add(32, reason), mload(reason))
}
}
}
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)
pragma solidity ^0.8.20;
import {IERC165} from "../../utils/introspection/IERC165.sol";
/**
* @dev Required interface of an ERC721 compliant contract.
*/
interface IERC721 is IERC165 {
/**
* @dev Emitted when `tokenId` token is transferred from `from` to `to`.
*/
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
*/
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
/**
* @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
*/
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
/**
* @dev Returns the number of tokens in ``owner``'s account.
*/
function balanceOf(address owner) external view returns (uint256 balance);
/**
* @dev Returns the owner of the `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function ownerOf(uint256 tokenId) external view returns (address owner);
/**
* @dev Safely transfers `tokenId` token from `from` to `to`.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
/**
* @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
* are aware of the ERC721 protocol to prevent tokens from being forever locked.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must exist and be owned by `from`.
* - If the caller is not `from`, it must have been allowed to move this token by either {approve} or
* {setApprovalForAll}.
* - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon
* a safe transfer.
*
* Emits a {Transfer} event.
*/
function safeTransferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Transfers `tokenId` token from `from` to `to`.
*
* WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
* or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
* understand this adds an external call which potentially creates a reentrancy vulnerability.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `tokenId` token must be owned by `from`.
* - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 tokenId) external;
/**
* @dev Gives permission to `to` to transfer `tokenId` token to another account.
* The approval is cleared when the token is transferred.
*
* Only a single account can be approved at a time, so approving the zero address clears previous approvals.
*
* Requirements:
*
* - The caller must own the token or be an approved operator.
* - `tokenId` must exist.
*
* Emits an {Approval} event.
*/
function approve(address to, uint256 tokenId) external;
/**
* @dev Approve or remove `operator` as an operator for the caller.
* Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
*
* Requirements:
*
* - The `operator` cannot be the address zero.
*
* Emits an {ApprovalForAll} event.
*/
function setApprovalForAll(address operator, bool approved) external;
/**
* @dev Returns the account approved for `tokenId` token.
*
* Requirements:
*
* - `tokenId` must exist.
*/
function getApproved(uint256 tokenId) external view returns (address operator);
/**
* @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
*
* See {setApprovalForAll}
*/
function isApprovedForAll(address owner, address operator) external view returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)
pragma solidity ^0.8.20;
/**
* @title ERC721 token receiver interface
* @dev Interface for any contract that wants to support safeTransfers
* from ERC721 asset contracts.
*/
interface IERC721Receiver {
/**
* @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
* by `operator` from `from`, this function is called.
*
* It must return its Solidity selector to confirm the token transfer.
* If any other value is returned or the interface is not implemented by the recipient, the transfer will be
* reverted.
*
* The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
*/
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes calldata data
) external returns (bytes4);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/ERC721URIStorage.sol)
pragma solidity ^0.8.20;
import {ERC721} from "../ERC721.sol";
import {Strings} from "../../../utils/Strings.sol";
import {IERC4906} from "../../../interfaces/IERC4906.sol";
import {IERC165} from "../../../interfaces/IERC165.sol";
/**
* @dev ERC721 token with storage based token URI management.
*/
abstract contract ERC721URIStorage is IERC4906, ERC721 {
using Strings for uint256;
// Interface ID as defined in ERC-4906. This does not correspond to a traditional interface ID as ERC-4906 only
// defines events and does not include any external function.
bytes4 private constant ERC4906_INTERFACE_ID = bytes4(0x49064906);
// Optional mapping for token URIs
mapping(uint256 tokenId => string) private _tokenURIs;
/**
* @dev See {IERC165-supportsInterface}
*/
function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, IERC165) returns (bool) {
return interfaceId == ERC4906_INTERFACE_ID || super.supportsInterface(interfaceId);
}
/**
* @dev See {IERC721Metadata-tokenURI}.
*/
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
_requireOwned(tokenId);
string memory _tokenURI = _tokenURIs[tokenId];
string memory base = _baseURI();
// If there is no base URI, return the token URI.
if (bytes(base).length == 0) {
return _tokenURI;
}
// If both are set, concatenate the baseURI and tokenURI (via string.concat).
if (bytes(_tokenURI).length > 0) {
return string.concat(base, _tokenURI);
}
return super.tokenURI(tokenId);
}
/**
* @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
*
* Emits {MetadataUpdate}.
*/
function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
_tokenURIs[tokenId] = _tokenURI;
emit MetadataUpdate(tokenId);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)
pragma solidity ^0.8.20;
import {IERC721} from "../IERC721.sol";
/**
* @title ERC-721 Non-Fungible Token Standard, optional metadata extension
* @dev See https://eips.ethereum.org/EIPS/eip-721
*/
interface IERC721Metadata is IERC721 {
/**
* @dev Returns the token collection name.
*/
function name() external view returns (string memory);
/**
* @dev Returns the token collection symbol.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
*/
function tokenURI(uint256 tokenId) external view returns (string memory);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)
pragma solidity ^0.8.20;
/**
* @dev Provides information about the current execution context, including the
* sender of the transaction and its data. While these are generally available
* via msg.sender and msg.data, they should not be accessed in such a direct
* manner, since when dealing with meta-transactions the account sending and
* paying for execution may not be the actual sender (as far as an application
* is concerned).
*
* This contract is only required for intermediate, library-like contracts.
*/
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ShortStrings.sol)
pragma solidity ^0.8.20;
import {StorageSlot} from "./StorageSlot.sol";
// | string | 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA |
// | length | 0x BB |
type ShortString is bytes32;
/**
* @dev This library provides functions to convert short memory strings
* into a `ShortString` type that can be used as an immutable variable.
*
* Strings of arbitrary length can be optimized using this library if
* they are short enough (up to 31 bytes) by packing them with their
* length (1 byte) in a single EVM word (32 bytes). Additionally, a
* fallback mechanism can be used for every other case.
*
* Usage example:
*
* ```solidity
* contract Named {
* using ShortStrings for *;
*
* ShortString private immutable _name;
* string private _nameFallback;
*
* constructor(string memory contractName) {
* _name = contractName.toShortStringWithFallback(_nameFallback);
* }
*
* function name() external view returns (string memory) {
* return _name.toStringWithFallback(_nameFallback);
* }
* }
* ```
*/
library ShortStrings {
// Used as an identifier for strings longer than 31 bytes.
bytes32 private constant FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
/**
* @dev Encode a string of at most 31 chars into a `ShortString`.
*
* This will trigger a `StringTooLong` error is the input string is too long.
*/
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
/**
* @dev Decode a `ShortString` back to a "normal" string.
*/
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
// using `new string(len)` would work locally but is not memory safe.
string memory str = new string(32);
/// @solidity memory-safe-assembly
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
/**
* @dev Return the length of a `ShortString`.
*/
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
/**
* @dev Encode a string into a `ShortString`, or write it to storage if it is too long.
*/
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(FALLBACK_SENTINEL);
}
}
/**
* @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}.
*/
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
/**
* @dev Return the length of a string that was encoded to `ShortString` or written to storage using
* {setWithFallback}.
*
* WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of
* actual characters as the UTF-8 encoding of a single character can span over multiple bytes.
*/
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.
pragma solidity ^0.8.20;
/**
* @dev Library for reading and writing primitive types to specific storage slots.
*
* Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
* This library helps with reading and writing to such slots without the need for inline assembly.
*
* The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
*
* Example usage to set ERC1967 implementation slot:
* ```solidity
* contract ERC1967 {
* bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
*
* function _getImplementation() internal view returns (address) {
* return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
* }
*
* function _setImplementation(address newImplementation) internal {
* require(newImplementation.code.length > 0);
* StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
* }
* }
* ```
*/
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
/**
* @dev Returns an `AddressSlot` with member `value` located at `slot`.
*/
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BooleanSlot` with member `value` located at `slot`.
*/
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
*/
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `Uint256Slot` with member `value` located at `slot`.
*/
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` with member `value` located at `slot`.
*/
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `StringSlot` representation of the string storage pointer `store`.
*/
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
/**
* @dev Returns an `BytesSlot` with member `value` located at `slot`.
*/
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := slot
}
}
/**
* @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
*/
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
/// @solidity memory-safe-assembly
assembly {
r.slot := store.slot
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Strings.sol)
pragma solidity ^0.8.20;
import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";
/**
* @dev String operations.
*/
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
/**
* @dev The `value` string doesn't fit in the specified `length`.
*/
error StringsInsufficientHexLength(uint256 value, uint256 length);
/**
* @dev Converts a `uint256` to its ASCII `string` decimal representation.
*/
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
/// @solidity memory-safe-assembly
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
/// @solidity memory-safe-assembly
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
/**
* @dev Converts a `int256` to its ASCII `string` decimal representation.
*/
function toStringSigned(int256 value) internal pure returns (string memory) {
return string.concat(value < 0 ? "-" : "", toString(SignedMath.abs(value)));
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
*/
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
/**
* @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
*/
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
/**
* @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal
* representation.
*/
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
/**
* @dev Returns true if the two strings are equal.
*/
function equal(string memory a, string memory b) internal pure returns (bool) {
return bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)
pragma solidity ^0.8.20;
/**
* @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
*
* These functions can be used to verify that a message was signed by the holder
* of the private keys of a given address.
*/
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
/**
* @dev The signature derives the `address(0)`.
*/
error ECDSAInvalidSignature();
/**
* @dev The signature has an invalid length.
*/
error ECDSAInvalidSignatureLength(uint256 length);
/**
* @dev The signature has an S value that is in the upper half order.
*/
error ECDSAInvalidSignatureS(bytes32 s);
/**
* @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
* return address(0) without also returning an error description. Errors are documented using an enum (error type)
* and a bytes32 providing additional information about the error.
*
* If no error is returned, then the address can be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*
* Documentation for signature generation:
* - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
* - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
*/
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
// ecrecover takes the signature parameters, and the only way to get them
// currently is to use assembly.
/// @solidity memory-safe-assembly
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
}
}
/**
* @dev Returns the address that signed a hashed message (`hash`) with
* `signature`. This address can then be used for verification purposes.
*
* The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
* this function rejects them by requiring the `s` value to be in the lower
* half order, and the `v` value to be either 27 or 28.
*
* IMPORTANT: `hash` _must_ be the result of a hash operation for the
* verification to be secure: it is possible to craft signatures that
* recover to arbitrary addresses for non-hashed data. A safe way to ensure
* this is by receiving a hash of the original message (which may otherwise
* be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
*/
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
*
* See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
*/
function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
unchecked {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
// We do not check for an overflow here since the shift operation results in 0 or 1.
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
}
/**
* @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
*/
function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Overload of {ECDSA-tryRecover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError, bytes32) {
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
// signatures from current libraries generate a unique signature with an s-value in the lower half order.
//
// If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
// with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
// vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
// these malleable signatures as well.
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
// If the signature is valid (and not malleable), return the signer address
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
/**
* @dev Overload of {ECDSA-recover} that receives the `v`,
* `r` and `s` signature fields separately.
*/
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
_throwError(error, errorArg);
return recovered;
}
/**
* @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
*/
function _throwError(RecoverError error, bytes32 errorArg) private pure {
if (error == RecoverError.NoError) {
return; // no error: do nothing
} else if (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} else if (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} else if (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/EIP712.sol)
pragma solidity ^0.8.20;
import {MessageHashUtils} from "./MessageHashUtils.sol";
import {ShortStrings, ShortString} from "../ShortStrings.sol";
import {IERC5267} from "../../interfaces/IERC5267.sol";
/**
* @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
*
* The encoding scheme specified in the EIP requires a domain separator and a hash of the typed structured data, whose
* encoding is very generic and therefore its implementation in Solidity is not feasible, thus this contract
* does not implement the encoding itself. Protocols need to implement the type-specific encoding they need in order to
* produce the hash of their typed data using a combination of `abi.encode` and `keccak256`.
*
* This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
* scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
* ({_hashTypedDataV4}).
*
* The implementation of the domain separator was designed to be as efficient as possible while still properly updating
* the chain id to protect against replay attacks on an eventual fork of the chain.
*
* NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
* https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
*
* NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
* separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the
* separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
*
* @custom:oz-upgrades-unsafe-allow state-variable-immutable
*/
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
// Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
// invalidate the cached domain separator if the chain id changes.
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
/**
* @dev Initializes the domain separator and parameter caches.
*
* The meaning of `name` and `version` is specified in
* https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
*
* - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
* - `version`: the current major version of the signing domain.
*
* NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
* contract upgrade].
*/
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
/**
* @dev Returns the domain separator for the current chain.
*/
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
/**
* @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
* function returns the hash of the fully encoded EIP712 message for this domain.
*
* This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
*
* ```solidity
* bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
* keccak256("Mail(address to,string contents)"),
* mailTo,
* keccak256(bytes(mailContents))
* )));
* address signer = ECDSA.recover(digest, signature);
* ```
*/
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
/**
* @dev See {IERC-5267}.
*/
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f", // 01111
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
/**
* @dev The name parameter for the EIP712 domain.
*
* NOTE: By default this function reads _name which is an immutable value.
* It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
*/
// solhint-disable-next-line func-name-mixedcase
function _EIP712Name() internal view returns (string memory) {
return _name.toStringWithFallback(_nameFallback);
}
/**
* @dev The version parameter for the EIP712 domain.
*
* NOTE: By default this function reads _version which is an immutable value.
* It only reads from storage if necessary (in case the value is too large to fit in a ShortString).
*/
// solhint-disable-next-line func-name-mixedcase
function _EIP712Version() internal view returns (string memory) {
return _version.toStringWithFallback(_versionFallback);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)
pragma solidity ^0.8.20;
import {Strings} from "../Strings.sol";
/**
* @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
*
* The library provides methods for generating a hash of a message that conforms to the
* https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
* specifications.
*/
library MessageHashUtils {
/**
* @dev Returns the keccak256 digest of an EIP-191 signed data with version
* `0x45` (`personal_sign` messages).
*
* The digest is calculated by prefixing a bytes32 `messageHash` with
* `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
* hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
*
* NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
* keccak256, although any bytes32 value can be safely used because the final digest will
* be re-hashed.
*
* See {ECDSA-recover}.
*/
function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
/// @solidity memory-safe-assembly
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
}
}
/**
* @dev Returns the keccak256 digest of an EIP-191 signed data with version
* `0x45` (`personal_sign` messages).
*
* The digest is calculated by prefixing an arbitrary `message` with
* `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
* hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
*
* See {ECDSA-recover}.
*/
function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
return
keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
}
/**
* @dev Returns the keccak256 digest of an EIP-191 signed data with version
* `0x00` (data with intended validator).
*
* The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
* `validator` address. Then hashing the result.
*
* See {ECDSA-recover}.
*/
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
/**
* @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
*
* The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
* `\x19\x01` and hashing the result. It corresponds to the hash signed by the
* https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
*
* See {ECDSA-recover}.
*/
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
/// @solidity memory-safe-assembly
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/SignatureChecker.sol)
pragma solidity ^0.8.20;
import {ECDSA} from "./ECDSA.sol";
import {IERC1271} from "../../interfaces/IERC1271.sol";
/**
* @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
* signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
* Argent and Safe Wallet (previously Gnosis Safe).
*/
library SignatureChecker {
/**
* @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
* signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
*
* NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
* change through time. It could return true at block N and false at block N+1 (or the opposite).
*/
function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
(address recovered, ECDSA.RecoverError error, ) = ECDSA.tryRecover(hash, signature);
return
(error == ECDSA.RecoverError.NoError && recovered == signer) ||
isValidERC1271SignatureNow(signer, hash, signature);
}
/**
* @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
* against the signer smart contract using ERC1271.
*
* NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
* change through time. It could return true at block N and false at block N+1 (or the opposite).
*/
function isValidERC1271SignatureNow(
address signer,
bytes32 hash,
bytes memory signature
) internal view returns (bool) {
(bool success, bytes memory result) = signer.staticcall(
abi.encodeCall(IERC1271.isValidSignature, (hash, signature))
);
return (success &&
result.length >= 32 &&
abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/ERC165.sol)
pragma solidity ^0.8.20;
import {IERC165} from "./IERC165.sol";
/**
* @dev Implementation of the {IERC165} interface.
*
* Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
* for the additional interface id that will be supported. For example:
*
* ```solidity
* function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
* return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
* }
* ```
*/
abstract contract ERC165 is IERC165 {
/**
* @dev See {IERC165-supportsInterface}.
*/
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/introspection/IERC165.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC165 standard, as defined in the
* https://eips.ethereum.org/EIPS/eip-165[EIP].
*
* Implementers can declare support of contract interfaces, which can then be
* queried by others ({ERC165Checker}).
*
* For an implementation, see {ERC165}.
*/
interface IERC165 {
/**
* @dev Returns true if this contract implements the interface defined by
* `interfaceId`. See the corresponding
* https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
* to learn more about how these ids are created.
*
* This function call must use less than 30 000 gas.
*/
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/Math.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard math utilities missing in the Solidity language.
*/
library Math {
/**
* @dev Muldiv operation overflow.
*/
error MathOverflowedMulDiv();
enum Rounding {
Floor, // Toward negative infinity
Ceil, // Toward positive infinity
Trunc, // Toward zero
Expand // Away from zero
}
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*/
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the subtraction of two unsigned integers, with an overflow flag.
*/
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*/
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*/
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*/
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the largest of two numbers.
*/
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two numbers.
*/
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two numbers. The result is rounded towards
* zero.
*/
function average(uint256 a, uint256 b) internal pure returns (uint256) {
// (a + b) / 2 can overflow.
return (a & b) + (a ^ b) / 2;
}
/**
* @dev Returns the ceiling of the division of two numbers.
*
* This differs from standard division with `/` in that it rounds towards infinity instead
* of rounding towards zero.
*/
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
// Guarantee the same behavior as in a regular Solidity division.
return a / b;
}
// (a + b - 1) / b can overflow on addition, so we distribute.
return a == 0 ? 0 : (a - 1) / b + 1;
}
/**
* @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
* denominator == 0.
* @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
* Uniswap Labs also under MIT license.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
unchecked {
// 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
// use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
// variables such that product = prod1 * 2^256 + prod0.
uint256 prod0 = x * y; // Least significant 256 bits of the product
uint256 prod1; // Most significant 256 bits of the product
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
// Handle non-overflow cases, 256 by 256 division.
if (prod1 == 0) {
// Solidity will revert if denominator == 0, unlike the div opcode on its own.
// The surrounding unchecked block does not change this fact.
// See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
return prod0 / denominator;
}
// Make sure the result is less than 2^256. Also prevents denominator == 0.
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
///////////////////////////////////////////////
// 512 by 256 division.
///////////////////////////////////////////////
// Make division exact by subtracting the remainder from [prod1 prod0].
uint256 remainder;
assembly {
// Compute remainder using mulmod.
remainder := mulmod(x, y, denominator)
// Subtract 256 bit number from 512 bit number.
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
// Factor powers of two out of denominator and compute largest power of two divisor of denominator.
// Always >= 1. See https://cs.stackexchange.com/q/138556/92363.
uint256 twos = denominator & (0 - denominator);
assembly {
// Divide denominator by twos.
denominator := div(denominator, twos)
// Divide [prod1 prod0] by twos.
prod0 := div(prod0, twos)
// Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
twos := add(div(sub(0, twos), twos), 1)
}
// Shift in bits from prod1 into prod0.
prod0 |= prod1 * twos;
// Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
// that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
// four bits. That is, denominator * inv = 1 mod 2^4.
uint256 inverse = (3 * denominator) ^ 2;
// Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
// works in modular arithmetic, doubling the correct bits in each step.
inverse *= 2 - denominator * inverse; // inverse mod 2^8
inverse *= 2 - denominator * inverse; // inverse mod 2^16
inverse *= 2 - denominator * inverse; // inverse mod 2^32
inverse *= 2 - denominator * inverse; // inverse mod 2^64
inverse *= 2 - denominator * inverse; // inverse mod 2^128
inverse *= 2 - denominator * inverse; // inverse mod 2^256
// Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
// This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
// less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
// is no longer required.
result = prod0 * inverse;
return result;
}
}
/**
* @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
*/
function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
/**
* @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
* towards zero.
*
* Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
*/
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
// For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
//
// We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
// `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
//
// This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
// → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
// → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
//
// Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
uint256 result = 1 << (log2(a) >> 1);
// At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
// since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
// every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
// into the expected uint128 result.
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
/**
* @notice Calculates sqrt(a), following the selected rounding direction.
*/
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
/**
* @dev Return the log in base 2 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 2, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 10 of a positive value rounded towards zero.
* Returns 0 if given 0.
*/
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 10, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
/**
* @dev Return the log in base 256 of a positive value rounded towards zero.
* Returns 0 if given 0.
*
* Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
*/
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
/**
* @dev Return the log in base 256, following the selected rounding direction, of a positive value.
* Returns 0 if given 0.
*/
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
}
}
/**
* @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
*/
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/math/SignedMath.sol)
pragma solidity ^0.8.20;
/**
* @dev Standard signed math utilities missing in the Solidity language.
*/
library SignedMath {
/**
* @dev Returns the largest of two signed numbers.
*/
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
/**
* @dev Returns the smallest of two signed numbers.
*/
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
/**
* @dev Returns the average of two signed numbers without overflow.
* The result is rounded towards zero.
*/
function average(int256 a, int256 b) internal pure returns (int256) {
// Formula from the book "Hacker's Delight"
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
/**
* @dev Returns the absolute unsigned value of a signed value.
*/
function abs(int256 n) internal pure returns (uint256) {
unchecked {
// must be unchecked in order to support `n = type(int256).min`
return uint256(n >= 0 ? n : -n);
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./interfaces/IBootloaderUtilities.sol";
import "./libraries/TransactionHelper.sol";
import "./libraries/RLPEncoder.sol";
import "./libraries/EfficientCall.sol";
/**
* @author Matter Labs
* @notice A contract that provides some utility methods for the bootloader
* that is very hard to write in Yul.
*/
contract BootloaderUtilities is IBootloaderUtilities {
using TransactionHelper for *;
/// @notice Calculates the canonical transaction hash and the recommended transaction hash.
/// @param _transaction The transaction.
/// @return txHash and signedTxHash of the transaction, i.e. the transaction hash to be used in the explorer and commits to all
/// the fields of the transaction and the recommended hash to be signed for this transaction.
/// @dev txHash must be unique for all transactions.
function getTransactionHashes(
Transaction calldata _transaction
) external view override returns (bytes32 txHash, bytes32 signedTxHash) {
signedTxHash = _transaction.encodeHash();
if (_transaction.txType == EIP_712_TX_TYPE) {
txHash = keccak256(bytes.concat(signedTxHash, EfficientCall.keccak(_transaction.signature)));
} else if (_transaction.txType == LEGACY_TX_TYPE) {
txHash = encodeLegacyTransactionHash(_transaction);
} else if (_transaction.txType == EIP_1559_TX_TYPE) {
txHash = encodeEIP1559TransactionHash(_transaction);
} else if (_transaction.txType == EIP_2930_TX_TYPE) {
txHash = encodeEIP2930TransactionHash(_transaction);
} else {
revert("Unsupported tx type");
}
}
/// @notice Calculates the hash for a legacy transaction.
/// @param _transaction The legacy transaction.
/// @return txHash The hash of the transaction.
function encodeLegacyTransactionHash(Transaction calldata _transaction) internal view returns (bytes32 txHash) {
// Hash of legacy transactions are encoded as one of the:
// - RLP(nonce, gasPrice, gasLimit, to, value, data, chainId, 0, 0)
// - RLP(nonce, gasPrice, gasLimit, to, value, data)
//
// In this RLP encoding, only the first one above list appears, so we encode each element
// inside list and then concatenate the length of all elements with them.
bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
// Encode `gasPrice` and `gasLimit` together to prevent "stack too deep error".
bytes memory encodedGasParam;
{
bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
encodedGasParam = bytes.concat(encodedGasPrice, encodedGasLimit);
}
bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
// Encode only the length of the transaction data, and not the data itself,
// so as not to copy to memory a potentially huge transaction data twice.
bytes memory encodedDataLength;
{
// Safe cast, because the length of the transaction data can't be so large.
uint64 txDataLen = uint64(_transaction.data.length);
if (txDataLen != 1) {
// If the length is not equal to one, then only using the length can it be encoded definitely.
encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
} else if (_transaction.data[0] >= 0x80) {
// If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
encodedDataLength = hex"81";
}
// Otherwise the length is not encoded at all.
}
bytes memory rEncoded;
{
uint256 rInt = uint256(bytes32(_transaction.signature[0:32]));
rEncoded = RLPEncoder.encodeUint256(rInt);
}
bytes memory sEncoded;
{
uint256 sInt = uint256(bytes32(_transaction.signature[32:64]));
sEncoded = RLPEncoder.encodeUint256(sInt);
}
bytes memory vEncoded;
{
uint256 vInt = uint256(uint8(_transaction.signature[64]));
require(vInt == 27 || vInt == 28, "Invalid v value");
// If the `chainId` is specified in the transaction, then the `v` value is encoded as
// `35 + y + 2 * chainId == vInt + 8 + 2 * chainId`, where y - parity bit (see EIP-155).
if (_transaction.reserved[0] != 0) {
vInt += 8 + block.chainid * 2;
}
vEncoded = RLPEncoder.encodeUint256(vInt);
}
bytes memory encodedListLength;
unchecked {
uint256 listLength = encodedNonce.length +
encodedGasParam.length +
encodedTo.length +
encodedValue.length +
encodedDataLength.length +
_transaction.data.length +
rEncoded.length +
sEncoded.length +
vEncoded.length;
// Safe cast, because the length of the list can't be so large.
encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
}
return
keccak256(
bytes.concat(
encodedListLength,
encodedNonce,
encodedGasParam,
encodedTo,
encodedValue,
encodedDataLength,
_transaction.data,
vEncoded,
rEncoded,
sEncoded
)
);
}
/// @notice Calculates the hash for an EIP2930 transaction.
/// @param _transaction The EIP2930 transaction.
/// @return txHash The hash of the transaction.
function encodeEIP2930TransactionHash(Transaction calldata _transaction) internal view returns (bytes32) {
// Encode all fixed-length params to avoid "stack too deep error"
bytes memory encodedFixedLengthParams;
{
bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
encodedFixedLengthParams = bytes.concat(
encodedChainId,
encodedNonce,
encodedGasPrice,
encodedGasLimit,
encodedTo,
encodedValue
);
}
// Encode only the length of the transaction data, and not the data itself,
// so as not to copy to memory a potentially huge transaction data twice.
bytes memory encodedDataLength;
{
// Safe cast, because the length of the transaction data can't be so large.
uint64 txDataLen = uint64(_transaction.data.length);
if (txDataLen != 1) {
// If the length is not equal to one, then only using the length can it be encoded definitely.
encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
} else if (_transaction.data[0] >= 0x80) {
// If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
encodedDataLength = hex"81";
}
// Otherwise the length is not encoded at all.
}
// On zkSync, access lists are always zero length (at least for now).
bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);
bytes memory rEncoded;
{
uint256 rInt = uint256(bytes32(_transaction.signature[0:32]));
rEncoded = RLPEncoder.encodeUint256(rInt);
}
bytes memory sEncoded;
{
uint256 sInt = uint256(bytes32(_transaction.signature[32:64]));
sEncoded = RLPEncoder.encodeUint256(sInt);
}
bytes memory vEncoded;
{
uint256 vInt = uint256(uint8(_transaction.signature[64]));
require(vInt == 27 || vInt == 28, "Invalid v value");
vEncoded = RLPEncoder.encodeUint256(vInt - 27);
}
bytes memory encodedListLength;
unchecked {
uint256 listLength = encodedFixedLengthParams.length +
encodedDataLength.length +
_transaction.data.length +
encodedAccessListLength.length +
rEncoded.length +
sEncoded.length +
vEncoded.length;
// Safe cast, because the length of the list can't be so large.
encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
}
return
keccak256(
bytes.concat(
"\x01",
encodedListLength,
encodedFixedLengthParams,
encodedDataLength,
_transaction.data,
encodedAccessListLength,
vEncoded,
rEncoded,
sEncoded
)
);
}
/// @notice Calculates the hash for an EIP1559 transaction.
/// @param _transaction The legacy transaction.
/// @return txHash The hash of the transaction.
function encodeEIP1559TransactionHash(Transaction calldata _transaction) internal view returns (bytes32) {
// The formula for hash of EIP1559 transaction in the original proposal:
// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md
// Encode all fixed-length params to avoid "stack too deep error"
bytes memory encodedFixedLengthParams;
{
bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
bytes memory encodedMaxPriorityFeePerGas = RLPEncoder.encodeUint256(_transaction.maxPriorityFeePerGas);
bytes memory encodedMaxFeePerGas = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
encodedFixedLengthParams = bytes.concat(
encodedChainId,
encodedNonce,
encodedMaxPriorityFeePerGas,
encodedMaxFeePerGas,
encodedGasLimit,
encodedTo,
encodedValue
);
}
// Encode only the length of the transaction data, and not the data itself,
// so as not to copy to memory a potentially huge transaction data twice.
bytes memory encodedDataLength;
{
// Safe cast, because the length of the transaction data can't be so large.
uint64 txDataLen = uint64(_transaction.data.length);
if (txDataLen != 1) {
// If the length is not equal to one, then only using the length can it be encoded definitely.
encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
} else if (_transaction.data[0] >= 0x80) {
// If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
encodedDataLength = hex"81";
}
// Otherwise the length is not encoded at all.
}
// On zkSync, access lists are always zero length (at least for now).
bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);
bytes memory rEncoded;
{
uint256 rInt = uint256(bytes32(_transaction.signature[0:32]));
rEncoded = RLPEncoder.encodeUint256(rInt);
}
bytes memory sEncoded;
{
uint256 sInt = uint256(bytes32(_transaction.signature[32:64]));
sEncoded = RLPEncoder.encodeUint256(sInt);
}
bytes memory vEncoded;
{
uint256 vInt = uint256(uint8(_transaction.signature[64]));
require(vInt == 27 || vInt == 28, "Invalid v value");
vEncoded = RLPEncoder.encodeUint256(vInt - 27);
}
bytes memory encodedListLength;
unchecked {
uint256 listLength = encodedFixedLengthParams.length +
encodedDataLength.length +
_transaction.data.length +
encodedAccessListLength.length +
rEncoded.length +
sEncoded.length +
vEncoded.length;
// Safe cast, because the length of the list can't be so large.
encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
}
return
keccak256(
bytes.concat(
"\x02",
encodedListLength,
encodedFixedLengthParams,
encodedDataLength,
_transaction.data,
encodedAccessListLength,
vEncoded,
rEncoded,
sEncoded
)
);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./interfaces/IAccountCodeStorage.sol";
import "./interfaces/INonceHolder.sol";
import "./interfaces/IContractDeployer.sol";
import "./interfaces/IKnownCodesStorage.sol";
import "./interfaces/IImmutableSimulator.sol";
import "./interfaces/IEthToken.sol";
import "./interfaces/IL1Messenger.sol";
import "./interfaces/ISystemContext.sol";
import "./interfaces/IBytecodeCompressor.sol";
import "./BootloaderUtilities.sol";
/// @dev All the system contracts introduced by zkSync have their addresses
/// started from 2^15 in order to avoid collision with Ethereum precompiles.
uint160 constant SYSTEM_CONTRACTS_OFFSET = 0x8000; // 2^15
/// @dev All the system contracts must be located in the kernel space,
/// i.e. their addresses must be below 2^16.
uint160 constant MAX_SYSTEM_CONTRACT_ADDRESS = 0xffff; // 2^16 - 1
address constant ECRECOVER_SYSTEM_CONTRACT = address(0x01);
address constant SHA256_SYSTEM_CONTRACT = address(0x02);
/// @dev The current maximum deployed precompile address.
/// Note: currently only two precompiles are deployed:
/// 0x01 - ecrecover
/// 0x02 - sha256
/// Important! So the constant should be updated if more precompiles are deployed.
uint256 constant CURRENT_MAX_PRECOMPILE_ADDRESS = uint256(uint160(SHA256_SYSTEM_CONTRACT));
address payable constant BOOTLOADER_FORMAL_ADDRESS = payable(address(SYSTEM_CONTRACTS_OFFSET + 0x01));
IAccountCodeStorage constant ACCOUNT_CODE_STORAGE_SYSTEM_CONTRACT = IAccountCodeStorage(
address(SYSTEM_CONTRACTS_OFFSET + 0x02)
);
INonceHolder constant NONCE_HOLDER_SYSTEM_CONTRACT = INonceHolder(address(SYSTEM_CONTRACTS_OFFSET + 0x03));
IKnownCodesStorage constant KNOWN_CODE_STORAGE_CONTRACT = IKnownCodesStorage(address(SYSTEM_CONTRACTS_OFFSET + 0x04));
IImmutableSimulator constant IMMUTABLE_SIMULATOR_SYSTEM_CONTRACT = IImmutableSimulator(
address(SYSTEM_CONTRACTS_OFFSET + 0x05)
);
IContractDeployer constant DEPLOYER_SYSTEM_CONTRACT = IContractDeployer(address(SYSTEM_CONTRACTS_OFFSET + 0x06));
// A contract that is allowed to deploy any codehash
// on any address. To be used only during an upgrade.
address constant FORCE_DEPLOYER = address(SYSTEM_CONTRACTS_OFFSET + 0x07);
IL1Messenger constant L1_MESSENGER_CONTRACT = IL1Messenger(address(SYSTEM_CONTRACTS_OFFSET + 0x08));
address constant MSG_VALUE_SYSTEM_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x09);
IEthToken constant ETH_TOKEN_SYSTEM_CONTRACT = IEthToken(address(SYSTEM_CONTRACTS_OFFSET + 0x0a));
address constant KECCAK256_SYSTEM_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x10);
ISystemContext constant SYSTEM_CONTEXT_CONTRACT = ISystemContext(payable(address(SYSTEM_CONTRACTS_OFFSET + 0x0b)));
BootloaderUtilities constant BOOTLOADER_UTILITIES = BootloaderUtilities(address(SYSTEM_CONTRACTS_OFFSET + 0x0c));
address constant EVENT_WRITER_CONTRACT = address(SYSTEM_CONTRACTS_OFFSET + 0x0d);
IBytecodeCompressor constant BYTECODE_COMPRESSOR_CONTRACT = IBytecodeCompressor(
address(SYSTEM_CONTRACTS_OFFSET + 0x0e)
);
/// @dev If the bitwise AND of the extraAbi[2] param when calling the MSG_VALUE_SIMULATOR
/// is non-zero, the call will be assumed to be a system one.
uint256 constant MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT = 1;
/// @dev The maximal msg.value that context can have
uint256 constant MAX_MSG_VALUE = 2 ** 128 - 1;
/// @dev Prefix used during derivation of account addresses using CREATE2
/// @dev keccak256("zksyncCreate2")
bytes32 constant CREATE2_PREFIX = 0x2020dba91b30cc0006188af794c2fb30dd8520db7e2c088b7fc7c103c00ca494;
/// @dev Prefix used during derivation of account addresses using CREATE
/// @dev keccak256("zksyncCreate")
bytes32 constant CREATE_PREFIX = 0x63bae3a9951d38e8a3fbb7b70909afc1200610fc5bc55ade242f815974674f23;// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IAccountCodeStorage {
function storeAccountConstructingCodeHash(address _address, bytes32 _hash) external;
function storeAccountConstructedCodeHash(address _address, bytes32 _hash) external;
function markAccountCodeHashAsConstructed(address _address) external;
function getRawCodeHash(address _address) external view returns (bytes32 codeHash);
function getCodeHash(uint256 _input) external view returns (bytes32 codeHash);
function getCodeSize(uint256 _input) external view returns (uint256 codeSize);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../libraries/TransactionHelper.sol";
interface IBootloaderUtilities {
function getTransactionHashes(
Transaction calldata _transaction
) external view returns (bytes32 txHash, bytes32 signedTxHash);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IBytecodeCompressor {
function publishCompressedBytecode(
bytes calldata _bytecode,
bytes calldata _rawCompressedData
) external payable returns (bytes32 bytecodeHash);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IContractDeployer {
/// @notice Defines the version of the account abstraction protocol
/// that a contract claims to follow.
/// - `None` means that the account is just a contract and it should never be interacted
/// with as a custom account
/// - `Version1` means that the account follows the first version of the account abstraction protocol
enum AccountAbstractionVersion {
None,
Version1
}
/// @notice Defines the nonce ordering used by the account
/// - `Sequential` means that it is expected that the nonces are monotonic and increment by 1
/// at a time (the same as EOAs).
/// - `Arbitrary` means that the nonces for the accounts can be arbitrary. The operator
/// should serve the transactions from such an account on a first-come-first-serve basis.
/// @dev This ordering is more of a suggestion to the operator on how the AA expects its transactions
/// to be processed and is not considered as a system invariant.
enum AccountNonceOrdering {
Sequential,
Arbitrary
}
struct AccountInfo {
AccountAbstractionVersion supportedAAVersion;
AccountNonceOrdering nonceOrdering;
}
event ContractDeployed(
address indexed deployerAddress,
bytes32 indexed bytecodeHash,
address indexed contractAddress
);
event AccountNonceOrderingUpdated(address indexed accountAddress, AccountNonceOrdering nonceOrdering);
event AccountVersionUpdated(address indexed accountAddress, AccountAbstractionVersion aaVersion);
function getNewAddressCreate2(
address _sender,
bytes32 _bytecodeHash,
bytes32 _salt,
bytes calldata _input
) external view returns (address newAddress);
function getNewAddressCreate(address _sender, uint256 _senderNonce) external pure returns (address newAddress);
function create2(
bytes32 _salt,
bytes32 _bytecodeHash,
bytes calldata _input
) external payable returns (address newAddress);
function create2Account(
bytes32 _salt,
bytes32 _bytecodeHash,
bytes calldata _input,
AccountAbstractionVersion _aaVersion
) external payable returns (address newAddress);
/// @dev While the `_salt` parameter is not used anywhere here,
/// it is still needed for consistency between `create` and
/// `create2` functions (required by the compiler).
function create(
bytes32 _salt,
bytes32 _bytecodeHash,
bytes calldata _input
) external payable returns (address newAddress);
/// @dev While `_salt` is never used here, we leave it here as a parameter
/// for the consistency with the `create` function.
function createAccount(
bytes32 _salt,
bytes32 _bytecodeHash,
bytes calldata _input,
AccountAbstractionVersion _aaVersion
) external payable returns (address newAddress);
/// @notice Returns the information about a certain AA.
function getAccountInfo(address _address) external view returns (AccountInfo memory info);
/// @notice Can be called by an account to update its account version
function updateAccountVersion(AccountAbstractionVersion _version) external;
/// @notice Can be called by an account to update its nonce ordering
function updateNonceOrdering(AccountNonceOrdering _nonceOrdering) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IEthToken {
function balanceOf(uint256) external view returns (uint256);
function transferFromTo(address _from, address _to, uint256 _amount) external;
function totalSupply() external view returns (uint256);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function mint(address _account, uint256 _amount) external;
function withdraw(address _l1Receiver) external payable;
event Mint(address indexed account, uint256 amount);
event Transfer(address indexed from, address indexed to, uint256 value);
event Withdrawal(address indexed _l2Sender, address indexed _l1Receiver, uint256 _amount);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
struct ImmutableData {
uint256 index;
bytes32 value;
}
interface IImmutableSimulator {
function getImmutable(address _dest, uint256 _index) external view returns (bytes32);
function setImmutables(address _dest, ImmutableData[] calldata _immutables) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IKnownCodesStorage {
event MarkedAsKnown(bytes32 indexed bytecodeHash, bool indexed sendBytecodeToL1);
function markFactoryDeps(bool _shouldSendToL1, bytes32[] calldata _hashes) external;
function markBytecodeAsPublished(
bytes32 _bytecodeHash,
bytes32 _l1PreimageHash,
uint256 _l1PreimageBytesLen
) external;
function getMarker(bytes32 _hash) external view returns (uint256);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IL1Messenger {
// Possibly in the future we will be able to track the messages sent to L1 with
// some hooks in the VM. For now, it is much easier to track them with L2 events.
event L1MessageSent(address indexed _sender, bytes32 indexed _hash, bytes _message);
function sendToL1(bytes memory _message) external returns (bytes32);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @author Matter Labs
* @dev Interface of the nonce holder contract -- a contract used by the system to ensure
* that there is always a unique identifier for a transaction with a particular account (we call it nonce).
* In other words, the pair of (address, nonce) should always be unique.
* @dev Custom accounts should use methods of this contract to store nonces or other possible unique identifiers
* for the transaction.
*/
interface INonceHolder {
event ValueSetUnderNonce(address indexed accountAddress, uint256 indexed key, uint256 value);
/// @dev Returns the current minimal nonce for account.
function getMinNonce(address _address) external view returns (uint256);
/// @dev Returns the raw version of the current minimal nonce
/// (equal to minNonce + 2^128 * deployment nonce).
function getRawNonce(address _address) external view returns (uint256);
/// @dev Increases the minimal nonce for the msg.sender.
function increaseMinNonce(uint256 _value) external returns (uint256);
/// @dev Sets the nonce value `key` as used.
function setValueUnderNonce(uint256 _key, uint256 _value) external;
/// @dev Gets the value stored inside a custom nonce.
function getValueUnderNonce(uint256 _key) external view returns (uint256);
/// @dev A convenience method to increment the minimal nonce if it is equal
/// to the `_expectedNonce`.
function incrementMinNonceIfEquals(uint256 _expectedNonce) external;
/// @dev Returns the deployment nonce for the accounts used for CREATE opcode.
function getDeploymentNonce(address _address) external view returns (uint256);
/// @dev Increments the deployment nonce for the account and returns the previous one.
function incrementDeploymentNonce(address _address) external returns (uint256);
/// @dev Determines whether a certain nonce has been already used for an account.
function validateNonceUsage(address _address, uint256 _key, bool _shouldBeUsed) external view;
/// @dev Returns whether a nonce has been used for an account.
function isNonceUsed(address _address, uint256 _nonce) external view returns (bool);
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../libraries/TransactionHelper.sol";
enum ExecutionResult {
Revert,
Success
}
bytes4 constant PAYMASTER_VALIDATION_SUCCESS_MAGIC = IPaymaster.validateAndPayForPaymasterTransaction.selector;
interface IPaymaster {
/// @dev Called by the bootloader to verify that the paymaster agrees to pay for the
/// fee for the transaction. This transaction should also send the necessary amount of funds onto the bootloader
/// address.
/// @param _txHash The hash of the transaction
/// @param _suggestedSignedHash The hash of the transaction that is signed by an EOA
/// @param _transaction The transaction itself.
/// @return magic The value that should be equal to the signature of the validateAndPayForPaymasterTransaction
/// if the paymaster agrees to pay for the transaction.
/// @return context The "context" of the transaction: an array of bytes of length at most 1024 bytes, which will be
/// passed to the `postTransaction` method of the account.
/// @dev The developer should strive to preserve as many steps as possible both for valid
/// and invalid transactions as this very method is also used during the gas fee estimation
/// (without some of the necessary data, e.g. signature).
function validateAndPayForPaymasterTransaction(
bytes32 _txHash,
bytes32 _suggestedSignedHash,
Transaction calldata _transaction
) external payable returns (bytes4 magic, bytes memory context);
/// @dev Called by the bootloader after the execution of the transaction. Please note that
/// there is no guarantee that this method will be called at all. Unlike the original EIP4337,
/// this method won't be called if the transaction execution results in out-of-gas.
/// @param _context, the context of the execution, returned by the "validateAndPayForPaymasterTransaction" method.
/// @param _transaction, the users' transaction.
/// @param _txResult, the result of the transaction execution (success or failure).
/// @param _maxRefundedGas, the upper bound on the amout of gas that could be refunded to the paymaster.
/// @dev The exact amount refunded depends on the gas spent by the "postOp" itself and so the developers should
/// take that into account.
function postTransaction(
bytes calldata _context,
Transaction calldata _transaction,
bytes32 _txHash,
bytes32 _suggestedSignedHash,
ExecutionResult _txResult,
uint256 _maxRefundedGas
) external payable;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @author Matter Labs
* @dev The interface that is used for encoding/decoding of
* different types of paymaster flows.
* @notice This is NOT an interface to be implementated
* by contracts. It is just used for encoding.
*/
interface IPaymasterFlow {
function general(bytes calldata input) external;
function approvalBased(address _token, uint256 _minAllowance, bytes calldata _innerInput) external;
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/**
* @author Matter Labs
* @notice Contract that stores some of the context variables, that may be either
* block-scoped, tx-scoped or system-wide.
*/
interface ISystemContext {
function chainId() external view returns (uint256);
function origin() external view returns (address);
function gasPrice() external view returns (uint256);
function blockGasLimit() external view returns (uint256);
function coinbase() external view returns (address);
function difficulty() external view returns (uint256);
function baseFee() external view returns (uint256);
function blockHash(uint256 _block) external view returns (bytes32);
function getBlockHashEVM(uint256 _block) external view returns (bytes32);
function getBlockNumberAndTimestamp() external view returns (uint256 blockNumber, uint256 blockTimestamp);
// Note, that for now, the implementation of the bootloader allows this variables to
// be incremented multiple times inside a block, so it should not relied upon right now.
function getBlockNumber() external view returns (uint256);
function getBlockTimestamp() external view returns (uint256);
}// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.0;
import "./SystemContractHelper.sol";
import "./Utils.sol";
import {SHA256_SYSTEM_CONTRACT, KECCAK256_SYSTEM_CONTRACT} from "../Constants.sol";
/**
* @author Matter Labs
* @notice This library is used to perform ultra-efficient calls using zkEVM-specific features.
* @dev EVM calls always accept a memory slice as input and return a memory slice as output.
* Therefore, even if the user has a ready-made calldata slice, they still need to copy it to memory
* before calling. This is especially inefficient for large inputs (proxies, multi-calls, etc.).
* In turn, zkEVM operates over a fat pointer, which is a set of (memory page, offset, start, length) in the memory/calldata/returndata.
* This allows forwarding the calldata slice as is, without copying it to memory.
* @dev Fat pointer is not just an integer, it is an extended data type supported on the VM level.
* zkEVM creates the wellformed fat pointers for all the calldata/returndata regions, later
* the contract may manipulate the already created fat pointers to forward a slice of the data, but not
* to create new fat pointers!
* @dev The allowed operation on fat pointers are:
* 1. `ptr.add` - Transforms `ptr.offset` into `ptr.offset + u32(_value)`. If overflow happens then it panics.
* 2. `ptr.sub` - Transforms `ptr.offset` into `ptr.offset - u32(_value)`. If underflow happens then it panics.
* 3. `ptr.pack` - Do the concatenation between the lowest 128 bits of the pointer itself and the highest 128 bits of `_value`. It is typically used to prepare the ABI for external calls.
* 4. `ptr.shrink` - Transforms `ptr.length` into `ptr.length - u32(_shrink)`. If underflow happens then it panics.
* @dev The call opcodes accept the fat pointer and change it to its canonical form before passing it to the child call
* 1. `ptr.start` is transformed into `ptr.offset + ptr.start`
* 2. `ptr.length` is transformed into `ptr.length - ptr.offset`
* 3. `ptr.offset` is transformed into `0`
*/
library EfficientCall {
/// @notice Call the `keccak256` without copying calldata to memory.
/// @param _data The preimage data.
/// @return The `keccak256` hash.
function keccak(bytes calldata _data) internal view returns (bytes32) {
bytes memory returnData = staticCall(gasleft(), KECCAK256_SYSTEM_CONTRACT, _data);
require(returnData.length == 32, "keccak256 returned invalid data");
return bytes32(returnData);
}
/// @notice Call the `sha256` precompile without copying calldata to memory.
/// @param _data The preimage data.
/// @return The `sha256` hash.
function sha(bytes calldata _data) internal view returns (bytes32) {
bytes memory returnData = staticCall(gasleft(), SHA256_SYSTEM_CONTRACT, _data);
require(returnData.length == 32, "sha returned invalid data");
return bytes32(returnData);
}
/// @notice Perform a `call` without copying calldata to memory.
/// @param _gas The gas to use for the call.
/// @param _address The address to call.
/// @param _value The `msg.value` to send.
/// @param _data The calldata to use for the call.
/// @param _isSystem Whether the call should contain the `isSystem` flag.
/// @return returnData The copied to memory return data.
function call(
uint256 _gas,
address _address,
uint256 _value,
bytes calldata _data,
bool _isSystem
) internal returns (bytes memory returnData) {
bool success = rawCall(_gas, _address, _value, _data, _isSystem);
returnData = _verifyCallResult(success);
}
/// @notice Perform a `staticCall` without copying calldata to memory.
/// @param _gas The gas to use for the call.
/// @param _address The address to call.
/// @param _data The calldata to use for the call.
/// @return returnData The copied to memory return data.
function staticCall(
uint256 _gas,
address _address,
bytes calldata _data
) internal view returns (bytes memory returnData) {
bool success = rawStaticCall(_gas, _address, _data);
returnData = _verifyCallResult(success);
}
/// @notice Perform a `delegateCall` without copying calldata to memory.
/// @param _gas The gas to use for the call.
/// @param _address The address to call.
/// @param _data The calldata to use for the call.
/// @return returnData The copied to memory return data.
function delegateCall(
uint256 _gas,
address _address,
bytes calldata _data
) internal returns (bytes memory returnData) {
bool success = rawDelegateCall(_gas, _address, _data);
returnData = _verifyCallResult(success);
}
/// @notice Perform a `mimicCall` (a call with custom msg.sender) without copying calldata to memory.
/// @param _gas The gas to use for the call.
/// @param _address The address to call.
/// @param _data The calldata to use for the call.
/// @param _whoToMimic The `msg.sender` for the next call.
/// @param _isConstructor Whether the call should contain the `isConstructor` flag.
/// @param _isSystem Whether the call should contain the `isSystem` flag.
/// @return returnData The copied to memory return data.
function mimicCall(
uint256 _gas,
address _address,
bytes calldata _data,
address _whoToMimic,
bool _isConstructor,
bool _isSystem
) internal returns (bytes memory returnData) {
bool success = rawMimicCall(_gas, _address, _data, _whoToMimic, _isConstructor, _isSystem);
returnData = _verifyCallResult(success);
}
/// @notice Perform a `call` without copying calldata to memory.
/// @param _gas The gas to use for the call.
/// @param _address The address to call.
/// @param _value The `msg.value` to send.
/// @param _data The calldata to use for the call.
/// @param _isSystem Whether the call should contain the `isSystem` flag.
/// @return success whether the call was successful.
function rawCall(
uint256 _gas,
address _address,
uint256 _value,
bytes calldata _data,
bool _isSystem
) internal returns (bool success) {
if (_value == 0) {
_loadFarCallABIIntoActivePtr(_gas, _data, false, _isSystem);
address callAddr = RAW_FAR_CALL_BY_REF_CALL_ADDRESS;
assembly {
success := call(_address, callAddr, 0, 0, 0xFFFF, 0, 0)
}
} else {
_loadFarCallABIIntoActivePtr(_gas, _data, false, true);
// If there is provided `msg.value` call the `MsgValueSimulator` to forward ether.
address msgValueSimulator = MSG_VALUE_SYSTEM_CONTRACT;
address callAddr = SYSTEM_CALL_BY_REF_CALL_ADDRESS;
// We need to supply the mask to the MsgValueSimulator to denote
// that the call should be a system one.
uint256 forwardMask = _isSystem ? MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT : 0;
assembly {
success := call(msgValueSimulator, callAddr, _value, _address, 0xFFFF, forwardMask, 0)
}
}
}
/// @notice Perform a `staticCall` without copying calldata to memory.
/// @param _gas The gas to use for the call.
/// @param _address The address to call.
/// @param _data The calldata to use for the call.
/// @return success whether the call was successful.
function rawStaticCall(uint256 _gas, address _address, bytes calldata _data) internal view returns (bool success) {
_loadFarCallABIIntoActivePtr(_gas, _data, false, false);
address callAddr = RAW_FAR_CALL_BY_REF_CALL_ADDRESS;
assembly {
success := staticcall(_address, callAddr, 0, 0xFFFF, 0, 0)
}
}
/// @notice Perform a `delegatecall` without copying calldata to memory.
/// @param _gas The gas to use for the call.
/// @param _address The address to call.
/// @param _data The calldata to use for the call.
/// @return success whether the call was successful.
function rawDelegateCall(uint256 _gas, address _address, bytes calldata _data) internal returns (bool success) {
_loadFarCallABIIntoActivePtr(_gas, _data, false, false);
address callAddr = RAW_FAR_CALL_BY_REF_CALL_ADDRESS;
assembly {
success := delegatecall(_address, callAddr, 0, 0xFFFF, 0, 0)
}
}
/// @notice Perform a `mimicCall` (call with custom msg.sender) without copying calldata to memory.
/// @param _gas The gas to use for the call.
/// @param _address The address to call.
/// @param _data The calldata to use for the call.
/// @param _whoToMimic The `msg.sender` for the next call.
/// @param _isConstructor Whether the call should contain the `isConstructor` flag.
/// @param _isSystem Whether the call should contain the `isSystem` flag.
/// @return success whether the call was successful.
/// @dev If called not in kernel mode, it will result in a revert (enforced by the VM)
function rawMimicCall(
uint256 _gas,
address _address,
bytes calldata _data,
address _whoToMimic,
bool _isConstructor,
bool _isSystem
) internal returns (bool success) {
_loadFarCallABIIntoActivePtr(_gas, _data, _isConstructor, _isSystem);
address callAddr = MIMIC_CALL_BY_REF_CALL_ADDRESS;
uint256 cleanupMask = ADDRESS_MASK;
assembly {
// Clearing values before usage in assembly, since Solidity
// doesn't do it by default
_whoToMimic := and(_whoToMimic, cleanupMask)
success := call(_address, callAddr, 0, 0, _whoToMimic, 0, 0)
}
}
/// @dev Verify that a low-level call was successful, and revert if it wasn't, by bubbling the revert reason.
/// @param _success Whether the call was successful.
/// @return returnData The copied to memory return data.
function _verifyCallResult(bool _success) private pure returns (bytes memory returnData) {
if (_success) {
uint256 size;
assembly {
size := returndatasize()
}
returnData = new bytes(size);
assembly {
returndatacopy(add(returnData, 0x20), 0, size)
}
} else {
propagateRevert();
}
}
/// @dev Propagate the revert reason from the current call to the caller.
function propagateRevert() internal pure {
assembly {
let size := returndatasize()
returndatacopy(0, 0, size)
revert(0, size)
}
}
/// @dev Load the far call ABI into active ptr, that will be used for the next call by reference.
/// @param _gas The gas to be passed to the call.
/// @param _data The calldata to be passed to the call.
/// @param _isConstructor Whether the call is a constructor call.
/// @param _isSystem Whether the call is a system call.
function _loadFarCallABIIntoActivePtr(
uint256 _gas,
bytes calldata _data,
bool _isConstructor,
bool _isSystem
) private view {
SystemContractHelper.loadCalldataIntoActivePtr();
// Currently, zkEVM considers the pointer valid if(ptr.offset < ptr.length || (ptr.length == 0 && ptr.offset == 0)), otherwise panics.
// So, if the data is empty we need to make the `ptr.length = ptr.offset = 0`, otherwise follow standard logic.
if (_data.length == 0) {
// Safe to cast, offset is never bigger than `type(uint32).max`
SystemContractHelper.ptrShrinkIntoActive(uint32(msg.data.length));
} else {
uint256 dataOffset;
assembly {
dataOffset := _data.offset
}
// Safe to cast, offset is never bigger than `type(uint32).max`
SystemContractHelper.ptrAddIntoActive(uint32(dataOffset));
// Safe to cast, `data.length` is never bigger than `type(uint32).max`
uint32 shrinkTo = uint32(msg.data.length - (_data.length + dataOffset));
SystemContractHelper.ptrShrinkIntoActive(shrinkTo);
}
uint32 gas = Utils.safeCastToU32(_gas);
uint256 farCallAbi = SystemContractsCaller.getFarCallABIWithEmptyFatPointer(
gas,
// Only rollup is supported for now
0,
CalldataForwardingMode.ForwardFatPointer,
_isConstructor,
_isSystem
);
SystemContractHelper.ptrPackIntoActivePtr(farCallAbi);
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
library RLPEncoder {
function encodeAddress(address _val) internal pure returns (bytes memory encoded) {
// The size is equal to 20 bytes of the address itself + 1 for encoding bytes length in RLP.
encoded = new bytes(0x15);
bytes20 shiftedVal = bytes20(_val);
assembly {
// In the first byte we write the encoded length as 0x80 + 0x14 == 0x94.
mstore(add(encoded, 0x20), 0x9400000000000000000000000000000000000000000000000000000000000000)
// Write address data without stripping zeros.
mstore(add(encoded, 0x21), shiftedVal)
}
}
function encodeUint256(uint256 _val) internal pure returns (bytes memory encoded) {
unchecked {
if (_val < 128) {
encoded = new bytes(1);
// Handle zero as a non-value, since stripping zeroes results in an empty byte array
encoded[0] = (_val == 0) ? bytes1(uint8(128)) : bytes1(uint8(_val));
} else {
uint256 hbs = _highestByteSet(_val);
encoded = new bytes(hbs + 2);
encoded[0] = bytes1(uint8(hbs + 0x81));
uint256 lbs = 31 - hbs;
uint256 shiftedVal = _val << (lbs * 8);
assembly {
mstore(add(encoded, 0x21), shiftedVal)
}
}
}
}
/// @notice Encodes the size of bytes in RLP format.
/// @param _len The length of the bytes to encode. It has a `uint64` type since as larger values are not supported.
/// NOTE: panics if the length is 1 since the length encoding is ambiguous in this case.
function encodeNonSingleBytesLen(uint64 _len) internal pure returns (bytes memory) {
assert(_len != 1);
return _encodeLength(_len, 0x80);
}
/// @notice Encodes the size of list items in RLP format.
/// @param _len The length of the bytes to encode. It has a `uint64` type since as larger values are not supported.
function encodeListLen(uint64 _len) internal pure returns (bytes memory) {
return _encodeLength(_len, 0xc0);
}
function _encodeLength(uint64 _len, uint256 _offset) private pure returns (bytes memory encoded) {
unchecked {
if (_len < 56) {
encoded = new bytes(1);
encoded[0] = bytes1(uint8(_len + _offset));
} else {
uint256 hbs = _highestByteSet(uint256(_len));
encoded = new bytes(hbs + 2);
encoded[0] = bytes1(uint8(_offset + hbs + 56));
uint256 lbs = 31 - hbs;
uint256 shiftedVal = uint256(_len) << (lbs * 8);
assembly {
mstore(add(encoded, 0x21), shiftedVal)
}
}
}
}
/// @notice Computes the index of the highest byte set in number.
/// @notice Uses little endian ordering (The least significant byte has index `0`).
/// NOTE: returns `0` for `0`
function _highestByteSet(uint256 _number) private pure returns (uint256 hbs) {
unchecked {
if (_number > type(uint128).max) {
_number >>= 128;
hbs += 16;
}
if (_number > type(uint64).max) {
_number >>= 64;
hbs += 8;
}
if (_number > type(uint32).max) {
_number >>= 32;
hbs += 4;
}
if (_number > type(uint16).max) {
_number >>= 16;
hbs += 2;
}
if (_number > type(uint8).max) {
hbs += 1;
}
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8;
import {MAX_SYSTEM_CONTRACT_ADDRESS, MSG_VALUE_SYSTEM_CONTRACT} from "../Constants.sol";
import "./SystemContractsCaller.sol";
import "./Utils.sol";
uint256 constant UINT32_MASK = 0xffffffff;
uint256 constant UINT128_MASK = 0xffffffffffffffffffffffffffffffff;
/// @dev The mask that is used to convert any uint256 to a proper address.
/// It needs to be padded with `00` to be treated as uint256 by Solidity
uint256 constant ADDRESS_MASK = 0x00ffffffffffffffffffffffffffffffffffffffff;
struct ZkSyncMeta {
uint32 gasPerPubdataByte;
uint32 heapSize;
uint32 auxHeapSize;
uint8 shardId;
uint8 callerShardId;
uint8 codeShardId;
}
enum Global {
CalldataPtr,
CallFlags,
ExtraABIData1,
ExtraABIData2,
ReturndataPtr
}
/**
* @author Matter Labs
* @notice Library used for accessing zkEVM-specific opcodes, needed for the development
* of system contracts.
* @dev While this library will be eventually available to public, some of the provided
* methods won't work for non-system contracts. We will not recommend this library
* for external use.
*/
library SystemContractHelper {
/// @notice Send an L2Log to L1.
/// @param _isService The `isService` flag.
/// @param _key The `key` part of the L2Log.
/// @param _value The `value` part of the L2Log.
/// @dev The meaning of all these parameters is context-dependent, but they
/// have no intrinsic meaning per se.
function toL1(bool _isService, bytes32 _key, bytes32 _value) internal {
address callAddr = TO_L1_CALL_ADDRESS;
assembly {
// Ensuring that the type is bool
_isService := and(_isService, 1)
// This `success` is always 0, but the method always succeeds
// (except for the cases when there is not enough gas)
let success := call(_isService, callAddr, _key, _value, 0xFFFF, 0, 0)
}
}
/// @notice Get address of the currently executed code.
/// @dev This allows differentiating between `call` and `delegatecall`.
/// During the former `this` and `codeAddress` are the same, while
/// during the latter they are not.
function getCodeAddress() internal view returns (address addr) {
address callAddr = CODE_ADDRESS_CALL_ADDRESS;
assembly {
addr := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
}
}
/// @notice Provide a compiler hint, by placing calldata fat pointer into virtual `ACTIVE_PTR`,
/// that can be manipulated by `ptr.add`/`ptr.sub`/`ptr.pack`/`ptr.shrink` later.
/// @dev This allows making a call by forwarding calldata pointer to the child call.
/// It is a much more efficient way to forward calldata, than standard EVM bytes copying.
function loadCalldataIntoActivePtr() internal view {
address callAddr = LOAD_CALLDATA_INTO_ACTIVE_PTR_CALL_ADDRESS;
assembly {
pop(staticcall(0, callAddr, 0, 0xFFFF, 0, 0))
}
}
/// @notice Compiler simulation of the `ptr.pack` opcode for the virtual `ACTIVE_PTR` pointer.
/// @dev Do the concatenation between lowest part of `ACTIVE_PTR` and highest part of `_farCallAbi`
/// forming packed fat pointer for a far call or ret ABI when necessary.
/// Note: Panics if the lowest 128 bits of `_farCallAbi` are not zeroes.
function ptrPackIntoActivePtr(uint256 _farCallAbi) internal view {
address callAddr = PTR_PACK_INTO_ACTIVE_CALL_ADDRESS;
assembly {
pop(staticcall(_farCallAbi, callAddr, 0, 0xFFFF, 0, 0))
}
}
/// @notice Compiler simulation of the `ptr.add` opcode for the virtual `ACTIVE_PTR` pointer.
/// @dev Transforms `ACTIVE_PTR.offset` into `ACTIVE_PTR.offset + u32(_value)`. If overflow happens then it panics.
function ptrAddIntoActive(uint32 _value) internal view {
address callAddr = PTR_ADD_INTO_ACTIVE_CALL_ADDRESS;
uint256 cleanupMask = UINT32_MASK;
assembly {
// Clearing input params as they are not cleaned by Solidity by default
_value := and(_value, cleanupMask)
pop(staticcall(_value, callAddr, 0, 0xFFFF, 0, 0))
}
}
/// @notice Compiler simulation of the `ptr.shrink` opcode for the virtual `ACTIVE_PTR` pointer.
/// @dev Transforms `ACTIVE_PTR.length` into `ACTIVE_PTR.length - u32(_shrink)`. If underflow happens then it panics.
function ptrShrinkIntoActive(uint32 _shrink) internal view {
address callAddr = PTR_SHRINK_INTO_ACTIVE_CALL_ADDRESS;
uint256 cleanupMask = UINT32_MASK;
assembly {
// Clearing input params as they are not cleaned by Solidity by default
_shrink := and(_shrink, cleanupMask)
pop(staticcall(_shrink, callAddr, 0, 0xFFFF, 0, 0))
}
}
/// @notice packs precompile parameters into one word
/// @param _inputMemoryOffset The memory offset in 32-byte words for the input data for calling the precompile.
/// @param _inputMemoryLength The length of the input data in words.
/// @param _outputMemoryOffset The memory offset in 32-byte words for the output data.
/// @param _outputMemoryLength The length of the output data in words.
/// @param _perPrecompileInterpreted The constant, the meaning of which is defined separately for
/// each precompile. For information, please read the documentation of the precompilecall log in
/// the VM.
function packPrecompileParams(
uint32 _inputMemoryOffset,
uint32 _inputMemoryLength,
uint32 _outputMemoryOffset,
uint32 _outputMemoryLength,
uint64 _perPrecompileInterpreted
) internal pure returns (uint256 rawParams) {
rawParams = _inputMemoryOffset;
rawParams |= uint256(_inputMemoryLength) << 32;
rawParams |= uint256(_outputMemoryOffset) << 64;
rawParams |= uint256(_outputMemoryLength) << 96;
rawParams |= uint256(_perPrecompileInterpreted) << 192;
}
/// @notice Call precompile with given parameters.
/// @param _rawParams The packed precompile params. They can be retrieved by
/// the `packPrecompileParams` method.
/// @param _gasToBurn The number of gas to burn during this call.
/// @return success Whether the call was successful.
/// @dev The list of currently available precompiles sha256, keccak256, ecrecover.
/// NOTE: The precompile type depends on `this` which calls precompile, which means that only
/// system contracts corresponding to the list of precompiles above can do `precompileCall`.
/// @dev If used not in the `sha256`, `keccak256` or `ecrecover` contracts, it will just burn the gas provided.
function precompileCall(uint256 _rawParams, uint32 _gasToBurn) internal view returns (bool success) {
address callAddr = PRECOMPILE_CALL_ADDRESS;
// After `precompileCall` gas will be burned down to 0 if there are not enough of them,
// thats why it should be checked before the call.
require(gasleft() >= _gasToBurn);
uint256 cleanupMask = UINT32_MASK;
assembly {
// Clearing input params as they are not cleaned by Solidity by default
_gasToBurn := and(_gasToBurn, cleanupMask)
success := staticcall(_rawParams, callAddr, _gasToBurn, 0xFFFF, 0, 0)
}
}
/// @notice Set `msg.value` to next far call.
/// @param _value The msg.value that will be used for the *next* call.
/// @dev If called not in kernel mode, it will result in a revert (enforced by the VM)
function setValueForNextFarCall(uint128 _value) internal returns (bool success) {
uint256 cleanupMask = UINT128_MASK;
address callAddr = SET_CONTEXT_VALUE_CALL_ADDRESS;
assembly {
// Clearing input params as they are not cleaned by Solidity by default
_value := and(_value, cleanupMask)
success := call(0, callAddr, _value, 0, 0xFFFF, 0, 0)
}
}
/// @notice Initialize a new event.
/// @param initializer The event initializing value.
/// @param value1 The first topic or data chunk.
function eventInitialize(uint256 initializer, uint256 value1) internal {
address callAddr = EVENT_INITIALIZE_ADDRESS;
assembly {
pop(call(initializer, callAddr, value1, 0, 0xFFFF, 0, 0))
}
}
/// @notice Continue writing the previously initialized event.
/// @param value1 The first topic or data chunk.
/// @param value2 The second topic or data chunk.
function eventWrite(uint256 value1, uint256 value2) internal {
address callAddr = EVENT_WRITE_ADDRESS;
assembly {
pop(call(value1, callAddr, value2, 0, 0xFFFF, 0, 0))
}
}
/// @notice Get the packed representation of the `ZkSyncMeta` from the current context.
/// @return meta The packed representation of the ZkSyncMeta.
/// @dev The fields in ZkSyncMeta are NOT tightly packed, i.e. there is a special rule on how
/// they are packed. For more information, please read the documentation on ZkSyncMeta.
function getZkSyncMetaBytes() internal view returns (uint256 meta) {
address callAddr = META_CALL_ADDRESS;
assembly {
meta := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
}
}
/// @notice Returns the bits [offset..offset+size-1] of the meta.
/// @param meta Packed representation of the ZkSyncMeta.
/// @param offset The offset of the bits.
/// @param size The size of the extracted number in bits.
/// @return result The extracted number.
function extractNumberFromMeta(uint256 meta, uint256 offset, uint256 size) internal pure returns (uint256 result) {
// Firstly, we delete all the bits after the field
uint256 shifted = (meta << (256 - size - offset));
// Then we shift everything back
result = (shifted >> (256 - size));
}
/// @notice Given the packed representation of `ZkSyncMeta`, retrieves the number of gas
/// that a single byte sent to L1 as pubdata costs.
/// @param meta Packed representation of the ZkSyncMeta.
/// @return gasPerPubdataByte The current price in gas per pubdata byte.
function getGasPerPubdataByteFromMeta(uint256 meta) internal pure returns (uint32 gasPerPubdataByte) {
gasPerPubdataByte = uint32(extractNumberFromMeta(meta, META_GAS_PER_PUBDATA_BYTE_OFFSET, 32));
}
/// @notice Given the packed representation of `ZkSyncMeta`, retrieves the number of the current size
/// of the heap in bytes.
/// @param meta Packed representation of the ZkSyncMeta.
/// @return heapSize The size of the memory in bytes byte.
/// @dev The following expression: getHeapSizeFromMeta(getZkSyncMetaBytes()) is
/// equivalent to the MSIZE in Solidity.
function getHeapSizeFromMeta(uint256 meta) internal pure returns (uint32 heapSize) {
heapSize = uint32(extractNumberFromMeta(meta, META_HEAP_SIZE_OFFSET, 32));
}
/// @notice Given the packed representation of `ZkSyncMeta`, retrieves the number of the current size
/// of the auxilary heap in bytes.
/// @param meta Packed representation of the ZkSyncMeta.
/// @return auxHeapSize The size of the auxilary memory in bytes byte.
/// @dev You can read more on auxilary memory in the VM1.2 documentation.
function getAuxHeapSizeFromMeta(uint256 meta) internal pure returns (uint32 auxHeapSize) {
auxHeapSize = uint32(extractNumberFromMeta(meta, META_AUX_HEAP_SIZE_OFFSET, 32));
}
/// @notice Given the packed representation of `ZkSyncMeta`, retrieves the shardId of `this`.
/// @param meta Packed representation of the ZkSyncMeta.
/// @return shardId The shardId of `this`.
/// @dev Currently only shard 0 (zkRollup) is supported.
function getShardIdFromMeta(uint256 meta) internal pure returns (uint8 shardId) {
shardId = uint8(extractNumberFromMeta(meta, META_SHARD_ID_OFFSET, 8));
}
/// @notice Given the packed representation of `ZkSyncMeta`, retrieves the shardId of
/// the msg.sender.
/// @param meta Packed representation of the ZkSyncMeta.
/// @return callerShardId The shardId of the msg.sender.
/// @dev Currently only shard 0 (zkRollup) is supported.
function getCallerShardIdFromMeta(uint256 meta) internal pure returns (uint8 callerShardId) {
callerShardId = uint8(extractNumberFromMeta(meta, META_CALLER_SHARD_ID_OFFSET, 8));
}
/// @notice Given the packed representation of `ZkSyncMeta`, retrieves the shardId of
/// the currently executed code.
/// @param meta Packed representation of the ZkSyncMeta.
/// @return codeShardId The shardId of the currently executed code.
/// @dev Currently only shard 0 (zkRollup) is supported.
function getCodeShardIdFromMeta(uint256 meta) internal pure returns (uint8 codeShardId) {
codeShardId = uint8(extractNumberFromMeta(meta, META_CODE_SHARD_ID_OFFSET, 8));
}
/// @notice Retrieves the ZkSyncMeta structure.
/// @return meta The ZkSyncMeta execution context parameters.
function getZkSyncMeta() internal view returns (ZkSyncMeta memory meta) {
uint256 metaPacked = getZkSyncMetaBytes();
meta.gasPerPubdataByte = getGasPerPubdataByteFromMeta(metaPacked);
meta.shardId = getShardIdFromMeta(metaPacked);
meta.callerShardId = getCallerShardIdFromMeta(metaPacked);
meta.codeShardId = getCodeShardIdFromMeta(metaPacked);
}
/// @notice Returns the call flags for the current call.
/// @return callFlags The bitmask of the callflags.
/// @dev Call flags is the value of the first register
/// at the start of the call.
/// @dev The zero bit of the callFlags indicates whether the call is
/// a constructor call. The first bit of the callFlags indicates whether
/// the call is a system one.
function getCallFlags() internal view returns (uint256 callFlags) {
address callAddr = CALLFLAGS_CALL_ADDRESS;
assembly {
callFlags := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
}
}
/// @notice Returns the current calldata pointer.
/// @return ptr The current calldata pointer.
/// @dev NOTE: This file is just an integer and it can not be used
/// to forward the calldata to the next calls in any way.
function getCalldataPtr() internal view returns (uint256 ptr) {
address callAddr = PTR_CALLDATA_CALL_ADDRESS;
assembly {
ptr := staticcall(0, callAddr, 0, 0xFFFF, 0, 0)
}
}
/// @notice Returns the N-th extraAbiParam for the current call.
/// @return extraAbiData The value of the N-th extraAbiParam for this call.
/// @dev It is equal to the value of the (N+2)-th register
/// at the start of the call.
function getExtraAbiData(uint256 index) internal view returns (uint256 extraAbiData) {
require(index < 10, "There are only 10 accessible registers");
address callAddr = GET_EXTRA_ABI_DATA_ADDRESS;
assembly {
extraAbiData := staticcall(index, callAddr, 0, 0xFFFF, 0, 0)
}
}
/// @notice Retuns whether the current call is a system call.
/// @return `true` or `false` based on whether the current call is a system call.
function isSystemCall() internal view returns (bool) {
uint256 callFlags = getCallFlags();
// When the system call is passed, the 2-bit it set to 1
return (callFlags & 2) != 0;
}
/// @notice Returns whether the address is a system contract.
/// @param _address The address to test
/// @return `true` or `false` based on whether the `_address` is a system contract.
function isSystemContract(address _address) internal pure returns (bool) {
return uint160(_address) <= uint160(MAX_SYSTEM_CONTRACT_ADDRESS);
}
}
/// @dev Solidity does not allow exporting modifiers via libraries, so
/// the only way to do reuse modifiers is to have a base contract
abstract contract ISystemContract {
/// @notice Modifier that makes sure that the method
/// can only be called via a system call.
modifier onlySystemCall() {
require(
SystemContractHelper.isSystemCall() || SystemContractHelper.isSystemContract(msg.sender),
"This method require system call flag"
);
_;
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8;
import {MSG_VALUE_SYSTEM_CONTRACT, MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT} from "../Constants.sol";
import "./Utils.sol";
// Addresses used for the compiler to be replaced with the
// zkSync-specific opcodes during the compilation.
// IMPORTANT: these are just compile-time constants and are used
// only if used in-place by Yul optimizer.
address constant TO_L1_CALL_ADDRESS = address((1 << 16) - 1);
address constant CODE_ADDRESS_CALL_ADDRESS = address((1 << 16) - 2);
address constant PRECOMPILE_CALL_ADDRESS = address((1 << 16) - 3);
address constant META_CALL_ADDRESS = address((1 << 16) - 4);
address constant MIMIC_CALL_CALL_ADDRESS = address((1 << 16) - 5);
address constant SYSTEM_MIMIC_CALL_CALL_ADDRESS = address((1 << 16) - 6);
address constant MIMIC_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 7);
address constant SYSTEM_MIMIC_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 8);
address constant RAW_FAR_CALL_CALL_ADDRESS = address((1 << 16) - 9);
address constant RAW_FAR_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 10);
address constant SYSTEM_CALL_CALL_ADDRESS = address((1 << 16) - 11);
address constant SYSTEM_CALL_BY_REF_CALL_ADDRESS = address((1 << 16) - 12);
address constant SET_CONTEXT_VALUE_CALL_ADDRESS = address((1 << 16) - 13);
address constant SET_PUBDATA_PRICE_CALL_ADDRESS = address((1 << 16) - 14);
address constant INCREMENT_TX_COUNTER_CALL_ADDRESS = address((1 << 16) - 15);
address constant PTR_CALLDATA_CALL_ADDRESS = address((1 << 16) - 16);
address constant CALLFLAGS_CALL_ADDRESS = address((1 << 16) - 17);
address constant PTR_RETURNDATA_CALL_ADDRESS = address((1 << 16) - 18);
address constant EVENT_INITIALIZE_ADDRESS = address((1 << 16) - 19);
address constant EVENT_WRITE_ADDRESS = address((1 << 16) - 20);
address constant LOAD_CALLDATA_INTO_ACTIVE_PTR_CALL_ADDRESS = address((1 << 16) - 21);
address constant LOAD_LATEST_RETURNDATA_INTO_ACTIVE_PTR_CALL_ADDRESS = address((1 << 16) - 22);
address constant PTR_ADD_INTO_ACTIVE_CALL_ADDRESS = address((1 << 16) - 23);
address constant PTR_SHRINK_INTO_ACTIVE_CALL_ADDRESS = address((1 << 16) - 24);
address constant PTR_PACK_INTO_ACTIVE_CALL_ADDRESS = address((1 << 16) - 25);
address constant MULTIPLICATION_HIGH_ADDRESS = address((1 << 16) - 26);
address constant GET_EXTRA_ABI_DATA_ADDRESS = address((1 << 16) - 27);
// All the offsets are in bits
uint256 constant META_GAS_PER_PUBDATA_BYTE_OFFSET = 0 * 8;
uint256 constant META_HEAP_SIZE_OFFSET = 8 * 8;
uint256 constant META_AUX_HEAP_SIZE_OFFSET = 12 * 8;
uint256 constant META_SHARD_ID_OFFSET = 28 * 8;
uint256 constant META_CALLER_SHARD_ID_OFFSET = 29 * 8;
uint256 constant META_CODE_SHARD_ID_OFFSET = 30 * 8;
/// @notice The way to forward the calldata:
/// - Use the current heap (i.e. the same as on EVM).
/// - Use the auxiliary heap.
/// - Forward via a pointer
/// @dev Note, that currently, users do not have access to the auxiliary
/// heap and so the only type of forwarding that will be used by the users
/// are UseHeap and ForwardFatPointer for forwarding a slice of the current calldata
/// to the next call.
enum CalldataForwardingMode {
UseHeap,
ForwardFatPointer,
UseAuxHeap
}
/**
* @author Matter Labs
* @notice A library that allows calling contracts with the `isSystem` flag.
* @dev It is needed to call ContractDeployer and NonceHolder.
*/
library SystemContractsCaller {
/// @notice Makes a call with the `isSystem` flag.
/// @param gasLimit The gas limit for the call.
/// @param to The address to call.
/// @param value The value to pass with the transaction.
/// @param data The calldata.
/// @return success Whether the transaction has been successful.
/// @dev Note, that the `isSystem` flag can only be set when calling system contracts.
function systemCall(uint32 gasLimit, address to, uint256 value, bytes memory data) internal returns (bool success) {
address callAddr = SYSTEM_CALL_CALL_ADDRESS;
uint32 dataStart;
assembly {
dataStart := add(data, 0x20)
}
uint32 dataLength = uint32(Utils.safeCastToU32(data.length));
uint256 farCallAbi = SystemContractsCaller.getFarCallABI(
0,
0,
dataStart,
dataLength,
gasLimit,
// Only rollup is supported for now
0,
CalldataForwardingMode.UseHeap,
false,
true
);
if (value == 0) {
// Doing the system call directly
assembly {
success := call(to, callAddr, 0, 0, farCallAbi, 0, 0)
}
} else {
address msgValueSimulator = MSG_VALUE_SYSTEM_CONTRACT;
// We need to supply the mask to the MsgValueSimulator to denote
// that the call should be a system one.
uint256 forwardMask = MSG_VALUE_SIMULATOR_IS_SYSTEM_BIT;
assembly {
success := call(msgValueSimulator, callAddr, value, to, farCallAbi, forwardMask, 0)
}
}
}
/// @notice Makes a call with the `isSystem` flag.
/// @param gasLimit The gas limit for the call.
/// @param to The address to call.
/// @param value The value to pass with the transaction.
/// @param data The calldata.
/// @return success Whether the transaction has been successful.
/// @return returnData The returndata of the transaction (revert reason in case the transaction has failed).
/// @dev Note, that the `isSystem` flag can only be set when calling system contracts.
function systemCallWithReturndata(
uint32 gasLimit,
address to,
uint128 value,
bytes memory data
) internal returns (bool success, bytes memory returnData) {
success = systemCall(gasLimit, to, value, data);
uint256 size;
assembly {
size := returndatasize()
}
returnData = new bytes(size);
assembly {
returndatacopy(add(returnData, 0x20), 0, size)
}
}
/// @notice Makes a call with the `isSystem` flag.
/// @param gasLimit The gas limit for the call.
/// @param to The address to call.
/// @param value The value to pass with the transaction.
/// @param data The calldata.
/// @return returnData The returndata of the transaction. In case the transaction reverts, the error
/// bubbles up to the parent frame.
/// @dev Note, that the `isSystem` flag can only be set when calling system contracts.
function systemCallWithPropagatedRevert(
uint32 gasLimit,
address to,
uint128 value,
bytes memory data
) internal returns (bytes memory returnData) {
bool success;
(success, returnData) = systemCallWithReturndata(gasLimit, to, value, data);
if (!success) {
assembly {
let size := mload(returnData)
revert(add(returnData, 0x20), size)
}
}
}
/// @notice Calculates the packed representation of the FarCallABI.
/// @param dataOffset Calldata offset in memory. Provide 0 unless using custom pointer.
/// @param memoryPage Memory page to use. Provide 0 unless using custom pointer.
/// @param dataStart The start of the calldata slice. Provide the offset in memory
/// if not using custom pointer.
/// @param dataLength The calldata length. Provide the length of the calldata in bytes
/// unless using custom pointer.
/// @param gasPassed The gas to pass with the call.
/// @param shardId Of the account to call. Currently only 0 is supported.
/// @param forwardingMode The forwarding mode to use:
/// - provide CalldataForwardingMode.UseHeap when using your current memory
/// - provide CalldataForwardingMode.ForwardFatPointer when using custom pointer.
/// @param isConstructorCall Whether the call will be a call to the constructor
/// (ignored when the caller is not a system contract).
/// @param isSystemCall Whether the call will have the `isSystem` flag.
/// @return farCallAbi The far call ABI.
/// @dev The `FarCallABI` has the following structure:
/// pub struct FarCallABI {
/// pub memory_quasi_fat_pointer: FatPointer,
/// pub gas_passed: u32,
/// pub shard_id: u8,
/// pub forwarding_mode: FarCallForwardPageType,
/// pub constructor_call: bool,
/// pub to_system: bool,
/// }
///
/// The FatPointer struct:
///
/// pub struct FatPointer {
/// pub offset: u32, // offset relative to `start`
/// pub memory_page: u32, // memory page where slice is located
/// pub start: u32, // absolute start of the slice
/// pub length: u32, // length of the slice
/// }
///
/// @dev Note, that the actual layout is the following:
///
/// [0..32) bits -- the calldata offset
/// [32..64) bits -- the memory page to use. Can be left blank in most of the cases.
/// [64..96) bits -- the absolute start of the slice
/// [96..128) bits -- the length of the slice.
/// [128..192) bits -- empty bits.
/// [192..224) bits -- gasPassed.
/// [224..232) bits -- forwarding_mode
/// [232..240) bits -- shard id.
/// [240..248) bits -- constructor call flag
/// [248..256] bits -- system call flag
function getFarCallABI(
uint32 dataOffset,
uint32 memoryPage,
uint32 dataStart,
uint32 dataLength,
uint32 gasPassed,
uint8 shardId,
CalldataForwardingMode forwardingMode,
bool isConstructorCall,
bool isSystemCall
) internal pure returns (uint256 farCallAbi) {
// Fill in the call parameter fields
farCallAbi = getFarCallABIWithEmptyFatPointer(
gasPassed,
shardId,
forwardingMode,
isConstructorCall,
isSystemCall
);
// Fill in the fat pointer fields
farCallAbi |= dataOffset;
farCallAbi |= (uint256(memoryPage) << 32);
farCallAbi |= (uint256(dataStart) << 64);
farCallAbi |= (uint256(dataLength) << 96);
}
/// @notice Calculates the packed representation of the FarCallABI with zero fat pointer fields.
/// @param gasPassed The gas to pass with the call.
/// @param shardId Of the account to call. Currently only 0 is supported.
/// @param forwardingMode The forwarding mode to use:
/// - provide CalldataForwardingMode.UseHeap when using your current memory
/// - provide CalldataForwardingMode.ForwardFatPointer when using custom pointer.
/// @param isConstructorCall Whether the call will be a call to the constructor
/// (ignored when the caller is not a system contract).
/// @param isSystemCall Whether the call will have the `isSystem` flag.
/// @return farCallAbiWithEmptyFatPtr The far call ABI with zero fat pointer fields.
function getFarCallABIWithEmptyFatPointer(
uint32 gasPassed,
uint8 shardId,
CalldataForwardingMode forwardingMode,
bool isConstructorCall,
bool isSystemCall
) internal pure returns (uint256 farCallAbiWithEmptyFatPtr) {
farCallAbiWithEmptyFatPtr |= (uint256(gasPassed) << 192);
farCallAbiWithEmptyFatPtr |= (uint256(forwardingMode) << 224);
farCallAbiWithEmptyFatPtr |= (uint256(shardId) << 232);
if (isConstructorCall) {
farCallAbiWithEmptyFatPtr |= (1 << 240);
}
if (isSystemCall) {
farCallAbiWithEmptyFatPtr |= (1 << 248);
}
}
}// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "../openzeppelin/token/ERC20/IERC20.sol";
import "../openzeppelin/token/ERC20/utils/SafeERC20.sol";
import "../interfaces/IPaymasterFlow.sol";
import "../interfaces/IContractDeployer.sol";
import {ETH_TOKEN_SYSTEM_CONTRACT, BOOTLOADER_FORMAL_ADDRESS} from "../Constants.sol";
import "./RLPEncoder.sol";
import "./EfficientCall.sol";
/// @dev The type id of zkSync's EIP-712-signed transaction.
uint8 constant EIP_712_TX_TYPE = 0x71;
/// @dev The type id of legacy transactions.
uint8 constant LEGACY_TX_TYPE = 0x0;
/// @dev The type id of legacy transactions.
uint8 constant EIP_2930_TX_TYPE = 0x01;
/// @dev The type id of EIP1559 transactions.
uint8 constant EIP_1559_TX_TYPE = 0x02;
/// @notice Structure used to represent zkSync transaction.
struct Transaction {
// The type of the transaction.
uint256 txType;
// The caller.
uint256 from;
// The callee.
uint256 to;
// The gasLimit to pass with the transaction.
// It has the same meaning as Ethereum's gasLimit.
uint256 gasLimit;
// The maximum amount of gas the user is willing to pay for a byte of pubdata.
uint256 gasPerPubdataByteLimit;
// The maximum fee per gas that the user is willing to pay.
// It is akin to EIP1559's maxFeePerGas.
uint256 maxFeePerGas;
// The maximum priority fee per gas that the user is willing to pay.
// It is akin to EIP1559's maxPriorityFeePerGas.
uint256 maxPriorityFeePerGas;
// The transaction's paymaster. If there is no paymaster, it is equal to 0.
uint256 paymaster;
// The nonce of the transaction.
uint256 nonce;
// The value to pass with the transaction.
uint256 value;
// In the future, we might want to add some
// new fields to the struct. The `txData` struct
// is to be passed to account and any changes to its structure
// would mean a breaking change to these accounts. In order to prevent this,
// we should keep some fields as "reserved".
// It is also recommended that their length is fixed, since
// it would allow easier proof integration (in case we will need
// some special circuit for preprocessing transactions).
uint256[4] reserved;
// The transaction's calldata.
bytes data;
// The signature of the transaction.
bytes signature;
// The properly formatted hashes of bytecodes that must be published on L1
// with the inclusion of this transaction. Note, that a bytecode has been published
// before, the user won't pay fees for its republishing.
bytes32[] factoryDeps;
// The input to the paymaster.
bytes paymasterInput;
// Reserved dynamic type for the future use-case. Using it should be avoided,
// But it is still here, just in case we want to enable some additional functionality.
bytes reservedDynamic;
}
/**
* @author Matter Labs
* @notice Library is used to help custom accounts to work with common methods for the Transaction type.
*/
library TransactionHelper {
using SafeERC20 for IERC20;
/// @notice The EIP-712 typehash for the contract's domain
bytes32 constant EIP712_DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,string version,uint256 chainId)");
bytes32 constant EIP712_TRANSACTION_TYPE_HASH =
keccak256(
"Transaction(uint256 txType,uint256 from,uint256 to,uint256 gasLimit,uint256 gasPerPubdataByteLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,uint256 paymaster,uint256 nonce,uint256 value,bytes data,bytes32[] factoryDeps,bytes paymasterInput)"
);
/// @notice Whether the token is Ethereum.
/// @param _addr The address of the token
/// @return `true` or `false` based on whether the token is Ether.
/// @dev This method assumes that address is Ether either if the address is 0 (for convenience)
/// or if the address is the address of the L2EthToken system contract.
function isEthToken(uint256 _addr) internal pure returns (bool) {
return _addr == uint256(uint160(address(ETH_TOKEN_SYSTEM_CONTRACT))) || _addr == 0;
}
/// @notice Calculate the suggested signed hash of the transaction,
/// i.e. the hash that is signed by EOAs and is recommended to be signed by other accounts.
function encodeHash(Transaction calldata _transaction) internal view returns (bytes32 resultHash) {
if (_transaction.txType == LEGACY_TX_TYPE) {
resultHash = _encodeHashLegacyTransaction(_transaction);
} else if (_transaction.txType == EIP_712_TX_TYPE) {
resultHash = _encodeHashEIP712Transaction(_transaction);
} else if (_transaction.txType == EIP_1559_TX_TYPE) {
resultHash = _encodeHashEIP1559Transaction(_transaction);
} else if (_transaction.txType == EIP_2930_TX_TYPE) {
resultHash = _encodeHashEIP2930Transaction(_transaction);
} else {
// Currently no other transaction types are supported.
// Any new transaction types will be processed in a similar manner.
revert("Encoding unsupported tx");
}
}
/// @notice Encode hash of the zkSync native transaction type.
/// @return keccak256 hash of the EIP-712 encoded representation of transaction
function _encodeHashEIP712Transaction(Transaction calldata _transaction) private view returns (bytes32) {
bytes32 structHash = keccak256(
abi.encode(
EIP712_TRANSACTION_TYPE_HASH,
_transaction.txType,
_transaction.from,
_transaction.to,
_transaction.gasLimit,
_transaction.gasPerPubdataByteLimit,
_transaction.maxFeePerGas,
_transaction.maxPriorityFeePerGas,
_transaction.paymaster,
_transaction.nonce,
_transaction.value,
EfficientCall.keccak(_transaction.data),
keccak256(abi.encodePacked(_transaction.factoryDeps)),
EfficientCall.keccak(_transaction.paymasterInput)
)
);
bytes32 domainSeparator = keccak256(
abi.encode(EIP712_DOMAIN_TYPEHASH, keccak256("zkSync"), keccak256("2"), block.chainid)
);
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
/// @notice Encode hash of the legacy transaction type.
/// @return keccak256 of the serialized RLP encoded representation of transaction
function _encodeHashLegacyTransaction(Transaction calldata _transaction) private view returns (bytes32) {
// Hash of legacy transactions are encoded as one of the:
// - RLP(nonce, gasPrice, gasLimit, to, value, data, chainId, 0, 0)
// - RLP(nonce, gasPrice, gasLimit, to, value, data)
//
// In this RLP encoding, only the first one above list appears, so we encode each element
// inside list and then concatenate the length of all elements with them.
bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
// Encode `gasPrice` and `gasLimit` together to prevent "stack too deep error".
bytes memory encodedGasParam;
{
bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
encodedGasParam = bytes.concat(encodedGasPrice, encodedGasLimit);
}
bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
// Encode only the length of the transaction data, and not the data itself,
// so as not to copy to memory a potentially huge transaction data twice.
bytes memory encodedDataLength;
{
// Safe cast, because the length of the transaction data can't be so large.
uint64 txDataLen = uint64(_transaction.data.length);
if (txDataLen != 1) {
// If the length is not equal to one, then only using the length can it be encoded definitely.
encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
} else if (_transaction.data[0] >= 0x80) {
// If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
encodedDataLength = hex"81";
}
// Otherwise the length is not encoded at all.
}
// Encode `chainId` according to EIP-155, but only if the `chainId` is specified in the transaction.
bytes memory encodedChainId;
if (_transaction.reserved[0] != 0) {
encodedChainId = bytes.concat(RLPEncoder.encodeUint256(block.chainid), hex"80_80");
}
bytes memory encodedListLength;
unchecked {
uint256 listLength = encodedNonce.length +
encodedGasParam.length +
encodedTo.length +
encodedValue.length +
encodedDataLength.length +
_transaction.data.length +
encodedChainId.length;
// Safe cast, because the length of the list can't be so large.
encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
}
return
keccak256(
bytes.concat(
encodedListLength,
encodedNonce,
encodedGasParam,
encodedTo,
encodedValue,
encodedDataLength,
_transaction.data,
encodedChainId
)
);
}
/// @notice Encode hash of the EIP2930 transaction type.
/// @return keccak256 of the serialized RLP encoded representation of transaction
function _encodeHashEIP2930Transaction(Transaction calldata _transaction) private view returns (bytes32) {
// Hash of EIP2930 transactions is encoded the following way:
// H(0x01 || RLP(chain_id, nonce, gas_price, gas_limit, destination, amount, data, access_list))
//
// Note, that on zkSync access lists are not supported and should always be empty.
// Encode all fixed-length params to avoid "stack too deep error"
bytes memory encodedFixedLengthParams;
{
bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
bytes memory encodedGasPrice = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
encodedFixedLengthParams = bytes.concat(
encodedChainId,
encodedNonce,
encodedGasPrice,
encodedGasLimit,
encodedTo,
encodedValue
);
}
// Encode only the length of the transaction data, and not the data itself,
// so as not to copy to memory a potentially huge transaction data twice.
bytes memory encodedDataLength;
{
// Safe cast, because the length of the transaction data can't be so large.
uint64 txDataLen = uint64(_transaction.data.length);
if (txDataLen != 1) {
// If the length is not equal to one, then only using the length can it be encoded definitely.
encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
} else if (_transaction.data[0] >= 0x80) {
// If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
encodedDataLength = hex"81";
}
// Otherwise the length is not encoded at all.
}
// On zkSync, access lists are always zero length (at least for now).
bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);
bytes memory encodedListLength;
unchecked {
uint256 listLength = encodedFixedLengthParams.length +
encodedDataLength.length +
_transaction.data.length +
encodedAccessListLength.length;
// Safe cast, because the length of the list can't be so large.
encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
}
return
keccak256(
bytes.concat(
"\x01",
encodedListLength,
encodedFixedLengthParams,
encodedDataLength,
_transaction.data,
encodedAccessListLength
)
);
}
/// @notice Encode hash of the EIP1559 transaction type.
/// @return keccak256 of the serialized RLP encoded representation of transaction
function _encodeHashEIP1559Transaction(Transaction calldata _transaction) private view returns (bytes32) {
// Hash of EIP1559 transactions is encoded the following way:
// H(0x02 || RLP(chain_id, nonce, max_priority_fee_per_gas, max_fee_per_gas, gas_limit, destination, amount, data, access_list))
//
// Note, that on zkSync access lists are not supported and should always be empty.
// Encode all fixed-length params to avoid "stack too deep error"
bytes memory encodedFixedLengthParams;
{
bytes memory encodedChainId = RLPEncoder.encodeUint256(block.chainid);
bytes memory encodedNonce = RLPEncoder.encodeUint256(_transaction.nonce);
bytes memory encodedMaxPriorityFeePerGas = RLPEncoder.encodeUint256(_transaction.maxPriorityFeePerGas);
bytes memory encodedMaxFeePerGas = RLPEncoder.encodeUint256(_transaction.maxFeePerGas);
bytes memory encodedGasLimit = RLPEncoder.encodeUint256(_transaction.gasLimit);
bytes memory encodedTo = RLPEncoder.encodeAddress(address(uint160(_transaction.to)));
bytes memory encodedValue = RLPEncoder.encodeUint256(_transaction.value);
encodedFixedLengthParams = bytes.concat(
encodedChainId,
encodedNonce,
encodedMaxPriorityFeePerGas,
encodedMaxFeePerGas,
encodedGasLimit,
encodedTo,
encodedValue
);
}
// Encode only the length of the transaction data, and not the data itself,
// so as not to copy to memory a potentially huge transaction data twice.
bytes memory encodedDataLength;
{
// Safe cast, because the length of the transaction data can't be so large.
uint64 txDataLen = uint64(_transaction.data.length);
if (txDataLen != 1) {
// If the length is not equal to one, then only using the length can it be encoded definitely.
encodedDataLength = RLPEncoder.encodeNonSingleBytesLen(txDataLen);
} else if (_transaction.data[0] >= 0x80) {
// If input is a byte in [0x80, 0xff] range, RLP encoding will concatenates 0x81 with the byte.
encodedDataLength = hex"81";
}
// Otherwise the length is not encoded at all.
}
// On zkSync, access lists are always zero length (at least for now).
bytes memory encodedAccessListLength = RLPEncoder.encodeListLen(0);
bytes memory encodedListLength;
unchecked {
uint256 listLength = encodedFixedLengthParams.length +
encodedDataLength.length +
_transaction.data.length +
encodedAccessListLength.length;
// Safe cast, because the length of the list can't be so large.
encodedListLength = RLPEncoder.encodeListLen(uint64(listLength));
}
return
keccak256(
bytes.concat(
"\x02",
encodedListLength,
encodedFixedLengthParams,
encodedDataLength,
_transaction.data,
encodedAccessListLength
)
);
}
/// @notice Processes the common paymaster flows, e.g. setting proper allowance
/// for tokens, etc. For more information on the expected behavior, check out
/// the "Paymaster flows" section in the documentation.
function processPaymasterInput(Transaction calldata _transaction) internal {
require(_transaction.paymasterInput.length >= 4, "The standard paymaster input must be at least 4 bytes long");
bytes4 paymasterInputSelector = bytes4(_transaction.paymasterInput[0:4]);
if (paymasterInputSelector == IPaymasterFlow.approvalBased.selector) {
require(
_transaction.paymasterInput.length >= 68,
"The approvalBased paymaster input must be at least 68 bytes long"
);
// While the actual data consists of address, uint256 and bytes data,
// the data is needed only for the paymaster, so we ignore it here for the sake of optimization
(address token, uint256 minAllowance) = abi.decode(_transaction.paymasterInput[4:68], (address, uint256));
address paymaster = address(uint160(_transaction.paymaster));
uint256 currentAllowance = IERC20(token).allowance(address(this), paymaster);
if (currentAllowance < minAllowance) {
// Some tokens, e.g. USDT require that the allowance is firsty set to zero
// and only then updated to the new value.
IERC20(token).safeApprove(paymaster, 0);
IERC20(token).safeApprove(paymaster, minAllowance);
}
} else if (paymasterInputSelector == IPaymasterFlow.general.selector) {
// Do nothing. general(bytes) paymaster flow means that the paymaster must interpret these bytes on his own.
} else {
revert("Unsupported paymaster flow");
}
}
/// @notice Pays the required fee for the transaction to the bootloader.
/// @dev Currently it pays the maximum amount "_transaction.maxFeePerGas * _transaction.gasLimit",
/// it will change in the future.
function payToTheBootloader(Transaction calldata _transaction) internal returns (bool success) {
address bootloaderAddr = BOOTLOADER_FORMAL_ADDRESS;
uint256 amount = _transaction.maxFeePerGas * _transaction.gasLimit;
assembly {
success := call(gas(), bootloaderAddr, amount, 0, 0, 0, 0)
}
}
// Returns the balance required to process the transaction.
function totalRequiredBalance(Transaction calldata _transaction) internal pure returns (uint256 requiredBalance) {
if (address(uint160(_transaction.paymaster)) != address(0)) {
// Paymaster pays for the fee
requiredBalance = _transaction.value;
} else {
// The user should have enough balance for both the fee and the value of the transaction
requiredBalance = _transaction.maxFeePerGas * _transaction.gasLimit + _transaction.value;
}
}
}// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
import "./EfficientCall.sol";
/**
* @author Matter Labs
* @dev Common utilities used in zkSync system contracts
*/
library Utils {
/// @dev Bit mask of bytecode hash "isConstructor" marker
bytes32 constant IS_CONSTRUCTOR_BYTECODE_HASH_BIT_MASK =
0x00ff000000000000000000000000000000000000000000000000000000000000;
/// @dev Bit mask to set the "isConstructor" marker in the bytecode hash
bytes32 constant SET_IS_CONSTRUCTOR_MARKER_BIT_MASK =
0x0001000000000000000000000000000000000000000000000000000000000000;
function safeCastToU128(uint256 _x) internal pure returns (uint128) {
require(_x <= type(uint128).max, "Overflow");
return uint128(_x);
}
function safeCastToU32(uint256 _x) internal pure returns (uint32) {
require(_x <= type(uint32).max, "Overflow");
return uint32(_x);
}
function safeCastToU24(uint256 _x) internal pure returns (uint24) {
require(_x <= type(uint24).max, "Overflow");
return uint24(_x);
}
/// @return codeLength The bytecode length in bytes
function bytecodeLenInBytes(bytes32 _bytecodeHash) internal pure returns (uint256 codeLength) {
codeLength = bytecodeLenInWords(_bytecodeHash) << 5; // _bytecodeHash * 32
}
/// @return codeLengthInWords The bytecode length in machine words
function bytecodeLenInWords(bytes32 _bytecodeHash) internal pure returns (uint256 codeLengthInWords) {
unchecked {
codeLengthInWords = uint256(uint8(_bytecodeHash[2])) * 256 + uint256(uint8(_bytecodeHash[3]));
}
}
/// @notice Denotes whether bytecode hash corresponds to a contract that already constructed
function isContractConstructed(bytes32 _bytecodeHash) internal pure returns (bool) {
return _bytecodeHash[1] == 0x00;
}
/// @notice Denotes whether bytecode hash corresponds to a contract that is on constructor or has already been constructed
function isContractConstructing(bytes32 _bytecodeHash) internal pure returns (bool) {
return _bytecodeHash[1] == 0x01;
}
/// @notice Sets "isConstructor" flag to TRUE for the bytecode hash
/// @param _bytecodeHash The bytecode hash for which it is needed to set the constructing flag
/// @return The bytecode hash with "isConstructor" flag set to TRUE
function constructingBytecodeHash(bytes32 _bytecodeHash) internal pure returns (bytes32) {
// Clear the "isConstructor" marker and set it to 0x01.
return constructedBytecodeHash(_bytecodeHash) | SET_IS_CONSTRUCTOR_MARKER_BIT_MASK;
}
/// @notice Sets "isConstructor" flag to FALSE for the bytecode hash
/// @param _bytecodeHash The bytecode hash for which it is needed to set the constructing flag
/// @return The bytecode hash with "isConstructor" flag set to FALSE
function constructedBytecodeHash(bytes32 _bytecodeHash) internal pure returns (bytes32) {
return _bytecodeHash & ~IS_CONSTRUCTOR_BYTECODE_HASH_BIT_MASK;
}
/// @notice Validate the bytecode format and calculate its hash.
/// @param _bytecode The bytecode to hash.
/// @return hashedBytecode The 32-byte hash of the bytecode.
/// Note: The function reverts the execution if the bytecode has non expected format:
/// - Bytecode bytes length is not a multiple of 32
/// - Bytecode bytes length is not less than 2^21 bytes (2^16 words)
/// - Bytecode words length is not odd
function hashL2Bytecode(bytes calldata _bytecode) internal view returns (bytes32 hashedBytecode) {
// Note that the length of the bytecode must be provided in 32-byte words.
require(_bytecode.length % 32 == 0, "po");
uint256 bytecodeLenInWords = _bytecode.length / 32;
require(bytecodeLenInWords < 2 ** 16, "pp"); // bytecode length must be less than 2^16 words
require(bytecodeLenInWords % 2 == 1, "pr"); // bytecode length in words must be odd
hashedBytecode =
EfficientCall.sha(_bytecode) &
0x00000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
// Setting the version of the hash
hashedBytecode = (hashedBytecode | bytes32(uint256(1 << 248)));
// Setting the length
hashedBytecode = hashedBytecode | bytes32(bytecodeLenInWords << 224);
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `from` to `to` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Permit.sol)
pragma solidity ^0.8.0;
/**
* @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
* https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
*
* Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
* presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
* need to send a transaction, and thus is not required to hold Ether at all.
*/
interface IERC20Permit {
/**
* @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
* given ``owner``'s signed approval.
*
* IMPORTANT: The same issues {IERC20-approve} has related to transaction
* ordering also apply here.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `deadline` must be a timestamp in the future.
* - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
* over the EIP712-formatted function arguments.
* - the signature must use ``owner``'s current nonce (see {nonces}).
*
* For more information on the signature format, see the
* https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
* section].
*/
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
/**
* @dev Returns the current nonce for `owner`. This value must be
* included whenever a signature is generated for {permit}.
*
* Every successful call to {permit} increases ``owner``'s nonce by one. This
* prevents a signature from being used multiple times.
*/
function nonces(address owner) external view returns (uint256);
/**
* @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
*/
// solhint-disable-next-line func-name-mixedcase
function DOMAIN_SEPARATOR() external view returns (bytes32);
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.sol";
/**
* @title SafeERC20
* @dev Wrappers around ERC20 operations that throw on failure (when the token
* contract returns false). Tokens that return no value (and instead revert or
* throw on failure) are also supported, non-reverting calls are assumed to be
* successful.
* To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
* which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
*/
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(
token,
abi.encodeWithSelector(token.transfer.selector, to, value)
);
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(
token,
abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
);
}
/**
* @dev Deprecated. This function has issues similar to the ones found in
* {IERC20-approve}, and its usage is discouraged.
*
* Whenever possible, use {safeIncreaseAllowance} and
* {safeDecreaseAllowance} instead.
*/
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
// safeApprove should only be called when setting an initial allowance,
// or when resetting it to zero. To increase and decrease it, use
// 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(
token,
abi.encodeWithSelector(token.approve.selector, spender, value)
);
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(
token,
abi.encodeWithSelector(
token.approve.selector,
spender,
newAllowance
)
);
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(
oldAllowance >= value,
"SafeERC20: decreased allowance below zero"
);
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(
token,
abi.encodeWithSelector(
token.approve.selector,
spender,
newAllowance
)
);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(
nonceAfter == nonceBefore + 1,
"SafeERC20: permit did not succeed"
);
}
/**
* @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
* on the return value: the return value is optional (but if data is returned, it must not be false).
* @param token The token targeted by the call.
* @param data The call data (encoded using abi.encode or one of its variants).
*/
function _callOptionalReturn(IERC20 token, bytes memory data) private {
// We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
// we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
// the target address contains contract code and also asserts for success in the low-level call.
bytes memory returndata = address(token).functionCall(
data,
"SafeERC20: low-level call failed"
);
if (returndata.length > 0) {
// Return data is optional
require(
abi.decode(returndata, (bool)),
"SafeERC20: ERC20 operation did not succeed"
);
}
}
}// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
pragma solidity ^0.8.1;
/**
* @dev Collection of functions related to the address type
*/
library Address {
/**
* @dev Returns true if `account` is a contract.
*
* [IMPORTANT]
* ====
* It is unsafe to assume that an address for which this function returns
* false is an externally-owned account (EOA) and not a contract.
*
* Among others, `isContract` will return false for the following
* types of addresses:
*
* - an externally-owned account
* - a contract in construction
* - an address where a contract will be created
* - an address where a contract lived, but was destroyed
* ====
*
* [IMPORTANT]
* ====
* You shouldn't rely on `isContract` to protect against flash loan attacks!
*
* Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
* like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
* constructor.
* ====
*/
function isContract(address account) internal view returns (bool) {
// This method relies on extcodesize/address.code.length, which returns 0
// for contracts in construction, since the code is only stored at the end
// of the constructor execution.
return account.code.length > 0;
}
/**
* @dev Replacement for Solidity's `transfer`: sends `amount` wei to
* `recipient`, forwarding all available gas and reverting on errors.
*
* https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
* of certain opcodes, possibly making contracts go over the 2300 gas limit
* imposed by `transfer`, making them unable to receive funds via
* `transfer`. {sendValue} removes this limitation.
*
* https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
*
* IMPORTANT: because control is transferred to `recipient`, care must be
* taken to not create reentrancy vulnerabilities. Consider using
* {ReentrancyGuard} or the
* https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
*/
function sendValue(address payable recipient, uint256 amount) internal {
require(
address(this).balance >= amount,
"Address: insufficient balance"
);
(bool success, ) = recipient.call{value: amount}("");
require(
success,
"Address: unable to send value, recipient may have reverted"
);
}
/**
* @dev Performs a Solidity function call using a low level `call`. A
* plain `call` is an unsafe replacement for a function call: use this
* function instead.
*
* If `target` reverts with a revert reason, it is bubbled up by this
* function (like regular Solidity function calls).
*
* Returns the raw returned data. To convert to the expected return value,
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
*
* Requirements:
*
* - `target` must be a contract.
* - calling `target` with `data` must not revert.
*
* _Available since v3.1._
*/
function functionCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionCallWithValue(
target,
data,
0,
"Address: low-level call failed"
);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
* `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but also transferring `value` wei to `target`.
*
* Requirements:
*
* - the calling contract must have an ETH balance of at least `value`.
* - the called Solidity function must be `payable`.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return
functionCallWithValue(
target,
data,
value,
"Address: low-level call with value failed"
);
}
/**
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
* with `errorMessage` as a fallback revert reason when `target` reverts.
*
* _Available since v3.1._
*/
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(
address(this).balance >= value,
"Address: insufficient balance for call"
);
(bool success, bytes memory returndata) = target.call{value: value}(
data
);
return
verifyCallResultFromTarget(
target,
success,
returndata,
errorMessage
);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(address target, bytes memory data)
internal
view
returns (bytes memory)
{
return
functionStaticCall(
target,
data,
"Address: low-level static call failed"
);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a static call.
*
* _Available since v3.3._
*/
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return
verifyCallResultFromTarget(
target,
success,
returndata,
errorMessage
);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(address target, bytes memory data)
internal
returns (bytes memory)
{
return
functionDelegateCall(
target,
data,
"Address: low-level delegate call failed"
);
}
/**
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
* but performing a delegate call.
*
* _Available since v3.4._
*/
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return
verifyCallResultFromTarget(
target,
success,
returndata,
errorMessage
);
}
/**
* @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
* the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
*
* _Available since v4.8._
*/
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
// only check isContract if the call was successful and the return data is empty
// otherwise we already know that it was a contract
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
/**
* @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
* revert reason or using the provided one.
*
* _Available since v4.3._
*/
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage)
private
pure
{
// Look for revert reason and bubble it up if present
if (returndata.length > 0) {
// The easiest way to bubble the revert reason is using memory via assembly
/// @solidity memory-safe-assembly
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}// SPDX-License-Identifier: BSD-3-Clause-Clear
pragma solidity 0.8.23;
import {ERC20} from "openzeppelin-contracts/contracts/token/ERC20/ERC20.sol";
import {ERC20Burnable} from "openzeppelin-contracts/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import {AccessControl} from "openzeppelin-contracts/contracts/access/AccessControl.sol";
contract NODL is ERC20Burnable, AccessControl {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
constructor() ERC20("Nodle Token", "NODL") {
_grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
_grantRole(MINTER_ROLE, msg.sender);
}
function mint(address to, uint256 amount) public {
_checkRole(MINTER_ROLE);
_mint(to, amount);
}
}// SPDX-License-Identifier: BSD-3-Clause-Clear
pragma solidity 0.8.23;
import {NODL} from "../NODL.sol";
/// @title NODLMigration
/// @notice This contract is used to help migrating the NODL assets from the Nodle Parachain
/// to the ZkSync contracts.
contract NODLMigration {
struct Proposal {
address target;
uint256 amount;
uint256 lastVote;
uint8 totalVotes;
bool executed;
}
NODL public nodl;
mapping(address => bool) public isOracle;
uint8 public threshold;
uint256 public delay;
// We track votes in a seperate mapping to avoid having to write helper functions to
// expose the votes for each proposal.
mapping(bytes32 => Proposal) public proposals;
mapping(address => mapping(bytes32 => bool)) public voted;
error AlreadyVoted(bytes32 proposal, address oracle);
error AlreadyExecuted(bytes32 proposal);
error ParametersChanged(bytes32 proposal);
error NotAnOracle(address user);
error NotYetWithdrawable(bytes32 proposal);
error NotEnoughVotes(bytes32 proposal);
event VoteStarted(bytes32 indexed proposal, address oracle, address indexed user, uint256 amount);
event Voted(bytes32 indexed proposal, address oracle);
event Withdrawn(bytes32 indexed proposal, address indexed user, uint256 amount);
/// @param bridgeOracles Array of oracle accounts that will be able to bridge the tokens.
/// @param token Contract address of the NODL token.
/// @param minVotes Minimum number of votes required to bridge the tokens. This needs to be
/// less than or equal to the number of oracles and is expected to be above 1.
/// @param minDelay Minimum delay in blocks before bridged tokens can be minted.
constructor(address[] memory bridgeOracles, NODL token, uint8 minVotes, uint256 minDelay) {
assert(bridgeOracles.length >= minVotes);
assert(minVotes > 0);
for (uint256 i = 0; i < bridgeOracles.length; i++) {
isOracle[bridgeOracles[i]] = true;
}
nodl = token;
threshold = minVotes;
delay = minDelay;
}
/// @notice Bridge some tokens from the Nodle Parachain to the ZkSync contracts. This
/// tracks "votes" from each oracle and unlocks execution after a withdrawal delay.
/// @param paraTxHash The transaction hash on the Parachain for this transfer.
/// @param user The user address.
/// @param amount The amount of NODL tokens that the user has burnt on the Parachain.
function bridge(bytes32 paraTxHash, address user, uint256 amount) external {
_mustBeAnOracle(msg.sender);
_mustNotHaveExecutedYet(paraTxHash);
if (_proposalExists(paraTxHash)) {
_mustNotHaveVotedYet(paraTxHash, msg.sender);
_mustNotBeChangingParameters(paraTxHash, user, amount);
_recordVote(paraTxHash, msg.sender);
} else {
_createVote(paraTxHash, msg.sender, user, amount);
}
}
/// @notice Withdraw the NODL tokens from the contract to the user's address if the
/// proposal has enough votes and has passed the safety delay.
/// @param paraTxHash The transaction hash on the Parachain for this transfer.
function withdraw(bytes32 paraTxHash) external {
_mustNotHaveExecutedYet(paraTxHash);
_mustHaveEnoughVotes(paraTxHash);
_mustBePastSafetyDelay(paraTxHash);
_withdraw(paraTxHash, proposals[paraTxHash].target, proposals[paraTxHash].amount);
}
function _mustBeAnOracle(address maybeOracle) internal view {
if (!isOracle[maybeOracle]) {
revert NotAnOracle(maybeOracle);
}
}
function _mustNotHaveVotedYet(bytes32 proposal, address oracle) internal view {
if (voted[oracle][proposal]) {
revert AlreadyVoted(proposal, oracle);
}
}
function _mustNotHaveExecutedYet(bytes32 proposal) internal view {
if (proposals[proposal].executed) {
revert AlreadyExecuted(proposal);
}
}
function _mustNotBeChangingParameters(bytes32 proposal, address user, uint256 amount) internal view {
if (proposals[proposal].amount != amount || proposals[proposal].target != user) {
revert ParametersChanged(proposal);
}
}
function _mustBePastSafetyDelay(bytes32 proposal) internal view {
if (block.number - proposals[proposal].lastVote < delay) {
revert NotYetWithdrawable(proposal);
}
}
function _mustHaveEnoughVotes(bytes32 proposal) internal view {
if (proposals[proposal].totalVotes < threshold) {
revert NotEnoughVotes(proposal);
}
}
function _proposalExists(bytes32 proposal) internal view returns (bool) {
return proposals[proposal].totalVotes > 0 && proposals[proposal].amount > 0;
}
function _createVote(bytes32 proposal, address oracle, address user, uint256 amount) internal {
voted[oracle][proposal] = true;
proposals[proposal].target = user;
proposals[proposal].amount = amount;
proposals[proposal].totalVotes = 1;
proposals[proposal].lastVote = block.number;
emit VoteStarted(proposal, oracle, user, amount);
}
function _recordVote(bytes32 proposal, address oracle) internal {
voted[oracle][proposal] = true;
// this is safe since we are unlikely to have maxUint8 oracles to manage
proposals[proposal].totalVotes += 1;
proposals[proposal].lastVote = block.number;
emit Voted(proposal, oracle);
}
function _withdraw(bytes32 proposal, address user, uint256 amount) internal {
proposals[proposal].executed = true;
nodl.mint(user, amount);
emit Withdrawn(proposal, user, amount);
}
}{
"remappings": [
"@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
"ds-test/=lib/forge-std/lib/ds-test/src/",
"erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
"forge-std/=lib/forge-std/src/",
"openzeppelin-contracts/=lib/openzeppelin-contracts/",
"zksync-contracts/=lib/zksync-contracts/"
],
"optimizer": {
"enabled": true,
"runs": 200
},
"outputSelection": {
"*": {
"*": [
"abi"
]
}
},
"evmVersion": "paris",
"libraries": {}
}Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
Contract ABI
API[{"inputs":[{"internalType":"contract NODLMigration","name":"_migration","type":"address"},{"internalType":"uint256","name":"_maxHolders","type":"uint256"},{"internalType":"uint256[]","name":"_levels","type":"uint256[]"},{"internalType":"string[]","name":"_levelToTokenURI","type":"string[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyClaimed","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721IncorrectOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721InsufficientApproval","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC721InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"ERC721InvalidOperator","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"ERC721InvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC721InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC721InvalidSender","type":"error"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ERC721NonexistentToken","type":"error"},{"inputs":[],"name":"NoLevelUp","type":"error"},{"inputs":[],"name":"NotExecuted","type":"error"},{"inputs":[],"name":"ProposalDoesNotExist","type":"error"},{"inputs":[],"name":"SoulboundIsNotTransferrable","type":"error"},{"inputs":[],"name":"TooManyHolders","type":"error"},{"inputs":[],"name":"UnequalLengths","type":"error"},{"inputs":[],"name":"UnsortedLevelsList","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"claimed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"holderToNextLevel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"individualHolders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"levelToTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"levels","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxHolders","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"migration","outputs":[{"internalType":"contract NODLMigration","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"txHash","type":"bytes32"}],"name":"safeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenIdToNextLevel","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}]Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
0000000000000000000000005de7fe085ee66fb48447e75aa8fb0598a080aee0000000000000000000000000000000000000000000000000000000000000520800000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000140000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000001b1ae4d6e2ef50000000000000000000000000000000000000000000000000003635c9adc5dea0000000000000000000000000000000000000000000000000010f0cf064dd5920000000000000000000000000000000000000000000000000021e19e0c9bab240000000000000000000000000000000000000000000000000152d02c7e14af6800000000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000002200000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d56737766645839384571486166644d474a4e485465347975397879516e6261644153714e714761486a50564c00000000000000000000000000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d66594e453934695a507248364c567437764243686268765834474a4e7952516b614d317a694a4e4d61587a3200000000000000000000000000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d55474b454a6b6a695637446e544a7345426e50335261625a4d54794c4d5a4a4779727a714277726b585a6d3700000000000000000000000000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d6344345438756b6f663541316b7a74354270677170633456744b4e445161413648767a33454d77323241445200000000000000000000000000000000000000000000000000000000000000000000000000000000000035697066733a2f2f516d664b56577a7373315a614e70386f617a43524d413334517266644c4a7368543844357158484855697a4551710000000000000000000000
-----Decoded View---------------
Arg [0] : _migration (address): 0x5de7fe085ee66Fb48447e75AA8fb0598a080AEe0
Arg [1] : _maxHolders (uint256): 21000
Arg [2] : _levels (uint256[]): 500000000000000000000,1000000000000000000000,5000000000000000000000,10000000000000000000000,100000000000000000000000
Arg [3] : _levelToTokenURI (string[]): ipfs://QmVswfdX98EqHafdMGJNHTe4yu9xyQnbadASqNqGaHjPVL,ipfs://QmfYNE94iZPrH6LVt7vBChbhvX4GJNyRQkaM1ziJNMaXz2,ipfs://QmUGKEJkjiV7DnTJsEBnP3RabZMTyLMZJGyrzqBwrkXZm7,ipfs://QmcD4T8ukof5A1kzt5Bpgqpc4VtKNDQaA6Hvz3EMw22ADR,ipfs://QmfKVWzss1ZaNp8oazCRMA34QrfdLJshT8D5qXHHUizEQq
-----Encoded View---------------
31 Constructor Arguments found :
Arg [0] : 0000000000000000000000005de7fe085ee66fb48447e75aa8fb0598a080aee0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000005208
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000140
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [5] : 00000000000000000000000000000000000000000000001b1ae4d6e2ef500000
Arg [6] : 00000000000000000000000000000000000000000000003635c9adc5dea00000
Arg [7] : 00000000000000000000000000000000000000000000010f0cf064dd59200000
Arg [8] : 00000000000000000000000000000000000000000000021e19e0c9bab2400000
Arg [9] : 00000000000000000000000000000000000000000000152d02c7e14af6800000
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [11] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [14] : 00000000000000000000000000000000000000000000000000000000000001c0
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000220
Arg [16] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [17] : 697066733a2f2f516d56737766645839384571486166644d474a4e4854653479
Arg [18] : 75397879516e6261644153714e714761486a50564c0000000000000000000000
Arg [19] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [20] : 697066733a2f2f516d66594e453934695a507248364c56743776424368626876
Arg [21] : 5834474a4e7952516b614d317a694a4e4d61587a320000000000000000000000
Arg [22] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [23] : 697066733a2f2f516d55474b454a6b6a695637446e544a7345426e5033526162
Arg [24] : 5a4d54794c4d5a4a4779727a714277726b585a6d370000000000000000000000
Arg [25] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [26] : 697066733a2f2f516d6344345438756b6f663541316b7a743542706771706334
Arg [27] : 56744b4e445161413648767a33454d7732324144520000000000000000000000
Arg [28] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [29] : 697066733a2f2f516d664b56577a7373315a614e70386f617a43524d41333451
Arg [30] : 7266644c4a7368543844357158484855697a4551710000000000000000000000
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.