├── .gitignore ├── .solhint.json ├── .vscode └── settings.json ├── remappings.txt ├── .gitmodules ├── src ├── test │ ├── mocks │ │ ├── MockContinuousGDA.sol │ │ └── MockDiscreteGDA.sol │ ├── utils │ │ ├── Utilities.sol │ │ └── Console.sol │ ├── ContinuousGDA.t.sol │ └── DiscreteGDA.t.sol ├── DiscreteGDA.sol └── ContinuousGDA.sol ├── .github └── workflows │ └── CI.yml ├── package.json ├── README.md └── analysis ├── gda.py ├── compute_price.py └── analysis.ipynb /.gitignore: -------------------------------------------------------------------------------- 1 | out/ 2 | cache/ 3 | node_modules/ 4 | .env 5 | .ipynb_checkpoints/ 6 | __pycache__ -------------------------------------------------------------------------------- /.solhint.json: -------------------------------------------------------------------------------- 1 | { 2 | "extends": "solhint:recommended", 3 | "rules": { 4 | "compiler-version": ["error",">=0.8.0"], 5 | "avoid-low-level-calls": "off" 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "editor.formatOnSave": true, 3 | "solidity.formatter": "prettier", 4 | "[solidity]": { 5 | "editor.defaultFormatter": "JuanBlanco.solidity" 6 | } 7 | } -------------------------------------------------------------------------------- /remappings.txt: -------------------------------------------------------------------------------- 1 | ds-test/=lib/ds-test/src/ 2 | solmate/=lib/solmate/src/ 3 | forge-std/=lib/forge-std/src/ 4 | prb-math/=lib/prb-math/contracts/ 5 | openzeppelin/=lib/openzeppelin-contracts/contracts/ 6 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "lib/ds-test"] 2 | path = lib/ds-test 3 | url = https://github.com/dapphub/ds-test 4 | [submodule "lib/solmate"] 5 | path = lib/solmate 6 | url = https://github.com/Rari-Capital/solmate 7 | [submodule "lib/forge-std"] 8 | path = lib/forge-std 9 | url = https://github.com/brockelmore/forge-std 10 | [submodule "lib/prb-math"] 11 | path = lib/prb-math 12 | url = https://github.com/hifi-finance/prb-math 13 | [submodule "lib/openzeppelin-contracts"] 14 | path = lib/openzeppelin-contracts 15 | url = https://github.com/openzeppelin/openzeppelin-contracts 16 | -------------------------------------------------------------------------------- /src/test/mocks/MockContinuousGDA.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicense 2 | pragma solidity >=0.8.0; 3 | 4 | import {ContinuousGDA} from "../../ContinuousGDA.sol"; 5 | 6 | contract MockContinuousGDA is ContinuousGDA { 7 | constructor( 8 | string memory _name, 9 | string memory _symbol, 10 | int256 _initialPrice, 11 | int256 _decayConstant, 12 | int256 _emissionRate 13 | ) 14 | ContinuousGDA( 15 | _name, 16 | _symbol, 17 | _initialPrice, 18 | _decayConstant, 19 | _emissionRate 20 | ) 21 | {} 22 | } 23 | -------------------------------------------------------------------------------- /src/test/mocks/MockDiscreteGDA.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicense 2 | pragma solidity >=0.8.0; 3 | 4 | import {DiscreteGDA} from "../../DiscreteGDA.sol"; 5 | 6 | contract MockDiscreteGDA is DiscreteGDA { 7 | constructor( 8 | string memory _name, 9 | string memory _symbol, 10 | int256 _initialPrice, 11 | int256 _scaleFactor, 12 | int256 _decayConstant 13 | ) 14 | DiscreteGDA(_name, _symbol, _initialPrice, _scaleFactor, _decayConstant) 15 | {} 16 | 17 | function tokenURI(uint256) 18 | public 19 | pure 20 | virtual 21 | override 22 | returns (string memory) 23 | {} 24 | } 25 | -------------------------------------------------------------------------------- /.github/workflows/CI.yml: -------------------------------------------------------------------------------- 1 | name: CI 2 | on: 3 | push: 4 | branches: 5 | - master 6 | pull_request: 7 | 8 | jobs: 9 | run-ci: 10 | runs-on: ubuntu-latest 11 | steps: 12 | - uses: actions/checkout@v2 13 | with: 14 | submodules: recursive 15 | - uses: actions/setup-node@v2 16 | - name: Install dev dependencies 17 | run: npm install 18 | 19 | - name: Install Foundry 20 | uses: onbjerg/foundry-toolchain@v1 21 | with: 22 | version: nightly 23 | 24 | - name: Run lint check 25 | run: npm run lint:check 26 | 27 | - name: Run tests 28 | run: forge test --no-match-test FFI 29 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "forge-template", 3 | "author": "FrankieIsLost", 4 | "version": "1.0.0", 5 | "description": "A forge template", 6 | "homepage": "https://github.com/FrankieIsLost/forge-template#readme", 7 | "repository": { 8 | "type": "git", 9 | "url": "git+https://github.com/FrankieIsLost/forge-template.git" 10 | }, 11 | "scripts": { 12 | "prettier": "prettier --write 'src/**/*.sol'", 13 | "prettier:list": "prettier --list-different 'src/**/*.sol'", 14 | "prettier:check": "prettier --check 'src/**/*.sol'", 15 | "solhint": "solhint --config ./.solhint.json 'src/**/*.sol' --fix", 16 | "solhint:check": "solhint --config ./.solhint.json 'src/**/*.sol'", 17 | "lint": "npm run prettier && npm run solhint", 18 | "lint:check": "npm run prettier:check && npm run solhint:check" 19 | 20 | }, 21 | "devDependencies": { 22 | "prettier": "^2.5.1", 23 | "prettier-plugin-solidity": "^1.0.0-beta.19", 24 | "solhint": "^3.3.6" 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Gradual Dutch Auction • [![CI](https://github.com/FrankieIsLost/gradual-dutch-auction/actions/workflows/CI.yml/badge.svg)](https://github.com/FrankieIsLost/gradual-dutch-auction/actions/workflows/CI.yml) 2 | 3 | An reference implementation of Gradual Dutch Auctions. GDAs enable the efficient sale of assets that do not have liquid markets. 4 | 5 | This repo contains implementations of both discrete GDAs, which are useful for selling NFTs, and continuous GDAs, which are useful for selling fungible tokens. We also include a python notebook modeling the mechanisms behaviour. 6 | 7 | ## Getting Started 8 | 9 | ```sh 10 | git clone https://github.com/FrankieIsLost/gradual-dutch-auction 11 | cd gradual-dutch-auction 12 | git submodule update --init --recursive ##initialize submodule dependencies 13 | forge build 14 | ``` 15 | 16 | ## Testing 17 | 18 | This repo utilizes forge FFI (foreign function interfaces) for correctness testing. In this case, FFI tests compute GDA prices in Soldity, and the call out to a python script which implements the same logic, to ensure price parity. FFI tests need elevated permissions to run. 19 | 20 | In order to run non-ffi tests, you can run the following command: 21 | 22 | ``` 23 | forge test --no-match-test FFI 24 | ``` 25 | 26 | To run ffi tests, run the following: 27 | 28 | ``` 29 | forge test --match-test FFI --ffi 30 | ``` 31 | -------------------------------------------------------------------------------- /analysis/gda.py: -------------------------------------------------------------------------------- 1 | from abc import ABC, abstractmethod 2 | import math 3 | 4 | class DiscreteGDA(ABC): 5 | 6 | @abstractmethod 7 | def get_cumulative_purchase_price(self, numTotalPurchases, timeSinceStart, quantity): 8 | pass 9 | 10 | class ContinuousGDA(ABC): 11 | 12 | @abstractmethod 13 | def get_cumulative_purchase_price(self, ageLastAvailableAuction, quantity): 14 | pass 15 | 16 | class ExponentialDiscreteGDA(DiscreteGDA): 17 | 18 | def __init__(self, initial_price, decay_constant, scale_factor): 19 | self.initial_price = initial_price 20 | self.decay_constant = decay_constant 21 | self.scale_factor = scale_factor 22 | 23 | def get_cumulative_purchase_price(self, num_total_purchases, time_since_start, quantity): 24 | t1 = self.initial_price * math.pow(self.scale_factor, num_total_purchases) 25 | t2 = math.pow(self.scale_factor, quantity) - 1 26 | t3 = math.exp(self.decay_constant * time_since_start) 27 | t4 = self.scale_factor - 1 28 | return t1 * t2 / (t3 * t4) 29 | 30 | class ExponentialContinuousGDA(ContinuousGDA): 31 | 32 | def __init__(self, initial_price, decay_constant, emission_rate): 33 | self.initial_price = initial_price 34 | self.decay_constant = decay_constant 35 | self.emission_rate = emission_rate 36 | 37 | def get_cumulative_purchase_price(self, age_last_available_auction, quantity): 38 | t1 = self.initial_price / self.decay_constant 39 | t2 = math.exp(self.decay_constant * quantity / self.emission_rate) - 1 40 | t3 = math.exp(self.decay_constant * age_last_available_auction) 41 | return t1 * t2 / t3 -------------------------------------------------------------------------------- /src/test/utils/Utilities.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicense 2 | pragma solidity >=0.8.0; 3 | 4 | import {DSTest} from "ds-test/test.sol"; 5 | import {Vm} from "forge-std/Vm.sol"; 6 | 7 | //common utilities for forge tests 8 | contract Utilities is DSTest { 9 | Vm internal immutable vm = Vm(HEVM_ADDRESS); 10 | bytes32 internal nextUser = keccak256(abi.encodePacked("user address")); 11 | 12 | function getNextUserAddress() external returns (address payable) { 13 | //bytes32 to address conversion 14 | address payable user = payable(address(uint160(uint256(nextUser)))); 15 | nextUser = keccak256(abi.encodePacked(nextUser)); 16 | return user; 17 | } 18 | 19 | //create users with 100 ether balance 20 | function createUsers(uint256 userNum) 21 | external 22 | returns (address payable[] memory) 23 | { 24 | address payable[] memory users = new address payable[](userNum); 25 | for (uint256 i = 0; i < userNum; i++) { 26 | address payable user = this.getNextUserAddress(); 27 | vm.deal(user, 100 ether); 28 | users[i] = user; 29 | } 30 | return users; 31 | } 32 | 33 | //assert that two uints are approximately equal. tolerance in 1/10th of a percent 34 | function assertApproxEqual( 35 | uint256 expected, 36 | uint256 actual, 37 | uint256 tolerance 38 | ) public { 39 | uint256 leftBound = (expected * (1000 - tolerance)) / 1000; 40 | uint256 rightBound = (expected * (1000 + tolerance)) / 1000; 41 | assertTrue(leftBound <= actual && actual <= rightBound); 42 | } 43 | 44 | //move block.number forward by a given number of blocks 45 | function mineBlocks(uint256 numBlocks) external { 46 | uint256 targetBlock = block.number + numBlocks; 47 | vm.roll(targetBlock); 48 | } 49 | } 50 | -------------------------------------------------------------------------------- /analysis/compute_price.py: -------------------------------------------------------------------------------- 1 | from gda import ExponentialDiscreteGDA, ExponentialContinuousGDA 2 | from eth_abi import encode_single 3 | import argparse 4 | 5 | def main(args): 6 | if (args.type == 'exp_discrete'): 7 | calculate_exp_discrete(args) 8 | if (args.type == 'exp_continuous'): 9 | calculate_exp_continuous(args) 10 | 11 | def calculate_exp_discrete(args): 12 | gda = ExponentialDiscreteGDA(args.initial_price / (10 ** 18), args.decay_constant / (10 ** 18), args.scale_factor / (10 ** 18)) 13 | price = gda.get_cumulative_purchase_price(args.num_total_purchases, args.time_since_start, args.quantity) 14 | ##convert price to wei 15 | price *= (10 ** 18) 16 | enc = encode_single('uint256', int(price)) 17 | ## append 0x for FFI parsing 18 | print("0x" + enc.hex()) 19 | 20 | def calculate_exp_continuous(args): 21 | gda = ExponentialContinuousGDA(args.initial_price / (10 ** 18), 22 | args.decay_constant / (10 ** 18), 23 | args.emission_rate / (10 ** 18)) 24 | price = gda.get_cumulative_purchase_price(args.age_last_auction, args.quantity) 25 | ##convert price to wei 26 | price *= (10 ** 18) 27 | enc = encode_single('uint256', int(price)) 28 | ## append 0x for FFI parsing 29 | print("0x" + enc.hex()) 30 | 31 | def parse_args(): 32 | parser = argparse.ArgumentParser() 33 | parser.add_argument("type") 34 | parser.add_argument("--scale_factor", type=int) 35 | parser.add_argument("--decay_constant", type=int) 36 | parser.add_argument("--emission_rate", type=int) 37 | parser.add_argument("--initial_price", type=int) 38 | parser.add_argument("--num_total_purchases", type=int) 39 | parser.add_argument("--time_since_start", type=int) 40 | parser.add_argument("--age_last_auction", type=int) 41 | parser.add_argument("--quantity", type=int) 42 | return parser.parse_args() 43 | 44 | if __name__ == '__main__': 45 | args = parse_args() 46 | main(args) -------------------------------------------------------------------------------- /src/DiscreteGDA.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicense 2 | pragma solidity >=0.8.0; 3 | 4 | import {ERC721} from "solmate/tokens/ERC721.sol"; 5 | import {PRBMathSD59x18} from "prb-math/PRBMathSD59x18.sol"; 6 | 7 | ///@notice Implementation of Discrete GDA with exponential price decay for ERC721 8 | abstract contract DiscreteGDA is ERC721 { 9 | using PRBMathSD59x18 for int256; 10 | 11 | ///@notice id of current ERC721 being minted 12 | uint256 public currentId = 0; 13 | 14 | /// ----------------------------- 15 | /// ---- Pricing Parameters ----- 16 | /// ----------------------------- 17 | 18 | ///@notice parameter that controls initial price, stored as a 59x18 fixed precision number 19 | int256 internal immutable initialPrice; 20 | 21 | ///@notice parameter that controls how much the starting price of each successive auction increases by, 22 | /// stored as a 59x18 fixed precision number 23 | int256 internal immutable scaleFactor; 24 | 25 | ///@notice parameter that controls price decay, stored as a 59x18 fixed precision number 26 | int256 internal immutable decayConstant; 27 | 28 | ///@notice start time for all auctions, stored as a 59x18 fixed precision number 29 | int256 internal immutable auctionStartTime; 30 | 31 | error InsufficientPayment(); 32 | 33 | error UnableToRefund(); 34 | 35 | constructor( 36 | string memory _name, 37 | string memory _symbol, 38 | int256 _initialPrice, 39 | int256 _scaleFactor, 40 | int256 _decayConstant 41 | ) ERC721(_name, _symbol) { 42 | initialPrice = _initialPrice; 43 | scaleFactor = _scaleFactor; 44 | decayConstant = _decayConstant; 45 | auctionStartTime = int256(block.timestamp).fromInt(); 46 | } 47 | 48 | ///@notice purchase a specific number of tokens from the GDA 49 | function purchaseTokens(uint256 numTokens, address to) public payable { 50 | uint256 cost = purchasePrice(numTokens); 51 | if (msg.value < cost) { 52 | revert InsufficientPayment(); 53 | } 54 | //mint all tokens 55 | for (uint256 i = 0; i < numTokens; i++) { 56 | _mint(to, ++currentId); 57 | } 58 | //refund extra payment 59 | uint256 refund = msg.value - cost; 60 | (bool sent, ) = msg.sender.call{value: refund}(""); 61 | if (!sent) { 62 | revert UnableToRefund(); 63 | } 64 | } 65 | 66 | ///@notice calculate purchase price using exponential discrete GDA formula 67 | function purchasePrice(uint256 numTokens) public view returns (uint256) { 68 | int256 quantity = int256(numTokens).fromInt(); 69 | int256 numSold = int256(currentId).fromInt(); 70 | int256 timeSinceStart = int256(block.timestamp).fromInt() - 71 | auctionStartTime; 72 | 73 | int256 num1 = initialPrice.mul(scaleFactor.pow(numSold)); 74 | int256 num2 = scaleFactor.pow(quantity) - PRBMathSD59x18.fromInt(1); 75 | int256 den1 = decayConstant.mul(timeSinceStart).exp(); 76 | int256 den2 = scaleFactor - PRBMathSD59x18.fromInt(1); 77 | int256 totalCost = num1.mul(num2).div(den1.mul(den2)); 78 | //total cost is already in terms of wei so no need to scale down before 79 | //conversion to uint. This is due to the fact that the original formula gives 80 | //price in terms of ether but we scale up by 10^18 during computation 81 | //in order to do fixed point math. 82 | return uint256(totalCost); 83 | } 84 | } 85 | -------------------------------------------------------------------------------- /src/ContinuousGDA.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicense 2 | pragma solidity >=0.8.0; 3 | 4 | import {ERC20} from "solmate/tokens/ERC20.sol"; 5 | import {PRBMathSD59x18} from "prb-math/PRBMathSD59x18.sol"; 6 | 7 | ///@notice Implementation of Continuous GDA with exponential price decay for ERC721 8 | abstract contract ContinuousGDA is ERC20 { 9 | using PRBMathSD59x18 for int256; 10 | 11 | /// ----------------------------- 12 | /// ---- Pricing Parameters ----- 13 | /// ----------------------------- 14 | 15 | ///@notice parameter that controls initial price, stored as a 59x18 fixed precision number 16 | int256 internal immutable initialPrice; 17 | 18 | ///@notice parameter that controls price decay, stored as a 59x18 fixed precision number 19 | int256 internal immutable decayConstant; 20 | 21 | ///@notice emission rate, in tokens per second, stored as a 59x18 fixed precision number 22 | int256 internal immutable emissionRate; 23 | 24 | ///@notice start time for last available auction, stored as a 59x18 fixed precision number 25 | int256 internal lastAvailableAuctionStartTime; 26 | 27 | error InsufficientPayment(); 28 | 29 | error InsufficientAvailableTokens(); 30 | 31 | error UnableToRefund(); 32 | 33 | constructor( 34 | string memory _name, 35 | string memory _symbol, 36 | int256 _initialPrice, 37 | int256 _decayConstant, 38 | int256 _emissionRate 39 | ) ERC20(_name, _symbol, 18) { 40 | initialPrice = _initialPrice; 41 | decayConstant = _decayConstant; 42 | emissionRate = _emissionRate; 43 | lastAvailableAuctionStartTime = int256(block.timestamp).fromInt(); 44 | } 45 | 46 | ///@notice purchase a specific number of tokens from the GDA 47 | function purchaseTokens(uint256 numTokens, address to) public payable { 48 | //number of seconds of token emissions that are available to be purchased 49 | int256 secondsOfEmissionsAvaiable = int256(block.timestamp).fromInt() - 50 | lastAvailableAuctionStartTime; 51 | //number of seconds of emissions are being purchased 52 | int256 secondsOfEmissionsToPurchase = int256(numTokens).fromInt().div( 53 | emissionRate 54 | ); 55 | //ensure there's been sufficient emissions to allow purchase 56 | if (secondsOfEmissionsToPurchase > secondsOfEmissionsAvaiable) { 57 | revert InsufficientAvailableTokens(); 58 | } 59 | 60 | uint256 cost = purchasePrice(numTokens); 61 | if (msg.value < cost) { 62 | revert InsufficientPayment(); 63 | } 64 | //mint tokens 65 | _mint(to, numTokens); 66 | //update last available auction 67 | lastAvailableAuctionStartTime += secondsOfEmissionsToPurchase; 68 | 69 | //refund extra payment 70 | uint256 refund = msg.value - cost; 71 | (bool sent, ) = msg.sender.call{value: refund}(""); 72 | if (!sent) { 73 | revert UnableToRefund(); 74 | } 75 | } 76 | 77 | ///@notice calculate purchase price using exponential continuous GDA formula 78 | function purchasePrice(uint256 numTokens) public view returns (uint256) { 79 | int256 quantity = int256(numTokens).fromInt(); 80 | int256 timeSinceLastAuctionStart = int256(block.timestamp).fromInt() - 81 | lastAvailableAuctionStartTime; 82 | int256 num1 = initialPrice.div(decayConstant); 83 | int256 num2 = decayConstant.mul(quantity).div(emissionRate).exp() - 84 | PRBMathSD59x18.fromInt(1); 85 | int256 den = decayConstant.mul(timeSinceLastAuctionStart).exp(); 86 | int256 totalCost = num1.mul(num2).div(den); 87 | //total cost is already in terms of wei so no need to scale down before 88 | //conversion to uint. This is due to the fact that the original formula gives 89 | //price in terms of ether but we scale up by 10^18 during computation 90 | //in order to do fixed point math. 91 | return uint256(totalCost); 92 | } 93 | } 94 | -------------------------------------------------------------------------------- /src/test/ContinuousGDA.t.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicense 2 | pragma solidity >=0.8.0; 3 | 4 | import {DSTest} from "ds-test/test.sol"; 5 | import {Utilities} from "./utils/Utilities.sol"; 6 | import {console} from "./utils/Console.sol"; 7 | import {Vm} from "forge-std/Vm.sol"; 8 | import {MockContinuousGDA} from "./mocks/MockContinuousGDA.sol"; 9 | import {PRBMathSD59x18} from "prb-math/PRBMathSD59x18.sol"; 10 | import {Strings} from "openzeppelin/utils/Strings.sol"; 11 | 12 | ///@notice test discrete GDA behaviour 13 | ///@dev run with --ffi flag to enable correctness tests 14 | contract ContinuousGDATest is DSTest { 15 | using PRBMathSD59x18 for int256; 16 | using Strings for uint256; 17 | 18 | Vm internal immutable vm = Vm(HEVM_ADDRESS); 19 | 20 | Utilities internal utils; 21 | address payable[] internal users; 22 | MockContinuousGDA internal gda; 23 | 24 | int256 public initialPrice = PRBMathSD59x18.fromInt(1000); 25 | int256 public decayConstant = 26 | PRBMathSD59x18.fromInt(1).div(PRBMathSD59x18.fromInt(2)); 27 | int256 public emissionRate = PRBMathSD59x18.fromInt(1); 28 | 29 | //encodings for revert tests 30 | bytes insufficientPayment = 31 | abi.encodeWithSignature("InsufficientPayment()"); 32 | bytes insufficientTokens = 33 | abi.encodeWithSignature("InsufficientAvailableTokens()"); 34 | 35 | function setUp() public { 36 | utils = new Utilities(); 37 | users = utils.createUsers(5); 38 | 39 | gda = new MockContinuousGDA( 40 | "Token", 41 | "TKN", 42 | initialPrice, 43 | decayConstant, 44 | emissionRate 45 | ); 46 | } 47 | 48 | function testInsuffientPayment() public { 49 | vm.warp(block.timestamp + 10); 50 | uint256 purchaseAmount = 5; 51 | uint256 purchasePrice = gda.purchasePrice(purchaseAmount); 52 | vm.deal(address(this), purchasePrice); 53 | vm.expectRevert(insufficientPayment); 54 | gda.purchaseTokens{value: purchasePrice - 1}( 55 | purchaseAmount, 56 | address(this) 57 | ); 58 | } 59 | 60 | function testInsufficientEmissions() public { 61 | //10 tokens available for sale 62 | vm.warp(block.timestamp + 10); 63 | //attempt to purchase 11 64 | vm.expectRevert(insufficientTokens); 65 | gda.purchaseTokens(11, address(this)); 66 | } 67 | 68 | function testMintCorrectly() public { 69 | vm.warp(block.timestamp + 10); 70 | assertEq(gda.balanceOf(address(this)), 0); 71 | uint256 purchaseAmount = 5; 72 | uint256 purchasePrice = gda.purchasePrice(purchaseAmount); 73 | assertTrue(purchasePrice > 0); 74 | vm.deal(address(this), purchasePrice); 75 | gda.purchaseTokens{value: purchasePrice}(purchaseAmount, address(this)); 76 | assertEq(gda.balanceOf(address(this)), purchaseAmount); 77 | } 78 | 79 | function testRefund() public { 80 | vm.warp(block.timestamp + 10); 81 | uint256 purchasePrice = gda.purchasePrice(1); 82 | vm.deal(address(this), 2 * purchasePrice); 83 | //pay twice the purchase price 84 | gda.purchaseTokens{value: 2 * purchasePrice}(1, address(this)); 85 | //purchase price should have been refunded 86 | assertTrue(address(this).balance == purchasePrice); 87 | } 88 | 89 | function testFFICorrectnessOne() public { 90 | uint256 ageOfLastAuction = 10; 91 | uint256 quantity = 9; 92 | checkPriceWithParameters( 93 | initialPrice, 94 | decayConstant, 95 | emissionRate, 96 | ageOfLastAuction, 97 | quantity 98 | ); 99 | } 100 | 101 | function testFFICorrectnessTwo() public { 102 | uint256 ageOfLastAuction = 20; 103 | uint256 quantity = 8; 104 | checkPriceWithParameters( 105 | initialPrice, 106 | decayConstant, 107 | emissionRate, 108 | ageOfLastAuction, 109 | quantity 110 | ); 111 | } 112 | 113 | function testFFICorrectnessThree() public { 114 | uint256 ageOfLastAuction = 30; 115 | uint256 quantity = 15; 116 | checkPriceWithParameters( 117 | initialPrice, 118 | decayConstant, 119 | emissionRate, 120 | ageOfLastAuction, 121 | quantity 122 | ); 123 | } 124 | 125 | function testFFICorrectnessFour() public { 126 | uint256 ageOfLastAuction = 40; 127 | uint256 quantity = 35; 128 | checkPriceWithParameters( 129 | initialPrice, 130 | decayConstant, 131 | emissionRate, 132 | ageOfLastAuction, 133 | quantity 134 | ); 135 | } 136 | 137 | //parametrized test helper 138 | function checkPriceWithParameters( 139 | int256 _initialPrice, 140 | int256 _decayConstant, 141 | int256 _emissionRate, 142 | uint256 _ageOfLastAuction, 143 | uint256 _quantity 144 | ) private { 145 | MockContinuousGDA _gda = new MockContinuousGDA( 146 | "Token", 147 | "TKN", 148 | initialPrice, 149 | decayConstant, 150 | emissionRate 151 | ); 152 | 153 | //move time forward 154 | vm.warp(block.timestamp + _ageOfLastAuction); 155 | //calculate actual price from gda 156 | uint256 actualPrice = _gda.purchasePrice(_quantity); 157 | //calculate expected price from python script 158 | uint256 expectedPrice = calculatePrice( 159 | _initialPrice, 160 | _decayConstant, 161 | _emissionRate, 162 | _ageOfLastAuction, 163 | _quantity 164 | ); 165 | //equal within 0.1 percent 166 | utils.assertApproxEqual(actualPrice, expectedPrice, 1); 167 | } 168 | 169 | //call out to python script for price computation 170 | function calculatePrice( 171 | int256 _initialPrice, 172 | int256 _decayConstant, 173 | int256 _emissionRate, 174 | uint256 _ageOfLastAuction, 175 | uint256 _quantity 176 | ) private returns (uint256) { 177 | string[] memory inputs = new string[](13); 178 | inputs[0] = "python3"; 179 | inputs[1] = "analysis/compute_price.py"; 180 | inputs[2] = "exp_continuous"; 181 | inputs[3] = "--initial_price"; 182 | inputs[4] = uint256(_initialPrice).toString(); 183 | inputs[5] = "--decay_constant"; 184 | inputs[6] = uint256(_decayConstant).toString(); 185 | inputs[7] = "--emission_rate"; 186 | inputs[8] = uint256(_emissionRate).toString(); 187 | inputs[9] = "--age_last_auction"; 188 | inputs[10] = _ageOfLastAuction.toString(); 189 | inputs[11] = "--quantity"; 190 | inputs[12] = _quantity.toString(); 191 | bytes memory res = vm.ffi(inputs); 192 | uint256 price = abi.decode(res, (uint256)); 193 | return price; 194 | } 195 | 196 | //make payable 197 | fallback() external payable {} 198 | } 199 | -------------------------------------------------------------------------------- /src/test/DiscreteGDA.t.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: Unlicense 2 | pragma solidity >=0.8.0; 3 | 4 | import {DSTest} from "ds-test/test.sol"; 5 | import {Utilities} from "./utils/Utilities.sol"; 6 | import {console} from "./utils/Console.sol"; 7 | import {Vm} from "forge-std/Vm.sol"; 8 | import {MockDiscreteGDA} from "./mocks/MockDiscreteGDA.sol"; 9 | import {PRBMathSD59x18} from "prb-math/PRBMathSD59x18.sol"; 10 | import {Strings} from "openzeppelin/utils/Strings.sol"; 11 | 12 | ///@notice test discrete GDA behaviour 13 | ///@dev run with --ffi flag to enable correctness tests 14 | contract DiscreteGDATest is DSTest { 15 | using PRBMathSD59x18 for int256; 16 | using Strings for uint256; 17 | 18 | Vm internal immutable vm = Vm(HEVM_ADDRESS); 19 | 20 | Utilities internal utils; 21 | address payable[] internal users; 22 | MockDiscreteGDA internal gda; 23 | 24 | int256 public initialPrice = PRBMathSD59x18.fromInt(1000); 25 | int256 public decayConstant = 26 | PRBMathSD59x18.fromInt(1).div(PRBMathSD59x18.fromInt(2)); 27 | int256 public scaleFactor = 28 | PRBMathSD59x18.fromInt(11).div(PRBMathSD59x18.fromInt(10)); 29 | 30 | //encodings for revert tests 31 | bytes insufficientPayment = 32 | abi.encodeWithSignature("InsufficientPayment()"); 33 | 34 | function setUp() public { 35 | utils = new Utilities(); 36 | users = utils.createUsers(5); 37 | 38 | gda = new MockDiscreteGDA( 39 | "Token", 40 | "TKN", 41 | initialPrice, 42 | scaleFactor, 43 | decayConstant 44 | ); 45 | } 46 | 47 | function testInitialPrice() public { 48 | //initialPrice should be price scale 49 | uint256 initial = uint256(initialPrice); 50 | uint256 purchasePrice = gda.purchasePrice(1); 51 | utils.assertApproxEqual(purchasePrice, initial, 1); 52 | } 53 | 54 | function testInsuffientPayment() public { 55 | uint256 purchasePrice = gda.purchasePrice(1); 56 | vm.deal(address(this), purchasePrice); 57 | vm.expectRevert(insufficientPayment); 58 | gda.purchaseTokens{value: purchasePrice - 1}(1, address(this)); 59 | } 60 | 61 | function testMintCorrectly() public { 62 | assertTrue(gda.ownerOf(1) != address(this)); 63 | uint256 purchasePrice = gda.purchasePrice(1); 64 | vm.deal(address(this), purchasePrice); 65 | gda.purchaseTokens{value: purchasePrice}(1, address(this)); 66 | assertTrue(gda.ownerOf(1) == address(this)); 67 | } 68 | 69 | function testRefund() public { 70 | uint256 purchasePrice = gda.purchasePrice(1); 71 | vm.deal(address(this), 2 * purchasePrice); 72 | //pay twice the purchase price 73 | gda.purchaseTokens{value: 2 * purchasePrice}(1, address(this)); 74 | //purchase price should have been refunded 75 | assertTrue(address(this).balance == purchasePrice); 76 | } 77 | 78 | function testFFICorrectnessOne() public { 79 | uint256 numTotalPurchases = 1; 80 | uint256 timeSinceStart = 10; 81 | uint256 quantity = 9; 82 | checkPriceWithParameters( 83 | initialPrice, 84 | scaleFactor, 85 | decayConstant, 86 | numTotalPurchases, 87 | timeSinceStart, 88 | quantity 89 | ); 90 | } 91 | 92 | function testFFICorrectnessTwo() public { 93 | uint256 numTotalPurchases = 2; 94 | uint256 timeSinceStart = 10; 95 | uint256 quantity = 9; 96 | checkPriceWithParameters( 97 | initialPrice, 98 | scaleFactor, 99 | decayConstant, 100 | numTotalPurchases, 101 | timeSinceStart, 102 | quantity 103 | ); 104 | } 105 | 106 | function testFFICorrectnessThree() public { 107 | uint256 numTotalPurchases = 4; 108 | uint256 timeSinceStart = 10; 109 | uint256 quantity = 9; 110 | checkPriceWithParameters( 111 | initialPrice, 112 | scaleFactor, 113 | decayConstant, 114 | numTotalPurchases, 115 | timeSinceStart, 116 | quantity 117 | ); 118 | } 119 | 120 | function testFFICorrectnessFour() public { 121 | uint256 numTotalPurchases = 20; 122 | uint256 timeSinceStart = 100; 123 | uint256 quantity = 1; 124 | checkPriceWithParameters( 125 | initialPrice, 126 | scaleFactor, 127 | decayConstant, 128 | numTotalPurchases, 129 | timeSinceStart, 130 | quantity 131 | ); 132 | } 133 | 134 | //parametrized test helper 135 | function checkPriceWithParameters( 136 | int256 _initialPrice, 137 | int256 _scaleFactor, 138 | int256 _decayConstant, 139 | uint256 _numTotalPurchases, 140 | uint256 _timeSinceStart, 141 | uint256 _quantity 142 | ) private { 143 | MockDiscreteGDA _gda = new MockDiscreteGDA( 144 | "Token", 145 | "TKN", 146 | _initialPrice, 147 | _scaleFactor, 148 | _decayConstant 149 | ); 150 | 151 | //make past pruchases 152 | uint256 purchasePrice = _gda.purchasePrice(_numTotalPurchases); 153 | vm.deal(address(this), purchasePrice); 154 | _gda.purchaseTokens{value: purchasePrice}( 155 | _numTotalPurchases, 156 | address(this) 157 | ); 158 | 159 | //move time forward 160 | vm.warp(block.timestamp + _timeSinceStart); 161 | //calculate actual price from gda 162 | uint256 actualPrice = _gda.purchasePrice(_quantity); 163 | //calculate expected price from python script 164 | uint256 expectedPrice = calculatePrice( 165 | _initialPrice, 166 | _scaleFactor, 167 | _decayConstant, 168 | _numTotalPurchases, 169 | _timeSinceStart, 170 | _quantity 171 | ); 172 | //equal within 0.1% 173 | utils.assertApproxEqual(actualPrice, expectedPrice, 1); 174 | } 175 | 176 | //call out to python script for price computation 177 | function calculatePrice( 178 | int256 _initialPrice, 179 | int256 _scaleFactor, 180 | int256 _decayConstant, 181 | uint256 _numTotalPurchases, 182 | uint256 _timeSinceStart, 183 | uint256 _quantity 184 | ) private returns (uint256) { 185 | string[] memory inputs = new string[](15); 186 | inputs[0] = "python3"; 187 | inputs[1] = "analysis/compute_price.py"; 188 | inputs[2] = "exp_discrete"; 189 | inputs[3] = "--initial_price"; 190 | inputs[4] = uint256(_initialPrice).toString(); 191 | inputs[5] = "--scale_factor"; 192 | inputs[6] = uint256(_scaleFactor).toString(); 193 | inputs[7] = "--decay_constant"; 194 | inputs[8] = uint256(_decayConstant).toString(); 195 | inputs[9] = "--num_total_purchases"; 196 | inputs[10] = _numTotalPurchases.toString(); 197 | inputs[11] = "--time_since_start"; 198 | inputs[12] = _timeSinceStart.toString(); 199 | inputs[13] = "--quantity"; 200 | inputs[14] = _quantity.toString(); 201 | bytes memory res = vm.ffi(inputs); 202 | uint256 price = abi.decode(res, (uint256)); 203 | return price; 204 | } 205 | 206 | //make payable 207 | fallback() external payable {} 208 | } 209 | -------------------------------------------------------------------------------- /analysis/analysis.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "id": "75271b14-a518-4d4b-8d96-095489d7f23b", 7 | "metadata": {}, 8 | "outputs": [], 9 | "source": [ 10 | "import matplotlib.pyplot as plt\n", 11 | "import numpy as np\n", 12 | "from gda import ExponentialDiscreteGDA, ExponentialContinuousGDA" 13 | ] 14 | }, 15 | { 16 | "cell_type": "code", 17 | "execution_count": 2, 18 | "id": "75420eb3-7dff-48eb-9a27-d162274296a7", 19 | "metadata": {}, 20 | "outputs": [], 21 | "source": [ 22 | "def plot_discrete_gda(gda, num_total_purchases, time_since_start): \n", 23 | " \n", 24 | " purchase_quantities = range(1, 11)\n", 25 | " cumulative_prices = [gda.get_cumulative_purchase_price(num_total_purchases, time_since_start, q) for q in purchase_quantities]\n", 26 | "\n", 27 | " plt.bar(purchase_quantities, cumulative_prices)\n", 28 | " plt.xlabel(\"Quantity of Tokens Purchased\")\n", 29 | " plt.ylabel(\"Cumulative Price (ETH)\")\n", 30 | " plt.title(f'Discrete GDA: Cumulative Purchase Price (λ: {gda.decay_constant}, α: {gda.scale_factor} T: {time_since_start}, m:{num_total_purchases}, k:{gda.initial_price})')\n", 31 | " plt.xticks(purchase_quantities)\n", 32 | " plt.show()" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 3, 38 | "id": "bfc9c787-62c0-4779-8119-af310d65cb94", 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "def plot_continuous_gda(gda, age_last_available_auction, title): \n", 43 | " \n", 44 | " purchase_quantities = np.arange(0.0, 10.0, 0.01)\n", 45 | " cumulative_prices = [gda.get_cumulative_purchase_price(age_last_available_auction, q) for q in purchase_quantities]\n", 46 | " \n", 47 | " plt.plot(purchase_quantities, cumulative_prices, lw=2)\n", 48 | " plt.xlabel(\"Quantity of Tokens Purchased\")\n", 49 | " plt.ylabel(\"Cumulative Price (ETH)\")\n", 50 | " plt.title(title)\n", 51 | " plt.show()" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 4, 57 | "id": "f194fba1-4de0-4a57-b401-989b7c5fd178", 58 | "metadata": {}, 59 | "outputs": [ 60 | { 61 | "data": { 62 | "image/png": "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", 63 | "text/plain": [ 64 | "
" 65 | ] 66 | }, 67 | "metadata": { 68 | "needs_background": "light" 69 | }, 70 | "output_type": "display_data" 71 | } 72 | ], 73 | "source": [ 74 | "gda = ExponentialDiscreteGDA(initial_price=10, decay_constant=.9, scale_factor=1.5)\n", 75 | "plot_discrete_gda(gda, num_total_purchases=1, time_since_start=5) " 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 12, 81 | "id": "835b5dff-e14e-4d68-8894-9907feea9e95", 82 | "metadata": {}, 83 | "outputs": [ 84 | { 85 | "data": { 86 | "image/png": "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", 87 | "text/plain": [ 88 | "
" 89 | ] 90 | }, 91 | "metadata": { 92 | "needs_background": "light" 93 | }, 94 | "output_type": "display_data" 95 | } 96 | ], 97 | "source": [ 98 | "initial_price = 10\n", 99 | "decay_constant = 0.5\n", 100 | "emission_rate = 1\n", 101 | "age_last_available_auction = 10\n", 102 | "title = f'Exponential GDA: Cumulative Purchase Price (λ: {decay_constant}, T: {age_last_available_auction}, r:{emission_rate}, k:{initial_price})'\n", 103 | "gda = ExponentialContinuousGDA(price_scale, decay_constant, emission_rate)\n", 104 | "plot_continuous_gda(gda, age_last_available_auction, title)" 105 | ] 106 | } 107 | ], 108 | "metadata": { 109 | "kernelspec": { 110 | "display_name": "Python 3 (ipykernel)", 111 | "language": "python", 112 | "name": "python3" 113 | }, 114 | "language_info": { 115 | "codemirror_mode": { 116 | "name": "ipython", 117 | "version": 3 118 | }, 119 | "file_extension": ".py", 120 | "mimetype": "text/x-python", 121 | "name": "python", 122 | "nbconvert_exporter": "python", 123 | "pygments_lexer": "ipython3", 124 | "version": "3.9.7" 125 | } 126 | }, 127 | "nbformat": 4, 128 | "nbformat_minor": 5 129 | } 130 | -------------------------------------------------------------------------------- /src/test/utils/Console.sol: -------------------------------------------------------------------------------- 1 | // SPDX-License-Identifier: MIT 2 | pragma solidity >=0.8.0; 3 | 4 | /* solhint-disable */ 5 | library console { 6 | address constant CONSOLE_ADDRESS = 7 | address(0x000000000000000000636F6e736F6c652e6c6f67); 8 | 9 | function _sendLogPayload(bytes memory payload) private view { 10 | uint256 payloadLength = payload.length; 11 | address consoleAddress = CONSOLE_ADDRESS; 12 | assembly { 13 | let payloadStart := add(payload, 32) 14 | let r := staticcall( 15 | gas(), 16 | consoleAddress, 17 | payloadStart, 18 | payloadLength, 19 | 0, 20 | 0 21 | ) 22 | } 23 | } 24 | 25 | function log() internal view { 26 | _sendLogPayload(abi.encodeWithSignature("log()")); 27 | } 28 | 29 | function logInt(int256 p0) internal view { 30 | _sendLogPayload(abi.encodeWithSignature("log(int)", p0)); 31 | } 32 | 33 | function logUint(uint256 p0) internal view { 34 | _sendLogPayload(abi.encodeWithSignature("log(uint)", p0)); 35 | } 36 | 37 | function logString(string memory p0) internal view { 38 | _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); 39 | } 40 | 41 | function logBool(bool p0) internal view { 42 | _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); 43 | } 44 | 45 | function logAddress(address p0) internal view { 46 | _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); 47 | } 48 | 49 | function logBytes(bytes memory p0) internal view { 50 | _sendLogPayload(abi.encodeWithSignature("log(bytes)", p0)); 51 | } 52 | 53 | function logBytes1(bytes1 p0) internal view { 54 | _sendLogPayload(abi.encodeWithSignature("log(bytes1)", p0)); 55 | } 56 | 57 | function logBytes2(bytes2 p0) internal view { 58 | _sendLogPayload(abi.encodeWithSignature("log(bytes2)", p0)); 59 | } 60 | 61 | function logBytes3(bytes3 p0) internal view { 62 | _sendLogPayload(abi.encodeWithSignature("log(bytes3)", p0)); 63 | } 64 | 65 | function logBytes4(bytes4 p0) internal view { 66 | _sendLogPayload(abi.encodeWithSignature("log(bytes4)", p0)); 67 | } 68 | 69 | function logBytes5(bytes5 p0) internal view { 70 | _sendLogPayload(abi.encodeWithSignature("log(bytes5)", p0)); 71 | } 72 | 73 | function logBytes6(bytes6 p0) internal view { 74 | _sendLogPayload(abi.encodeWithSignature("log(bytes6)", p0)); 75 | } 76 | 77 | function logBytes7(bytes7 p0) internal view { 78 | _sendLogPayload(abi.encodeWithSignature("log(bytes7)", p0)); 79 | } 80 | 81 | function logBytes8(bytes8 p0) internal view { 82 | _sendLogPayload(abi.encodeWithSignature("log(bytes8)", p0)); 83 | } 84 | 85 | function logBytes9(bytes9 p0) internal view { 86 | _sendLogPayload(abi.encodeWithSignature("log(bytes9)", p0)); 87 | } 88 | 89 | function logBytes10(bytes10 p0) internal view { 90 | _sendLogPayload(abi.encodeWithSignature("log(bytes10)", p0)); 91 | } 92 | 93 | function logBytes11(bytes11 p0) internal view { 94 | _sendLogPayload(abi.encodeWithSignature("log(bytes11)", p0)); 95 | } 96 | 97 | function logBytes12(bytes12 p0) internal view { 98 | _sendLogPayload(abi.encodeWithSignature("log(bytes12)", p0)); 99 | } 100 | 101 | function logBytes13(bytes13 p0) internal view { 102 | _sendLogPayload(abi.encodeWithSignature("log(bytes13)", p0)); 103 | } 104 | 105 | function logBytes14(bytes14 p0) internal view { 106 | _sendLogPayload(abi.encodeWithSignature("log(bytes14)", p0)); 107 | } 108 | 109 | function logBytes15(bytes15 p0) internal view { 110 | _sendLogPayload(abi.encodeWithSignature("log(bytes15)", p0)); 111 | } 112 | 113 | function logBytes16(bytes16 p0) internal view { 114 | _sendLogPayload(abi.encodeWithSignature("log(bytes16)", p0)); 115 | } 116 | 117 | function logBytes17(bytes17 p0) internal view { 118 | _sendLogPayload(abi.encodeWithSignature("log(bytes17)", p0)); 119 | } 120 | 121 | function logBytes18(bytes18 p0) internal view { 122 | _sendLogPayload(abi.encodeWithSignature("log(bytes18)", p0)); 123 | } 124 | 125 | function logBytes19(bytes19 p0) internal view { 126 | _sendLogPayload(abi.encodeWithSignature("log(bytes19)", p0)); 127 | } 128 | 129 | function logBytes20(bytes20 p0) internal view { 130 | _sendLogPayload(abi.encodeWithSignature("log(bytes20)", p0)); 131 | } 132 | 133 | function logBytes21(bytes21 p0) internal view { 134 | _sendLogPayload(abi.encodeWithSignature("log(bytes21)", p0)); 135 | } 136 | 137 | function logBytes22(bytes22 p0) internal view { 138 | _sendLogPayload(abi.encodeWithSignature("log(bytes22)", p0)); 139 | } 140 | 141 | function logBytes23(bytes23 p0) internal view { 142 | _sendLogPayload(abi.encodeWithSignature("log(bytes23)", p0)); 143 | } 144 | 145 | function logBytes24(bytes24 p0) internal view { 146 | _sendLogPayload(abi.encodeWithSignature("log(bytes24)", p0)); 147 | } 148 | 149 | function logBytes25(bytes25 p0) internal view { 150 | _sendLogPayload(abi.encodeWithSignature("log(bytes25)", p0)); 151 | } 152 | 153 | function logBytes26(bytes26 p0) internal view { 154 | _sendLogPayload(abi.encodeWithSignature("log(bytes26)", p0)); 155 | } 156 | 157 | function logBytes27(bytes27 p0) internal view { 158 | _sendLogPayload(abi.encodeWithSignature("log(bytes27)", p0)); 159 | } 160 | 161 | function logBytes28(bytes28 p0) internal view { 162 | _sendLogPayload(abi.encodeWithSignature("log(bytes28)", p0)); 163 | } 164 | 165 | function logBytes29(bytes29 p0) internal view { 166 | _sendLogPayload(abi.encodeWithSignature("log(bytes29)", p0)); 167 | } 168 | 169 | function logBytes30(bytes30 p0) internal view { 170 | _sendLogPayload(abi.encodeWithSignature("log(bytes30)", p0)); 171 | } 172 | 173 | function logBytes31(bytes31 p0) internal view { 174 | _sendLogPayload(abi.encodeWithSignature("log(bytes31)", p0)); 175 | } 176 | 177 | function logBytes32(bytes32 p0) internal view { 178 | _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0)); 179 | } 180 | 181 | function log(bytes32[] memory p0) internal view { 182 | for (uint256 i; i < p0.length; ) { 183 | _sendLogPayload(abi.encodeWithSignature("log(bytes32)", p0[i])); 184 | unchecked { 185 | ++i; 186 | } 187 | } 188 | } 189 | 190 | function log(uint256 p0) internal view { 191 | _sendLogPayload(abi.encodeWithSignature("log(uint)", p0)); 192 | } 193 | 194 | function log(uint256[] memory p0) internal view { 195 | for (uint256 i; i < p0.length; ) { 196 | _sendLogPayload(abi.encodeWithSignature("log(uint)", p0[i])); 197 | unchecked { 198 | ++i; 199 | } 200 | } 201 | } 202 | 203 | function log(string memory p0) internal view { 204 | _sendLogPayload(abi.encodeWithSignature("log(string)", p0)); 205 | } 206 | 207 | function log(string[] memory p0) internal view { 208 | for (uint256 i; i < p0.length; ) { 209 | _sendLogPayload(abi.encodeWithSignature("log(string)", p0[i])); 210 | unchecked { 211 | ++i; 212 | } 213 | } 214 | } 215 | 216 | function log(bool p0) internal view { 217 | _sendLogPayload(abi.encodeWithSignature("log(bool)", p0)); 218 | } 219 | 220 | function log(bool[] memory p0) internal view { 221 | for (uint256 i; i < p0.length; ) { 222 | _sendLogPayload(abi.encodeWithSignature("log(bool)", p0[i])); 223 | unchecked { 224 | ++i; 225 | } 226 | } 227 | } 228 | 229 | function log(address p0) internal view { 230 | _sendLogPayload(abi.encodeWithSignature("log(address)", p0)); 231 | } 232 | 233 | function log(address[] memory p0) internal view { 234 | for (uint256 i; i < p0.length; ) { 235 | _sendLogPayload(abi.encodeWithSignature("log(address)", p0[i])); 236 | unchecked { 237 | ++i; 238 | } 239 | } 240 | } 241 | 242 | function log(uint256 p0, uint256 p1) internal view { 243 | _sendLogPayload(abi.encodeWithSignature("log(uint,uint)", p0, p1)); 244 | } 245 | 246 | function log(uint256 p0, string memory p1) internal view { 247 | _sendLogPayload(abi.encodeWithSignature("log(uint,string)", p0, p1)); 248 | } 249 | 250 | function log(uint256 p0, bool p1) internal view { 251 | _sendLogPayload(abi.encodeWithSignature("log(uint,bool)", p0, p1)); 252 | } 253 | 254 | function log(uint256 p0, address p1) internal view { 255 | _sendLogPayload(abi.encodeWithSignature("log(uint,address)", p0, p1)); 256 | } 257 | 258 | function log(string memory p0, uint256 p1) internal view { 259 | _sendLogPayload(abi.encodeWithSignature("log(string,uint)", p0, p1)); 260 | } 261 | 262 | function log(string memory p0, string memory p1) internal view { 263 | _sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1)); 264 | } 265 | 266 | function log(string memory p0, bool p1) internal view { 267 | _sendLogPayload(abi.encodeWithSignature("log(string,bool)", p0, p1)); 268 | } 269 | 270 | function log(string memory p0, address p1) internal view { 271 | _sendLogPayload(abi.encodeWithSignature("log(string,address)", p0, p1)); 272 | } 273 | 274 | function log(bool p0, uint256 p1) internal view { 275 | _sendLogPayload(abi.encodeWithSignature("log(bool,uint)", p0, p1)); 276 | } 277 | 278 | function log(bool p0, string memory p1) internal view { 279 | _sendLogPayload(abi.encodeWithSignature("log(bool,string)", p0, p1)); 280 | } 281 | 282 | function log(bool p0, bool p1) internal view { 283 | _sendLogPayload(abi.encodeWithSignature("log(bool,bool)", p0, p1)); 284 | } 285 | 286 | function log(bool p0, address p1) internal view { 287 | _sendLogPayload(abi.encodeWithSignature("log(bool,address)", p0, p1)); 288 | } 289 | 290 | function log(address p0, uint256 p1) internal view { 291 | _sendLogPayload(abi.encodeWithSignature("log(address,uint)", p0, p1)); 292 | } 293 | 294 | function log(address p0, string memory p1) internal view { 295 | _sendLogPayload(abi.encodeWithSignature("log(address,string)", p0, p1)); 296 | } 297 | 298 | function log(address p0, bool p1) internal view { 299 | _sendLogPayload(abi.encodeWithSignature("log(address,bool)", p0, p1)); 300 | } 301 | 302 | function log(address p0, address p1) internal view { 303 | _sendLogPayload( 304 | abi.encodeWithSignature("log(address,address)", p0, p1) 305 | ); 306 | } 307 | 308 | function log( 309 | uint256 p0, 310 | uint256 p1, 311 | uint256 p2 312 | ) internal view { 313 | _sendLogPayload( 314 | abi.encodeWithSignature("log(uint,uint,uint)", p0, p1, p2) 315 | ); 316 | } 317 | 318 | function log( 319 | uint256 p0, 320 | uint256 p1, 321 | string memory p2 322 | ) internal view { 323 | _sendLogPayload( 324 | abi.encodeWithSignature("log(uint,uint,string)", p0, p1, p2) 325 | ); 326 | } 327 | 328 | function log( 329 | uint256 p0, 330 | uint256 p1, 331 | bool p2 332 | ) internal view { 333 | _sendLogPayload( 334 | abi.encodeWithSignature("log(uint,uint,bool)", p0, p1, p2) 335 | ); 336 | } 337 | 338 | function log( 339 | uint256 p0, 340 | uint256 p1, 341 | address p2 342 | ) internal view { 343 | _sendLogPayload( 344 | abi.encodeWithSignature("log(uint,uint,address)", p0, p1, p2) 345 | ); 346 | } 347 | 348 | function log( 349 | uint256 p0, 350 | string memory p1, 351 | uint256 p2 352 | ) internal view { 353 | _sendLogPayload( 354 | abi.encodeWithSignature("log(uint,string,uint)", p0, p1, p2) 355 | ); 356 | } 357 | 358 | function log( 359 | uint256 p0, 360 | string memory p1, 361 | string memory p2 362 | ) internal view { 363 | _sendLogPayload( 364 | abi.encodeWithSignature("log(uint,string,string)", p0, p1, p2) 365 | ); 366 | } 367 | 368 | function log( 369 | uint256 p0, 370 | string memory p1, 371 | bool p2 372 | ) internal view { 373 | _sendLogPayload( 374 | abi.encodeWithSignature("log(uint,string,bool)", p0, p1, p2) 375 | ); 376 | } 377 | 378 | function log( 379 | uint256 p0, 380 | string memory p1, 381 | address p2 382 | ) internal view { 383 | _sendLogPayload( 384 | abi.encodeWithSignature("log(uint,string,address)", p0, p1, p2) 385 | ); 386 | } 387 | 388 | function log( 389 | uint256 p0, 390 | bool p1, 391 | uint256 p2 392 | ) internal view { 393 | _sendLogPayload( 394 | abi.encodeWithSignature("log(uint,bool,uint)", p0, p1, p2) 395 | ); 396 | } 397 | 398 | function log( 399 | uint256 p0, 400 | bool p1, 401 | string memory p2 402 | ) internal view { 403 | _sendLogPayload( 404 | abi.encodeWithSignature("log(uint,bool,string)", p0, p1, p2) 405 | ); 406 | } 407 | 408 | function log( 409 | uint256 p0, 410 | bool p1, 411 | bool p2 412 | ) internal view { 413 | _sendLogPayload( 414 | abi.encodeWithSignature("log(uint,bool,bool)", p0, p1, p2) 415 | ); 416 | } 417 | 418 | function log( 419 | uint256 p0, 420 | bool p1, 421 | address p2 422 | ) internal view { 423 | _sendLogPayload( 424 | abi.encodeWithSignature("log(uint,bool,address)", p0, p1, p2) 425 | ); 426 | } 427 | 428 | function log( 429 | uint256 p0, 430 | address p1, 431 | uint256 p2 432 | ) internal view { 433 | _sendLogPayload( 434 | abi.encodeWithSignature("log(uint,address,uint)", p0, p1, p2) 435 | ); 436 | } 437 | 438 | function log( 439 | uint256 p0, 440 | address p1, 441 | string memory p2 442 | ) internal view { 443 | _sendLogPayload( 444 | abi.encodeWithSignature("log(uint,address,string)", p0, p1, p2) 445 | ); 446 | } 447 | 448 | function log( 449 | uint256 p0, 450 | address p1, 451 | bool p2 452 | ) internal view { 453 | _sendLogPayload( 454 | abi.encodeWithSignature("log(uint,address,bool)", p0, p1, p2) 455 | ); 456 | } 457 | 458 | function log( 459 | uint256 p0, 460 | address p1, 461 | address p2 462 | ) internal view { 463 | _sendLogPayload( 464 | abi.encodeWithSignature("log(uint,address,address)", p0, p1, p2) 465 | ); 466 | } 467 | 468 | function log( 469 | string memory p0, 470 | uint256 p1, 471 | uint256 p2 472 | ) internal view { 473 | _sendLogPayload( 474 | abi.encodeWithSignature("log(string,uint,uint)", p0, p1, p2) 475 | ); 476 | } 477 | 478 | function log( 479 | string memory p0, 480 | uint256 p1, 481 | string memory p2 482 | ) internal view { 483 | _sendLogPayload( 484 | abi.encodeWithSignature("log(string,uint,string)", p0, p1, p2) 485 | ); 486 | } 487 | 488 | function log( 489 | string memory p0, 490 | uint256 p1, 491 | bool p2 492 | ) internal view { 493 | _sendLogPayload( 494 | abi.encodeWithSignature("log(string,uint,bool)", p0, p1, p2) 495 | ); 496 | } 497 | 498 | function log( 499 | string memory p0, 500 | uint256 p1, 501 | address p2 502 | ) internal view { 503 | _sendLogPayload( 504 | abi.encodeWithSignature("log(string,uint,address)", p0, p1, p2) 505 | ); 506 | } 507 | 508 | function log( 509 | string memory p0, 510 | string memory p1, 511 | uint256 p2 512 | ) internal view { 513 | _sendLogPayload( 514 | abi.encodeWithSignature("log(string,string,uint)", p0, p1, p2) 515 | ); 516 | } 517 | 518 | function log( 519 | string memory p0, 520 | string memory p1, 521 | string memory p2 522 | ) internal view { 523 | _sendLogPayload( 524 | abi.encodeWithSignature("log(string,string,string)", p0, p1, p2) 525 | ); 526 | } 527 | 528 | function log( 529 | string memory p0, 530 | string memory p1, 531 | bool p2 532 | ) internal view { 533 | _sendLogPayload( 534 | abi.encodeWithSignature("log(string,string,bool)", p0, p1, p2) 535 | ); 536 | } 537 | 538 | function log( 539 | string memory p0, 540 | string memory p1, 541 | address p2 542 | ) internal view { 543 | _sendLogPayload( 544 | abi.encodeWithSignature("log(string,string,address)", p0, p1, p2) 545 | ); 546 | } 547 | 548 | function log( 549 | string memory p0, 550 | bool p1, 551 | uint256 p2 552 | ) internal view { 553 | _sendLogPayload( 554 | abi.encodeWithSignature("log(string,bool,uint)", p0, p1, p2) 555 | ); 556 | } 557 | 558 | function log( 559 | string memory p0, 560 | bool p1, 561 | string memory p2 562 | ) internal view { 563 | _sendLogPayload( 564 | abi.encodeWithSignature("log(string,bool,string)", p0, p1, p2) 565 | ); 566 | } 567 | 568 | function log( 569 | string memory p0, 570 | bool p1, 571 | bool p2 572 | ) internal view { 573 | _sendLogPayload( 574 | abi.encodeWithSignature("log(string,bool,bool)", p0, p1, p2) 575 | ); 576 | } 577 | 578 | function log( 579 | string memory p0, 580 | bool p1, 581 | address p2 582 | ) internal view { 583 | _sendLogPayload( 584 | abi.encodeWithSignature("log(string,bool,address)", p0, p1, p2) 585 | ); 586 | } 587 | 588 | function log( 589 | string memory p0, 590 | address p1, 591 | uint256 p2 592 | ) internal view { 593 | _sendLogPayload( 594 | abi.encodeWithSignature("log(string,address,uint)", p0, p1, p2) 595 | ); 596 | } 597 | 598 | function log( 599 | string memory p0, 600 | address p1, 601 | string memory p2 602 | ) internal view { 603 | _sendLogPayload( 604 | abi.encodeWithSignature("log(string,address,string)", p0, p1, p2) 605 | ); 606 | } 607 | 608 | function log( 609 | string memory p0, 610 | address p1, 611 | bool p2 612 | ) internal view { 613 | _sendLogPayload( 614 | abi.encodeWithSignature("log(string,address,bool)", p0, p1, p2) 615 | ); 616 | } 617 | 618 | function log( 619 | string memory p0, 620 | address p1, 621 | address p2 622 | ) internal view { 623 | _sendLogPayload( 624 | abi.encodeWithSignature("log(string,address,address)", p0, p1, p2) 625 | ); 626 | } 627 | 628 | function log( 629 | bool p0, 630 | uint256 p1, 631 | uint256 p2 632 | ) internal view { 633 | _sendLogPayload( 634 | abi.encodeWithSignature("log(bool,uint,uint)", p0, p1, p2) 635 | ); 636 | } 637 | 638 | function log( 639 | bool p0, 640 | uint256 p1, 641 | string memory p2 642 | ) internal view { 643 | _sendLogPayload( 644 | abi.encodeWithSignature("log(bool,uint,string)", p0, p1, p2) 645 | ); 646 | } 647 | 648 | function log( 649 | bool p0, 650 | uint256 p1, 651 | bool p2 652 | ) internal view { 653 | _sendLogPayload( 654 | abi.encodeWithSignature("log(bool,uint,bool)", p0, p1, p2) 655 | ); 656 | } 657 | 658 | function log( 659 | bool p0, 660 | uint256 p1, 661 | address p2 662 | ) internal view { 663 | _sendLogPayload( 664 | abi.encodeWithSignature("log(bool,uint,address)", p0, p1, p2) 665 | ); 666 | } 667 | 668 | function log( 669 | bool p0, 670 | string memory p1, 671 | uint256 p2 672 | ) internal view { 673 | _sendLogPayload( 674 | abi.encodeWithSignature("log(bool,string,uint)", p0, p1, p2) 675 | ); 676 | } 677 | 678 | function log( 679 | bool p0, 680 | string memory p1, 681 | string memory p2 682 | ) internal view { 683 | _sendLogPayload( 684 | abi.encodeWithSignature("log(bool,string,string)", p0, p1, p2) 685 | ); 686 | } 687 | 688 | function log( 689 | bool p0, 690 | string memory p1, 691 | bool p2 692 | ) internal view { 693 | _sendLogPayload( 694 | abi.encodeWithSignature("log(bool,string,bool)", p0, p1, p2) 695 | ); 696 | } 697 | 698 | function log( 699 | bool p0, 700 | string memory p1, 701 | address p2 702 | ) internal view { 703 | _sendLogPayload( 704 | abi.encodeWithSignature("log(bool,string,address)", p0, p1, p2) 705 | ); 706 | } 707 | 708 | function log( 709 | bool p0, 710 | bool p1, 711 | uint256 p2 712 | ) internal view { 713 | _sendLogPayload( 714 | abi.encodeWithSignature("log(bool,bool,uint)", p0, p1, p2) 715 | ); 716 | } 717 | 718 | function log( 719 | bool p0, 720 | bool p1, 721 | string memory p2 722 | ) internal view { 723 | _sendLogPayload( 724 | abi.encodeWithSignature("log(bool,bool,string)", p0, p1, p2) 725 | ); 726 | } 727 | 728 | function log( 729 | bool p0, 730 | bool p1, 731 | bool p2 732 | ) internal view { 733 | _sendLogPayload( 734 | abi.encodeWithSignature("log(bool,bool,bool)", p0, p1, p2) 735 | ); 736 | } 737 | 738 | function log( 739 | bool p0, 740 | bool p1, 741 | address p2 742 | ) internal view { 743 | _sendLogPayload( 744 | abi.encodeWithSignature("log(bool,bool,address)", p0, p1, p2) 745 | ); 746 | } 747 | 748 | function log( 749 | bool p0, 750 | address p1, 751 | uint256 p2 752 | ) internal view { 753 | _sendLogPayload( 754 | abi.encodeWithSignature("log(bool,address,uint)", p0, p1, p2) 755 | ); 756 | } 757 | 758 | function log( 759 | bool p0, 760 | address p1, 761 | string memory p2 762 | ) internal view { 763 | _sendLogPayload( 764 | abi.encodeWithSignature("log(bool,address,string)", p0, p1, p2) 765 | ); 766 | } 767 | 768 | function log( 769 | bool p0, 770 | address p1, 771 | bool p2 772 | ) internal view { 773 | _sendLogPayload( 774 | abi.encodeWithSignature("log(bool,address,bool)", p0, p1, p2) 775 | ); 776 | } 777 | 778 | function log( 779 | bool p0, 780 | address p1, 781 | address p2 782 | ) internal view { 783 | _sendLogPayload( 784 | abi.encodeWithSignature("log(bool,address,address)", p0, p1, p2) 785 | ); 786 | } 787 | 788 | function log( 789 | address p0, 790 | uint256 p1, 791 | uint256 p2 792 | ) internal view { 793 | _sendLogPayload( 794 | abi.encodeWithSignature("log(address,uint,uint)", p0, p1, p2) 795 | ); 796 | } 797 | 798 | function log( 799 | address p0, 800 | uint256 p1, 801 | string memory p2 802 | ) internal view { 803 | _sendLogPayload( 804 | abi.encodeWithSignature("log(address,uint,string)", p0, p1, p2) 805 | ); 806 | } 807 | 808 | function log( 809 | address p0, 810 | uint256 p1, 811 | bool p2 812 | ) internal view { 813 | _sendLogPayload( 814 | abi.encodeWithSignature("log(address,uint,bool)", p0, p1, p2) 815 | ); 816 | } 817 | 818 | function log( 819 | address p0, 820 | uint256 p1, 821 | address p2 822 | ) internal view { 823 | _sendLogPayload( 824 | abi.encodeWithSignature("log(address,uint,address)", p0, p1, p2) 825 | ); 826 | } 827 | 828 | function log( 829 | address p0, 830 | string memory p1, 831 | uint256 p2 832 | ) internal view { 833 | _sendLogPayload( 834 | abi.encodeWithSignature("log(address,string,uint)", p0, p1, p2) 835 | ); 836 | } 837 | 838 | function log( 839 | address p0, 840 | string memory p1, 841 | string memory p2 842 | ) internal view { 843 | _sendLogPayload( 844 | abi.encodeWithSignature("log(address,string,string)", p0, p1, p2) 845 | ); 846 | } 847 | 848 | function log( 849 | address p0, 850 | string memory p1, 851 | bool p2 852 | ) internal view { 853 | _sendLogPayload( 854 | abi.encodeWithSignature("log(address,string,bool)", p0, p1, p2) 855 | ); 856 | } 857 | 858 | function log( 859 | address p0, 860 | string memory p1, 861 | address p2 862 | ) internal view { 863 | _sendLogPayload( 864 | abi.encodeWithSignature("log(address,string,address)", p0, p1, p2) 865 | ); 866 | } 867 | 868 | function log( 869 | address p0, 870 | bool p1, 871 | uint256 p2 872 | ) internal view { 873 | _sendLogPayload( 874 | abi.encodeWithSignature("log(address,bool,uint)", p0, p1, p2) 875 | ); 876 | } 877 | 878 | function log( 879 | address p0, 880 | bool p1, 881 | string memory p2 882 | ) internal view { 883 | _sendLogPayload( 884 | abi.encodeWithSignature("log(address,bool,string)", p0, p1, p2) 885 | ); 886 | } 887 | 888 | function log( 889 | address p0, 890 | bool p1, 891 | bool p2 892 | ) internal view { 893 | _sendLogPayload( 894 | abi.encodeWithSignature("log(address,bool,bool)", p0, p1, p2) 895 | ); 896 | } 897 | 898 | function log( 899 | address p0, 900 | bool p1, 901 | address p2 902 | ) internal view { 903 | _sendLogPayload( 904 | abi.encodeWithSignature("log(address,bool,address)", p0, p1, p2) 905 | ); 906 | } 907 | 908 | function log( 909 | address p0, 910 | address p1, 911 | uint256 p2 912 | ) internal view { 913 | _sendLogPayload( 914 | abi.encodeWithSignature("log(address,address,uint)", p0, p1, p2) 915 | ); 916 | } 917 | 918 | function log( 919 | address p0, 920 | address p1, 921 | string memory p2 922 | ) internal view { 923 | _sendLogPayload( 924 | abi.encodeWithSignature("log(address,address,string)", p0, p1, p2) 925 | ); 926 | } 927 | 928 | function log( 929 | address p0, 930 | address p1, 931 | bool p2 932 | ) internal view { 933 | _sendLogPayload( 934 | abi.encodeWithSignature("log(address,address,bool)", p0, p1, p2) 935 | ); 936 | } 937 | 938 | function log( 939 | address p0, 940 | address p1, 941 | address p2 942 | ) internal view { 943 | _sendLogPayload( 944 | abi.encodeWithSignature("log(address,address,address)", p0, p1, p2) 945 | ); 946 | } 947 | 948 | function log( 949 | uint256 p0, 950 | uint256 p1, 951 | uint256 p2, 952 | uint256 p3 953 | ) internal view { 954 | _sendLogPayload( 955 | abi.encodeWithSignature("log(uint,uint,uint,uint)", p0, p1, p2, p3) 956 | ); 957 | } 958 | 959 | function log( 960 | uint256 p0, 961 | uint256 p1, 962 | uint256 p2, 963 | string memory p3 964 | ) internal view { 965 | _sendLogPayload( 966 | abi.encodeWithSignature( 967 | "log(uint,uint,uint,string)", 968 | p0, 969 | p1, 970 | p2, 971 | p3 972 | ) 973 | ); 974 | } 975 | 976 | function log( 977 | uint256 p0, 978 | uint256 p1, 979 | uint256 p2, 980 | bool p3 981 | ) internal view { 982 | _sendLogPayload( 983 | abi.encodeWithSignature("log(uint,uint,uint,bool)", p0, p1, p2, p3) 984 | ); 985 | } 986 | 987 | function log( 988 | uint256 p0, 989 | uint256 p1, 990 | uint256 p2, 991 | address p3 992 | ) internal view { 993 | _sendLogPayload( 994 | abi.encodeWithSignature( 995 | "log(uint,uint,uint,address)", 996 | p0, 997 | p1, 998 | p2, 999 | p3 1000 | ) 1001 | ); 1002 | } 1003 | 1004 | function log( 1005 | uint256 p0, 1006 | uint256 p1, 1007 | string memory p2, 1008 | uint256 p3 1009 | ) internal view { 1010 | _sendLogPayload( 1011 | abi.encodeWithSignature( 1012 | "log(uint,uint,string,uint)", 1013 | p0, 1014 | p1, 1015 | p2, 1016 | p3 1017 | ) 1018 | ); 1019 | } 1020 | 1021 | function log( 1022 | uint256 p0, 1023 | uint256 p1, 1024 | string memory p2, 1025 | string memory p3 1026 | ) internal view { 1027 | _sendLogPayload( 1028 | abi.encodeWithSignature( 1029 | "log(uint,uint,string,string)", 1030 | p0, 1031 | p1, 1032 | p2, 1033 | p3 1034 | ) 1035 | ); 1036 | } 1037 | 1038 | function log( 1039 | uint256 p0, 1040 | uint256 p1, 1041 | string memory p2, 1042 | bool p3 1043 | ) internal view { 1044 | _sendLogPayload( 1045 | abi.encodeWithSignature( 1046 | "log(uint,uint,string,bool)", 1047 | p0, 1048 | p1, 1049 | p2, 1050 | p3 1051 | ) 1052 | ); 1053 | } 1054 | 1055 | function log( 1056 | uint256 p0, 1057 | uint256 p1, 1058 | string memory p2, 1059 | address p3 1060 | ) internal view { 1061 | _sendLogPayload( 1062 | abi.encodeWithSignature( 1063 | "log(uint,uint,string,address)", 1064 | p0, 1065 | p1, 1066 | p2, 1067 | p3 1068 | ) 1069 | ); 1070 | } 1071 | 1072 | function log( 1073 | uint256 p0, 1074 | uint256 p1, 1075 | bool p2, 1076 | uint256 p3 1077 | ) internal view { 1078 | _sendLogPayload( 1079 | abi.encodeWithSignature("log(uint,uint,bool,uint)", p0, p1, p2, p3) 1080 | ); 1081 | } 1082 | 1083 | function log( 1084 | uint256 p0, 1085 | uint256 p1, 1086 | bool p2, 1087 | string memory p3 1088 | ) internal view { 1089 | _sendLogPayload( 1090 | abi.encodeWithSignature( 1091 | "log(uint,uint,bool,string)", 1092 | p0, 1093 | p1, 1094 | p2, 1095 | p3 1096 | ) 1097 | ); 1098 | } 1099 | 1100 | function log( 1101 | uint256 p0, 1102 | uint256 p1, 1103 | bool p2, 1104 | bool p3 1105 | ) internal view { 1106 | _sendLogPayload( 1107 | abi.encodeWithSignature("log(uint,uint,bool,bool)", p0, p1, p2, p3) 1108 | ); 1109 | } 1110 | 1111 | function log( 1112 | uint256 p0, 1113 | uint256 p1, 1114 | bool p2, 1115 | address p3 1116 | ) internal view { 1117 | _sendLogPayload( 1118 | abi.encodeWithSignature( 1119 | "log(uint,uint,bool,address)", 1120 | p0, 1121 | p1, 1122 | p2, 1123 | p3 1124 | ) 1125 | ); 1126 | } 1127 | 1128 | function log( 1129 | uint256 p0, 1130 | uint256 p1, 1131 | address p2, 1132 | uint256 p3 1133 | ) internal view { 1134 | _sendLogPayload( 1135 | abi.encodeWithSignature( 1136 | "log(uint,uint,address,uint)", 1137 | p0, 1138 | p1, 1139 | p2, 1140 | p3 1141 | ) 1142 | ); 1143 | } 1144 | 1145 | function log( 1146 | uint256 p0, 1147 | uint256 p1, 1148 | address p2, 1149 | string memory p3 1150 | ) internal view { 1151 | _sendLogPayload( 1152 | abi.encodeWithSignature( 1153 | "log(uint,uint,address,string)", 1154 | p0, 1155 | p1, 1156 | p2, 1157 | p3 1158 | ) 1159 | ); 1160 | } 1161 | 1162 | function log( 1163 | uint256 p0, 1164 | uint256 p1, 1165 | address p2, 1166 | bool p3 1167 | ) internal view { 1168 | _sendLogPayload( 1169 | abi.encodeWithSignature( 1170 | "log(uint,uint,address,bool)", 1171 | p0, 1172 | p1, 1173 | p2, 1174 | p3 1175 | ) 1176 | ); 1177 | } 1178 | 1179 | function log( 1180 | uint256 p0, 1181 | uint256 p1, 1182 | address p2, 1183 | address p3 1184 | ) internal view { 1185 | _sendLogPayload( 1186 | abi.encodeWithSignature( 1187 | "log(uint,uint,address,address)", 1188 | p0, 1189 | p1, 1190 | p2, 1191 | p3 1192 | ) 1193 | ); 1194 | } 1195 | 1196 | function log( 1197 | uint256 p0, 1198 | string memory p1, 1199 | uint256 p2, 1200 | uint256 p3 1201 | ) internal view { 1202 | _sendLogPayload( 1203 | abi.encodeWithSignature( 1204 | "log(uint,string,uint,uint)", 1205 | p0, 1206 | p1, 1207 | p2, 1208 | p3 1209 | ) 1210 | ); 1211 | } 1212 | 1213 | function log( 1214 | uint256 p0, 1215 | string memory p1, 1216 | uint256 p2, 1217 | string memory p3 1218 | ) internal view { 1219 | _sendLogPayload( 1220 | abi.encodeWithSignature( 1221 | "log(uint,string,uint,string)", 1222 | p0, 1223 | p1, 1224 | p2, 1225 | p3 1226 | ) 1227 | ); 1228 | } 1229 | 1230 | function log( 1231 | uint256 p0, 1232 | string memory p1, 1233 | uint256 p2, 1234 | bool p3 1235 | ) internal view { 1236 | _sendLogPayload( 1237 | abi.encodeWithSignature( 1238 | "log(uint,string,uint,bool)", 1239 | p0, 1240 | p1, 1241 | p2, 1242 | p3 1243 | ) 1244 | ); 1245 | } 1246 | 1247 | function log( 1248 | uint256 p0, 1249 | string memory p1, 1250 | uint256 p2, 1251 | address p3 1252 | ) internal view { 1253 | _sendLogPayload( 1254 | abi.encodeWithSignature( 1255 | "log(uint,string,uint,address)", 1256 | p0, 1257 | p1, 1258 | p2, 1259 | p3 1260 | ) 1261 | ); 1262 | } 1263 | 1264 | function log( 1265 | uint256 p0, 1266 | string memory p1, 1267 | string memory p2, 1268 | uint256 p3 1269 | ) internal view { 1270 | _sendLogPayload( 1271 | abi.encodeWithSignature( 1272 | "log(uint,string,string,uint)", 1273 | p0, 1274 | p1, 1275 | p2, 1276 | p3 1277 | ) 1278 | ); 1279 | } 1280 | 1281 | function log( 1282 | uint256 p0, 1283 | string memory p1, 1284 | string memory p2, 1285 | string memory p3 1286 | ) internal view { 1287 | _sendLogPayload( 1288 | abi.encodeWithSignature( 1289 | "log(uint,string,string,string)", 1290 | p0, 1291 | p1, 1292 | p2, 1293 | p3 1294 | ) 1295 | ); 1296 | } 1297 | 1298 | function log( 1299 | uint256 p0, 1300 | string memory p1, 1301 | string memory p2, 1302 | bool p3 1303 | ) internal view { 1304 | _sendLogPayload( 1305 | abi.encodeWithSignature( 1306 | "log(uint,string,string,bool)", 1307 | p0, 1308 | p1, 1309 | p2, 1310 | p3 1311 | ) 1312 | ); 1313 | } 1314 | 1315 | function log( 1316 | uint256 p0, 1317 | string memory p1, 1318 | string memory p2, 1319 | address p3 1320 | ) internal view { 1321 | _sendLogPayload( 1322 | abi.encodeWithSignature( 1323 | "log(uint,string,string,address)", 1324 | p0, 1325 | p1, 1326 | p2, 1327 | p3 1328 | ) 1329 | ); 1330 | } 1331 | 1332 | function log( 1333 | uint256 p0, 1334 | string memory p1, 1335 | bool p2, 1336 | uint256 p3 1337 | ) internal view { 1338 | _sendLogPayload( 1339 | abi.encodeWithSignature( 1340 | "log(uint,string,bool,uint)", 1341 | p0, 1342 | p1, 1343 | p2, 1344 | p3 1345 | ) 1346 | ); 1347 | } 1348 | 1349 | function log( 1350 | uint256 p0, 1351 | string memory p1, 1352 | bool p2, 1353 | string memory p3 1354 | ) internal view { 1355 | _sendLogPayload( 1356 | abi.encodeWithSignature( 1357 | "log(uint,string,bool,string)", 1358 | p0, 1359 | p1, 1360 | p2, 1361 | p3 1362 | ) 1363 | ); 1364 | } 1365 | 1366 | function log( 1367 | uint256 p0, 1368 | string memory p1, 1369 | bool p2, 1370 | bool p3 1371 | ) internal view { 1372 | _sendLogPayload( 1373 | abi.encodeWithSignature( 1374 | "log(uint,string,bool,bool)", 1375 | p0, 1376 | p1, 1377 | p2, 1378 | p3 1379 | ) 1380 | ); 1381 | } 1382 | 1383 | function log( 1384 | uint256 p0, 1385 | string memory p1, 1386 | bool p2, 1387 | address p3 1388 | ) internal view { 1389 | _sendLogPayload( 1390 | abi.encodeWithSignature( 1391 | "log(uint,string,bool,address)", 1392 | p0, 1393 | p1, 1394 | p2, 1395 | p3 1396 | ) 1397 | ); 1398 | } 1399 | 1400 | function log( 1401 | uint256 p0, 1402 | string memory p1, 1403 | address p2, 1404 | uint256 p3 1405 | ) internal view { 1406 | _sendLogPayload( 1407 | abi.encodeWithSignature( 1408 | "log(uint,string,address,uint)", 1409 | p0, 1410 | p1, 1411 | p2, 1412 | p3 1413 | ) 1414 | ); 1415 | } 1416 | 1417 | function log( 1418 | uint256 p0, 1419 | string memory p1, 1420 | address p2, 1421 | string memory p3 1422 | ) internal view { 1423 | _sendLogPayload( 1424 | abi.encodeWithSignature( 1425 | "log(uint,string,address,string)", 1426 | p0, 1427 | p1, 1428 | p2, 1429 | p3 1430 | ) 1431 | ); 1432 | } 1433 | 1434 | function log( 1435 | uint256 p0, 1436 | string memory p1, 1437 | address p2, 1438 | bool p3 1439 | ) internal view { 1440 | _sendLogPayload( 1441 | abi.encodeWithSignature( 1442 | "log(uint,string,address,bool)", 1443 | p0, 1444 | p1, 1445 | p2, 1446 | p3 1447 | ) 1448 | ); 1449 | } 1450 | 1451 | function log( 1452 | uint256 p0, 1453 | string memory p1, 1454 | address p2, 1455 | address p3 1456 | ) internal view { 1457 | _sendLogPayload( 1458 | abi.encodeWithSignature( 1459 | "log(uint,string,address,address)", 1460 | p0, 1461 | p1, 1462 | p2, 1463 | p3 1464 | ) 1465 | ); 1466 | } 1467 | 1468 | function log( 1469 | uint256 p0, 1470 | bool p1, 1471 | uint256 p2, 1472 | uint256 p3 1473 | ) internal view { 1474 | _sendLogPayload( 1475 | abi.encodeWithSignature("log(uint,bool,uint,uint)", p0, p1, p2, p3) 1476 | ); 1477 | } 1478 | 1479 | function log( 1480 | uint256 p0, 1481 | bool p1, 1482 | uint256 p2, 1483 | string memory p3 1484 | ) internal view { 1485 | _sendLogPayload( 1486 | abi.encodeWithSignature( 1487 | "log(uint,bool,uint,string)", 1488 | p0, 1489 | p1, 1490 | p2, 1491 | p3 1492 | ) 1493 | ); 1494 | } 1495 | 1496 | function log( 1497 | uint256 p0, 1498 | bool p1, 1499 | uint256 p2, 1500 | bool p3 1501 | ) internal view { 1502 | _sendLogPayload( 1503 | abi.encodeWithSignature("log(uint,bool,uint,bool)", p0, p1, p2, p3) 1504 | ); 1505 | } 1506 | 1507 | function log( 1508 | uint256 p0, 1509 | bool p1, 1510 | uint256 p2, 1511 | address p3 1512 | ) internal view { 1513 | _sendLogPayload( 1514 | abi.encodeWithSignature( 1515 | "log(uint,bool,uint,address)", 1516 | p0, 1517 | p1, 1518 | p2, 1519 | p3 1520 | ) 1521 | ); 1522 | } 1523 | 1524 | function log( 1525 | uint256 p0, 1526 | bool p1, 1527 | string memory p2, 1528 | uint256 p3 1529 | ) internal view { 1530 | _sendLogPayload( 1531 | abi.encodeWithSignature( 1532 | "log(uint,bool,string,uint)", 1533 | p0, 1534 | p1, 1535 | p2, 1536 | p3 1537 | ) 1538 | ); 1539 | } 1540 | 1541 | function log( 1542 | uint256 p0, 1543 | bool p1, 1544 | string memory p2, 1545 | string memory p3 1546 | ) internal view { 1547 | _sendLogPayload( 1548 | abi.encodeWithSignature( 1549 | "log(uint,bool,string,string)", 1550 | p0, 1551 | p1, 1552 | p2, 1553 | p3 1554 | ) 1555 | ); 1556 | } 1557 | 1558 | function log( 1559 | uint256 p0, 1560 | bool p1, 1561 | string memory p2, 1562 | bool p3 1563 | ) internal view { 1564 | _sendLogPayload( 1565 | abi.encodeWithSignature( 1566 | "log(uint,bool,string,bool)", 1567 | p0, 1568 | p1, 1569 | p2, 1570 | p3 1571 | ) 1572 | ); 1573 | } 1574 | 1575 | function log( 1576 | uint256 p0, 1577 | bool p1, 1578 | string memory p2, 1579 | address p3 1580 | ) internal view { 1581 | _sendLogPayload( 1582 | abi.encodeWithSignature( 1583 | "log(uint,bool,string,address)", 1584 | p0, 1585 | p1, 1586 | p2, 1587 | p3 1588 | ) 1589 | ); 1590 | } 1591 | 1592 | function log( 1593 | uint256 p0, 1594 | bool p1, 1595 | bool p2, 1596 | uint256 p3 1597 | ) internal view { 1598 | _sendLogPayload( 1599 | abi.encodeWithSignature("log(uint,bool,bool,uint)", p0, p1, p2, p3) 1600 | ); 1601 | } 1602 | 1603 | function log( 1604 | uint256 p0, 1605 | bool p1, 1606 | bool p2, 1607 | string memory p3 1608 | ) internal view { 1609 | _sendLogPayload( 1610 | abi.encodeWithSignature( 1611 | "log(uint,bool,bool,string)", 1612 | p0, 1613 | p1, 1614 | p2, 1615 | p3 1616 | ) 1617 | ); 1618 | } 1619 | 1620 | function log( 1621 | uint256 p0, 1622 | bool p1, 1623 | bool p2, 1624 | bool p3 1625 | ) internal view { 1626 | _sendLogPayload( 1627 | abi.encodeWithSignature("log(uint,bool,bool,bool)", p0, p1, p2, p3) 1628 | ); 1629 | } 1630 | 1631 | function log( 1632 | uint256 p0, 1633 | bool p1, 1634 | bool p2, 1635 | address p3 1636 | ) internal view { 1637 | _sendLogPayload( 1638 | abi.encodeWithSignature( 1639 | "log(uint,bool,bool,address)", 1640 | p0, 1641 | p1, 1642 | p2, 1643 | p3 1644 | ) 1645 | ); 1646 | } 1647 | 1648 | function log( 1649 | uint256 p0, 1650 | bool p1, 1651 | address p2, 1652 | uint256 p3 1653 | ) internal view { 1654 | _sendLogPayload( 1655 | abi.encodeWithSignature( 1656 | "log(uint,bool,address,uint)", 1657 | p0, 1658 | p1, 1659 | p2, 1660 | p3 1661 | ) 1662 | ); 1663 | } 1664 | 1665 | function log( 1666 | uint256 p0, 1667 | bool p1, 1668 | address p2, 1669 | string memory p3 1670 | ) internal view { 1671 | _sendLogPayload( 1672 | abi.encodeWithSignature( 1673 | "log(uint,bool,address,string)", 1674 | p0, 1675 | p1, 1676 | p2, 1677 | p3 1678 | ) 1679 | ); 1680 | } 1681 | 1682 | function log( 1683 | uint256 p0, 1684 | bool p1, 1685 | address p2, 1686 | bool p3 1687 | ) internal view { 1688 | _sendLogPayload( 1689 | abi.encodeWithSignature( 1690 | "log(uint,bool,address,bool)", 1691 | p0, 1692 | p1, 1693 | p2, 1694 | p3 1695 | ) 1696 | ); 1697 | } 1698 | 1699 | function log( 1700 | uint256 p0, 1701 | bool p1, 1702 | address p2, 1703 | address p3 1704 | ) internal view { 1705 | _sendLogPayload( 1706 | abi.encodeWithSignature( 1707 | "log(uint,bool,address,address)", 1708 | p0, 1709 | p1, 1710 | p2, 1711 | p3 1712 | ) 1713 | ); 1714 | } 1715 | 1716 | function log( 1717 | uint256 p0, 1718 | address p1, 1719 | uint256 p2, 1720 | uint256 p3 1721 | ) internal view { 1722 | _sendLogPayload( 1723 | abi.encodeWithSignature( 1724 | "log(uint,address,uint,uint)", 1725 | p0, 1726 | p1, 1727 | p2, 1728 | p3 1729 | ) 1730 | ); 1731 | } 1732 | 1733 | function log( 1734 | uint256 p0, 1735 | address p1, 1736 | uint256 p2, 1737 | string memory p3 1738 | ) internal view { 1739 | _sendLogPayload( 1740 | abi.encodeWithSignature( 1741 | "log(uint,address,uint,string)", 1742 | p0, 1743 | p1, 1744 | p2, 1745 | p3 1746 | ) 1747 | ); 1748 | } 1749 | 1750 | function log( 1751 | uint256 p0, 1752 | address p1, 1753 | uint256 p2, 1754 | bool p3 1755 | ) internal view { 1756 | _sendLogPayload( 1757 | abi.encodeWithSignature( 1758 | "log(uint,address,uint,bool)", 1759 | p0, 1760 | p1, 1761 | p2, 1762 | p3 1763 | ) 1764 | ); 1765 | } 1766 | 1767 | function log( 1768 | uint256 p0, 1769 | address p1, 1770 | uint256 p2, 1771 | address p3 1772 | ) internal view { 1773 | _sendLogPayload( 1774 | abi.encodeWithSignature( 1775 | "log(uint,address,uint,address)", 1776 | p0, 1777 | p1, 1778 | p2, 1779 | p3 1780 | ) 1781 | ); 1782 | } 1783 | 1784 | function log( 1785 | uint256 p0, 1786 | address p1, 1787 | string memory p2, 1788 | uint256 p3 1789 | ) internal view { 1790 | _sendLogPayload( 1791 | abi.encodeWithSignature( 1792 | "log(uint,address,string,uint)", 1793 | p0, 1794 | p1, 1795 | p2, 1796 | p3 1797 | ) 1798 | ); 1799 | } 1800 | 1801 | function log( 1802 | uint256 p0, 1803 | address p1, 1804 | string memory p2, 1805 | string memory p3 1806 | ) internal view { 1807 | _sendLogPayload( 1808 | abi.encodeWithSignature( 1809 | "log(uint,address,string,string)", 1810 | p0, 1811 | p1, 1812 | p2, 1813 | p3 1814 | ) 1815 | ); 1816 | } 1817 | 1818 | function log( 1819 | uint256 p0, 1820 | address p1, 1821 | string memory p2, 1822 | bool p3 1823 | ) internal view { 1824 | _sendLogPayload( 1825 | abi.encodeWithSignature( 1826 | "log(uint,address,string,bool)", 1827 | p0, 1828 | p1, 1829 | p2, 1830 | p3 1831 | ) 1832 | ); 1833 | } 1834 | 1835 | function log( 1836 | uint256 p0, 1837 | address p1, 1838 | string memory p2, 1839 | address p3 1840 | ) internal view { 1841 | _sendLogPayload( 1842 | abi.encodeWithSignature( 1843 | "log(uint,address,string,address)", 1844 | p0, 1845 | p1, 1846 | p2, 1847 | p3 1848 | ) 1849 | ); 1850 | } 1851 | 1852 | function log( 1853 | uint256 p0, 1854 | address p1, 1855 | bool p2, 1856 | uint256 p3 1857 | ) internal view { 1858 | _sendLogPayload( 1859 | abi.encodeWithSignature( 1860 | "log(uint,address,bool,uint)", 1861 | p0, 1862 | p1, 1863 | p2, 1864 | p3 1865 | ) 1866 | ); 1867 | } 1868 | 1869 | function log( 1870 | uint256 p0, 1871 | address p1, 1872 | bool p2, 1873 | string memory p3 1874 | ) internal view { 1875 | _sendLogPayload( 1876 | abi.encodeWithSignature( 1877 | "log(uint,address,bool,string)", 1878 | p0, 1879 | p1, 1880 | p2, 1881 | p3 1882 | ) 1883 | ); 1884 | } 1885 | 1886 | function log( 1887 | uint256 p0, 1888 | address p1, 1889 | bool p2, 1890 | bool p3 1891 | ) internal view { 1892 | _sendLogPayload( 1893 | abi.encodeWithSignature( 1894 | "log(uint,address,bool,bool)", 1895 | p0, 1896 | p1, 1897 | p2, 1898 | p3 1899 | ) 1900 | ); 1901 | } 1902 | 1903 | function log( 1904 | uint256 p0, 1905 | address p1, 1906 | bool p2, 1907 | address p3 1908 | ) internal view { 1909 | _sendLogPayload( 1910 | abi.encodeWithSignature( 1911 | "log(uint,address,bool,address)", 1912 | p0, 1913 | p1, 1914 | p2, 1915 | p3 1916 | ) 1917 | ); 1918 | } 1919 | 1920 | function log( 1921 | uint256 p0, 1922 | address p1, 1923 | address p2, 1924 | uint256 p3 1925 | ) internal view { 1926 | _sendLogPayload( 1927 | abi.encodeWithSignature( 1928 | "log(uint,address,address,uint)", 1929 | p0, 1930 | p1, 1931 | p2, 1932 | p3 1933 | ) 1934 | ); 1935 | } 1936 | 1937 | function log( 1938 | uint256 p0, 1939 | address p1, 1940 | address p2, 1941 | string memory p3 1942 | ) internal view { 1943 | _sendLogPayload( 1944 | abi.encodeWithSignature( 1945 | "log(uint,address,address,string)", 1946 | p0, 1947 | p1, 1948 | p2, 1949 | p3 1950 | ) 1951 | ); 1952 | } 1953 | 1954 | function log( 1955 | uint256 p0, 1956 | address p1, 1957 | address p2, 1958 | bool p3 1959 | ) internal view { 1960 | _sendLogPayload( 1961 | abi.encodeWithSignature( 1962 | "log(uint,address,address,bool)", 1963 | p0, 1964 | p1, 1965 | p2, 1966 | p3 1967 | ) 1968 | ); 1969 | } 1970 | 1971 | function log( 1972 | uint256 p0, 1973 | address p1, 1974 | address p2, 1975 | address p3 1976 | ) internal view { 1977 | _sendLogPayload( 1978 | abi.encodeWithSignature( 1979 | "log(uint,address,address,address)", 1980 | p0, 1981 | p1, 1982 | p2, 1983 | p3 1984 | ) 1985 | ); 1986 | } 1987 | 1988 | function log( 1989 | string memory p0, 1990 | uint256 p1, 1991 | uint256 p2, 1992 | uint256 p3 1993 | ) internal view { 1994 | _sendLogPayload( 1995 | abi.encodeWithSignature( 1996 | "log(string,uint,uint,uint)", 1997 | p0, 1998 | p1, 1999 | p2, 2000 | p3 2001 | ) 2002 | ); 2003 | } 2004 | 2005 | function log( 2006 | string memory p0, 2007 | uint256 p1, 2008 | uint256 p2, 2009 | string memory p3 2010 | ) internal view { 2011 | _sendLogPayload( 2012 | abi.encodeWithSignature( 2013 | "log(string,uint,uint,string)", 2014 | p0, 2015 | p1, 2016 | p2, 2017 | p3 2018 | ) 2019 | ); 2020 | } 2021 | 2022 | function log( 2023 | string memory p0, 2024 | uint256 p1, 2025 | uint256 p2, 2026 | bool p3 2027 | ) internal view { 2028 | _sendLogPayload( 2029 | abi.encodeWithSignature( 2030 | "log(string,uint,uint,bool)", 2031 | p0, 2032 | p1, 2033 | p2, 2034 | p3 2035 | ) 2036 | ); 2037 | } 2038 | 2039 | function log( 2040 | string memory p0, 2041 | uint256 p1, 2042 | uint256 p2, 2043 | address p3 2044 | ) internal view { 2045 | _sendLogPayload( 2046 | abi.encodeWithSignature( 2047 | "log(string,uint,uint,address)", 2048 | p0, 2049 | p1, 2050 | p2, 2051 | p3 2052 | ) 2053 | ); 2054 | } 2055 | 2056 | function log( 2057 | string memory p0, 2058 | uint256 p1, 2059 | string memory p2, 2060 | uint256 p3 2061 | ) internal view { 2062 | _sendLogPayload( 2063 | abi.encodeWithSignature( 2064 | "log(string,uint,string,uint)", 2065 | p0, 2066 | p1, 2067 | p2, 2068 | p3 2069 | ) 2070 | ); 2071 | } 2072 | 2073 | function log( 2074 | string memory p0, 2075 | uint256 p1, 2076 | string memory p2, 2077 | string memory p3 2078 | ) internal view { 2079 | _sendLogPayload( 2080 | abi.encodeWithSignature( 2081 | "log(string,uint,string,string)", 2082 | p0, 2083 | p1, 2084 | p2, 2085 | p3 2086 | ) 2087 | ); 2088 | } 2089 | 2090 | function log( 2091 | string memory p0, 2092 | uint256 p1, 2093 | string memory p2, 2094 | bool p3 2095 | ) internal view { 2096 | _sendLogPayload( 2097 | abi.encodeWithSignature( 2098 | "log(string,uint,string,bool)", 2099 | p0, 2100 | p1, 2101 | p2, 2102 | p3 2103 | ) 2104 | ); 2105 | } 2106 | 2107 | function log( 2108 | string memory p0, 2109 | uint256 p1, 2110 | string memory p2, 2111 | address p3 2112 | ) internal view { 2113 | _sendLogPayload( 2114 | abi.encodeWithSignature( 2115 | "log(string,uint,string,address)", 2116 | p0, 2117 | p1, 2118 | p2, 2119 | p3 2120 | ) 2121 | ); 2122 | } 2123 | 2124 | function log( 2125 | string memory p0, 2126 | uint256 p1, 2127 | bool p2, 2128 | uint256 p3 2129 | ) internal view { 2130 | _sendLogPayload( 2131 | abi.encodeWithSignature( 2132 | "log(string,uint,bool,uint)", 2133 | p0, 2134 | p1, 2135 | p2, 2136 | p3 2137 | ) 2138 | ); 2139 | } 2140 | 2141 | function log( 2142 | string memory p0, 2143 | uint256 p1, 2144 | bool p2, 2145 | string memory p3 2146 | ) internal view { 2147 | _sendLogPayload( 2148 | abi.encodeWithSignature( 2149 | "log(string,uint,bool,string)", 2150 | p0, 2151 | p1, 2152 | p2, 2153 | p3 2154 | ) 2155 | ); 2156 | } 2157 | 2158 | function log( 2159 | string memory p0, 2160 | uint256 p1, 2161 | bool p2, 2162 | bool p3 2163 | ) internal view { 2164 | _sendLogPayload( 2165 | abi.encodeWithSignature( 2166 | "log(string,uint,bool,bool)", 2167 | p0, 2168 | p1, 2169 | p2, 2170 | p3 2171 | ) 2172 | ); 2173 | } 2174 | 2175 | function log( 2176 | string memory p0, 2177 | uint256 p1, 2178 | bool p2, 2179 | address p3 2180 | ) internal view { 2181 | _sendLogPayload( 2182 | abi.encodeWithSignature( 2183 | "log(string,uint,bool,address)", 2184 | p0, 2185 | p1, 2186 | p2, 2187 | p3 2188 | ) 2189 | ); 2190 | } 2191 | 2192 | function log( 2193 | string memory p0, 2194 | uint256 p1, 2195 | address p2, 2196 | uint256 p3 2197 | ) internal view { 2198 | _sendLogPayload( 2199 | abi.encodeWithSignature( 2200 | "log(string,uint,address,uint)", 2201 | p0, 2202 | p1, 2203 | p2, 2204 | p3 2205 | ) 2206 | ); 2207 | } 2208 | 2209 | function log( 2210 | string memory p0, 2211 | uint256 p1, 2212 | address p2, 2213 | string memory p3 2214 | ) internal view { 2215 | _sendLogPayload( 2216 | abi.encodeWithSignature( 2217 | "log(string,uint,address,string)", 2218 | p0, 2219 | p1, 2220 | p2, 2221 | p3 2222 | ) 2223 | ); 2224 | } 2225 | 2226 | function log( 2227 | string memory p0, 2228 | uint256 p1, 2229 | address p2, 2230 | bool p3 2231 | ) internal view { 2232 | _sendLogPayload( 2233 | abi.encodeWithSignature( 2234 | "log(string,uint,address,bool)", 2235 | p0, 2236 | p1, 2237 | p2, 2238 | p3 2239 | ) 2240 | ); 2241 | } 2242 | 2243 | function log( 2244 | string memory p0, 2245 | uint256 p1, 2246 | address p2, 2247 | address p3 2248 | ) internal view { 2249 | _sendLogPayload( 2250 | abi.encodeWithSignature( 2251 | "log(string,uint,address,address)", 2252 | p0, 2253 | p1, 2254 | p2, 2255 | p3 2256 | ) 2257 | ); 2258 | } 2259 | 2260 | function log( 2261 | string memory p0, 2262 | string memory p1, 2263 | uint256 p2, 2264 | uint256 p3 2265 | ) internal view { 2266 | _sendLogPayload( 2267 | abi.encodeWithSignature( 2268 | "log(string,string,uint,uint)", 2269 | p0, 2270 | p1, 2271 | p2, 2272 | p3 2273 | ) 2274 | ); 2275 | } 2276 | 2277 | function log( 2278 | string memory p0, 2279 | string memory p1, 2280 | uint256 p2, 2281 | string memory p3 2282 | ) internal view { 2283 | _sendLogPayload( 2284 | abi.encodeWithSignature( 2285 | "log(string,string,uint,string)", 2286 | p0, 2287 | p1, 2288 | p2, 2289 | p3 2290 | ) 2291 | ); 2292 | } 2293 | 2294 | function log( 2295 | string memory p0, 2296 | string memory p1, 2297 | uint256 p2, 2298 | bool p3 2299 | ) internal view { 2300 | _sendLogPayload( 2301 | abi.encodeWithSignature( 2302 | "log(string,string,uint,bool)", 2303 | p0, 2304 | p1, 2305 | p2, 2306 | p3 2307 | ) 2308 | ); 2309 | } 2310 | 2311 | function log( 2312 | string memory p0, 2313 | string memory p1, 2314 | uint256 p2, 2315 | address p3 2316 | ) internal view { 2317 | _sendLogPayload( 2318 | abi.encodeWithSignature( 2319 | "log(string,string,uint,address)", 2320 | p0, 2321 | p1, 2322 | p2, 2323 | p3 2324 | ) 2325 | ); 2326 | } 2327 | 2328 | function log( 2329 | string memory p0, 2330 | string memory p1, 2331 | string memory p2, 2332 | uint256 p3 2333 | ) internal view { 2334 | _sendLogPayload( 2335 | abi.encodeWithSignature( 2336 | "log(string,string,string,uint)", 2337 | p0, 2338 | p1, 2339 | p2, 2340 | p3 2341 | ) 2342 | ); 2343 | } 2344 | 2345 | function log( 2346 | string memory p0, 2347 | string memory p1, 2348 | string memory p2, 2349 | string memory p3 2350 | ) internal view { 2351 | _sendLogPayload( 2352 | abi.encodeWithSignature( 2353 | "log(string,string,string,string)", 2354 | p0, 2355 | p1, 2356 | p2, 2357 | p3 2358 | ) 2359 | ); 2360 | } 2361 | 2362 | function log( 2363 | string memory p0, 2364 | string memory p1, 2365 | string memory p2, 2366 | bool p3 2367 | ) internal view { 2368 | _sendLogPayload( 2369 | abi.encodeWithSignature( 2370 | "log(string,string,string,bool)", 2371 | p0, 2372 | p1, 2373 | p2, 2374 | p3 2375 | ) 2376 | ); 2377 | } 2378 | 2379 | function log( 2380 | string memory p0, 2381 | string memory p1, 2382 | string memory p2, 2383 | address p3 2384 | ) internal view { 2385 | _sendLogPayload( 2386 | abi.encodeWithSignature( 2387 | "log(string,string,string,address)", 2388 | p0, 2389 | p1, 2390 | p2, 2391 | p3 2392 | ) 2393 | ); 2394 | } 2395 | 2396 | function log( 2397 | string memory p0, 2398 | string memory p1, 2399 | bool p2, 2400 | uint256 p3 2401 | ) internal view { 2402 | _sendLogPayload( 2403 | abi.encodeWithSignature( 2404 | "log(string,string,bool,uint)", 2405 | p0, 2406 | p1, 2407 | p2, 2408 | p3 2409 | ) 2410 | ); 2411 | } 2412 | 2413 | function log( 2414 | string memory p0, 2415 | string memory p1, 2416 | bool p2, 2417 | string memory p3 2418 | ) internal view { 2419 | _sendLogPayload( 2420 | abi.encodeWithSignature( 2421 | "log(string,string,bool,string)", 2422 | p0, 2423 | p1, 2424 | p2, 2425 | p3 2426 | ) 2427 | ); 2428 | } 2429 | 2430 | function log( 2431 | string memory p0, 2432 | string memory p1, 2433 | bool p2, 2434 | bool p3 2435 | ) internal view { 2436 | _sendLogPayload( 2437 | abi.encodeWithSignature( 2438 | "log(string,string,bool,bool)", 2439 | p0, 2440 | p1, 2441 | p2, 2442 | p3 2443 | ) 2444 | ); 2445 | } 2446 | 2447 | function log( 2448 | string memory p0, 2449 | string memory p1, 2450 | bool p2, 2451 | address p3 2452 | ) internal view { 2453 | _sendLogPayload( 2454 | abi.encodeWithSignature( 2455 | "log(string,string,bool,address)", 2456 | p0, 2457 | p1, 2458 | p2, 2459 | p3 2460 | ) 2461 | ); 2462 | } 2463 | 2464 | function log( 2465 | string memory p0, 2466 | string memory p1, 2467 | address p2, 2468 | uint256 p3 2469 | ) internal view { 2470 | _sendLogPayload( 2471 | abi.encodeWithSignature( 2472 | "log(string,string,address,uint)", 2473 | p0, 2474 | p1, 2475 | p2, 2476 | p3 2477 | ) 2478 | ); 2479 | } 2480 | 2481 | function log( 2482 | string memory p0, 2483 | string memory p1, 2484 | address p2, 2485 | string memory p3 2486 | ) internal view { 2487 | _sendLogPayload( 2488 | abi.encodeWithSignature( 2489 | "log(string,string,address,string)", 2490 | p0, 2491 | p1, 2492 | p2, 2493 | p3 2494 | ) 2495 | ); 2496 | } 2497 | 2498 | function log( 2499 | string memory p0, 2500 | string memory p1, 2501 | address p2, 2502 | bool p3 2503 | ) internal view { 2504 | _sendLogPayload( 2505 | abi.encodeWithSignature( 2506 | "log(string,string,address,bool)", 2507 | p0, 2508 | p1, 2509 | p2, 2510 | p3 2511 | ) 2512 | ); 2513 | } 2514 | 2515 | function log( 2516 | string memory p0, 2517 | string memory p1, 2518 | address p2, 2519 | address p3 2520 | ) internal view { 2521 | _sendLogPayload( 2522 | abi.encodeWithSignature( 2523 | "log(string,string,address,address)", 2524 | p0, 2525 | p1, 2526 | p2, 2527 | p3 2528 | ) 2529 | ); 2530 | } 2531 | 2532 | function log( 2533 | string memory p0, 2534 | bool p1, 2535 | uint256 p2, 2536 | uint256 p3 2537 | ) internal view { 2538 | _sendLogPayload( 2539 | abi.encodeWithSignature( 2540 | "log(string,bool,uint,uint)", 2541 | p0, 2542 | p1, 2543 | p2, 2544 | p3 2545 | ) 2546 | ); 2547 | } 2548 | 2549 | function log( 2550 | string memory p0, 2551 | bool p1, 2552 | uint256 p2, 2553 | string memory p3 2554 | ) internal view { 2555 | _sendLogPayload( 2556 | abi.encodeWithSignature( 2557 | "log(string,bool,uint,string)", 2558 | p0, 2559 | p1, 2560 | p2, 2561 | p3 2562 | ) 2563 | ); 2564 | } 2565 | 2566 | function log( 2567 | string memory p0, 2568 | bool p1, 2569 | uint256 p2, 2570 | bool p3 2571 | ) internal view { 2572 | _sendLogPayload( 2573 | abi.encodeWithSignature( 2574 | "log(string,bool,uint,bool)", 2575 | p0, 2576 | p1, 2577 | p2, 2578 | p3 2579 | ) 2580 | ); 2581 | } 2582 | 2583 | function log( 2584 | string memory p0, 2585 | bool p1, 2586 | uint256 p2, 2587 | address p3 2588 | ) internal view { 2589 | _sendLogPayload( 2590 | abi.encodeWithSignature( 2591 | "log(string,bool,uint,address)", 2592 | p0, 2593 | p1, 2594 | p2, 2595 | p3 2596 | ) 2597 | ); 2598 | } 2599 | 2600 | function log( 2601 | string memory p0, 2602 | bool p1, 2603 | string memory p2, 2604 | uint256 p3 2605 | ) internal view { 2606 | _sendLogPayload( 2607 | abi.encodeWithSignature( 2608 | "log(string,bool,string,uint)", 2609 | p0, 2610 | p1, 2611 | p2, 2612 | p3 2613 | ) 2614 | ); 2615 | } 2616 | 2617 | function log( 2618 | string memory p0, 2619 | bool p1, 2620 | string memory p2, 2621 | string memory p3 2622 | ) internal view { 2623 | _sendLogPayload( 2624 | abi.encodeWithSignature( 2625 | "log(string,bool,string,string)", 2626 | p0, 2627 | p1, 2628 | p2, 2629 | p3 2630 | ) 2631 | ); 2632 | } 2633 | 2634 | function log( 2635 | string memory p0, 2636 | bool p1, 2637 | string memory p2, 2638 | bool p3 2639 | ) internal view { 2640 | _sendLogPayload( 2641 | abi.encodeWithSignature( 2642 | "log(string,bool,string,bool)", 2643 | p0, 2644 | p1, 2645 | p2, 2646 | p3 2647 | ) 2648 | ); 2649 | } 2650 | 2651 | function log( 2652 | string memory p0, 2653 | bool p1, 2654 | string memory p2, 2655 | address p3 2656 | ) internal view { 2657 | _sendLogPayload( 2658 | abi.encodeWithSignature( 2659 | "log(string,bool,string,address)", 2660 | p0, 2661 | p1, 2662 | p2, 2663 | p3 2664 | ) 2665 | ); 2666 | } 2667 | 2668 | function log( 2669 | string memory p0, 2670 | bool p1, 2671 | bool p2, 2672 | uint256 p3 2673 | ) internal view { 2674 | _sendLogPayload( 2675 | abi.encodeWithSignature( 2676 | "log(string,bool,bool,uint)", 2677 | p0, 2678 | p1, 2679 | p2, 2680 | p3 2681 | ) 2682 | ); 2683 | } 2684 | 2685 | function log( 2686 | string memory p0, 2687 | bool p1, 2688 | bool p2, 2689 | string memory p3 2690 | ) internal view { 2691 | _sendLogPayload( 2692 | abi.encodeWithSignature( 2693 | "log(string,bool,bool,string)", 2694 | p0, 2695 | p1, 2696 | p2, 2697 | p3 2698 | ) 2699 | ); 2700 | } 2701 | 2702 | function log( 2703 | string memory p0, 2704 | bool p1, 2705 | bool p2, 2706 | bool p3 2707 | ) internal view { 2708 | _sendLogPayload( 2709 | abi.encodeWithSignature( 2710 | "log(string,bool,bool,bool)", 2711 | p0, 2712 | p1, 2713 | p2, 2714 | p3 2715 | ) 2716 | ); 2717 | } 2718 | 2719 | function log( 2720 | string memory p0, 2721 | bool p1, 2722 | bool p2, 2723 | address p3 2724 | ) internal view { 2725 | _sendLogPayload( 2726 | abi.encodeWithSignature( 2727 | "log(string,bool,bool,address)", 2728 | p0, 2729 | p1, 2730 | p2, 2731 | p3 2732 | ) 2733 | ); 2734 | } 2735 | 2736 | function log( 2737 | string memory p0, 2738 | bool p1, 2739 | address p2, 2740 | uint256 p3 2741 | ) internal view { 2742 | _sendLogPayload( 2743 | abi.encodeWithSignature( 2744 | "log(string,bool,address,uint)", 2745 | p0, 2746 | p1, 2747 | p2, 2748 | p3 2749 | ) 2750 | ); 2751 | } 2752 | 2753 | function log( 2754 | string memory p0, 2755 | bool p1, 2756 | address p2, 2757 | string memory p3 2758 | ) internal view { 2759 | _sendLogPayload( 2760 | abi.encodeWithSignature( 2761 | "log(string,bool,address,string)", 2762 | p0, 2763 | p1, 2764 | p2, 2765 | p3 2766 | ) 2767 | ); 2768 | } 2769 | 2770 | function log( 2771 | string memory p0, 2772 | bool p1, 2773 | address p2, 2774 | bool p3 2775 | ) internal view { 2776 | _sendLogPayload( 2777 | abi.encodeWithSignature( 2778 | "log(string,bool,address,bool)", 2779 | p0, 2780 | p1, 2781 | p2, 2782 | p3 2783 | ) 2784 | ); 2785 | } 2786 | 2787 | function log( 2788 | string memory p0, 2789 | bool p1, 2790 | address p2, 2791 | address p3 2792 | ) internal view { 2793 | _sendLogPayload( 2794 | abi.encodeWithSignature( 2795 | "log(string,bool,address,address)", 2796 | p0, 2797 | p1, 2798 | p2, 2799 | p3 2800 | ) 2801 | ); 2802 | } 2803 | 2804 | function log( 2805 | string memory p0, 2806 | address p1, 2807 | uint256 p2, 2808 | uint256 p3 2809 | ) internal view { 2810 | _sendLogPayload( 2811 | abi.encodeWithSignature( 2812 | "log(string,address,uint,uint)", 2813 | p0, 2814 | p1, 2815 | p2, 2816 | p3 2817 | ) 2818 | ); 2819 | } 2820 | 2821 | function log( 2822 | string memory p0, 2823 | address p1, 2824 | uint256 p2, 2825 | string memory p3 2826 | ) internal view { 2827 | _sendLogPayload( 2828 | abi.encodeWithSignature( 2829 | "log(string,address,uint,string)", 2830 | p0, 2831 | p1, 2832 | p2, 2833 | p3 2834 | ) 2835 | ); 2836 | } 2837 | 2838 | function log( 2839 | string memory p0, 2840 | address p1, 2841 | uint256 p2, 2842 | bool p3 2843 | ) internal view { 2844 | _sendLogPayload( 2845 | abi.encodeWithSignature( 2846 | "log(string,address,uint,bool)", 2847 | p0, 2848 | p1, 2849 | p2, 2850 | p3 2851 | ) 2852 | ); 2853 | } 2854 | 2855 | function log( 2856 | string memory p0, 2857 | address p1, 2858 | uint256 p2, 2859 | address p3 2860 | ) internal view { 2861 | _sendLogPayload( 2862 | abi.encodeWithSignature( 2863 | "log(string,address,uint,address)", 2864 | p0, 2865 | p1, 2866 | p2, 2867 | p3 2868 | ) 2869 | ); 2870 | } 2871 | 2872 | function log( 2873 | string memory p0, 2874 | address p1, 2875 | string memory p2, 2876 | uint256 p3 2877 | ) internal view { 2878 | _sendLogPayload( 2879 | abi.encodeWithSignature( 2880 | "log(string,address,string,uint)", 2881 | p0, 2882 | p1, 2883 | p2, 2884 | p3 2885 | ) 2886 | ); 2887 | } 2888 | 2889 | function log( 2890 | string memory p0, 2891 | address p1, 2892 | string memory p2, 2893 | string memory p3 2894 | ) internal view { 2895 | _sendLogPayload( 2896 | abi.encodeWithSignature( 2897 | "log(string,address,string,string)", 2898 | p0, 2899 | p1, 2900 | p2, 2901 | p3 2902 | ) 2903 | ); 2904 | } 2905 | 2906 | function log( 2907 | string memory p0, 2908 | address p1, 2909 | string memory p2, 2910 | bool p3 2911 | ) internal view { 2912 | _sendLogPayload( 2913 | abi.encodeWithSignature( 2914 | "log(string,address,string,bool)", 2915 | p0, 2916 | p1, 2917 | p2, 2918 | p3 2919 | ) 2920 | ); 2921 | } 2922 | 2923 | function log( 2924 | string memory p0, 2925 | address p1, 2926 | string memory p2, 2927 | address p3 2928 | ) internal view { 2929 | _sendLogPayload( 2930 | abi.encodeWithSignature( 2931 | "log(string,address,string,address)", 2932 | p0, 2933 | p1, 2934 | p2, 2935 | p3 2936 | ) 2937 | ); 2938 | } 2939 | 2940 | function log( 2941 | string memory p0, 2942 | address p1, 2943 | bool p2, 2944 | uint256 p3 2945 | ) internal view { 2946 | _sendLogPayload( 2947 | abi.encodeWithSignature( 2948 | "log(string,address,bool,uint)", 2949 | p0, 2950 | p1, 2951 | p2, 2952 | p3 2953 | ) 2954 | ); 2955 | } 2956 | 2957 | function log( 2958 | string memory p0, 2959 | address p1, 2960 | bool p2, 2961 | string memory p3 2962 | ) internal view { 2963 | _sendLogPayload( 2964 | abi.encodeWithSignature( 2965 | "log(string,address,bool,string)", 2966 | p0, 2967 | p1, 2968 | p2, 2969 | p3 2970 | ) 2971 | ); 2972 | } 2973 | 2974 | function log( 2975 | string memory p0, 2976 | address p1, 2977 | bool p2, 2978 | bool p3 2979 | ) internal view { 2980 | _sendLogPayload( 2981 | abi.encodeWithSignature( 2982 | "log(string,address,bool,bool)", 2983 | p0, 2984 | p1, 2985 | p2, 2986 | p3 2987 | ) 2988 | ); 2989 | } 2990 | 2991 | function log( 2992 | string memory p0, 2993 | address p1, 2994 | bool p2, 2995 | address p3 2996 | ) internal view { 2997 | _sendLogPayload( 2998 | abi.encodeWithSignature( 2999 | "log(string,address,bool,address)", 3000 | p0, 3001 | p1, 3002 | p2, 3003 | p3 3004 | ) 3005 | ); 3006 | } 3007 | 3008 | function log( 3009 | string memory p0, 3010 | address p1, 3011 | address p2, 3012 | uint256 p3 3013 | ) internal view { 3014 | _sendLogPayload( 3015 | abi.encodeWithSignature( 3016 | "log(string,address,address,uint)", 3017 | p0, 3018 | p1, 3019 | p2, 3020 | p3 3021 | ) 3022 | ); 3023 | } 3024 | 3025 | function log( 3026 | string memory p0, 3027 | address p1, 3028 | address p2, 3029 | string memory p3 3030 | ) internal view { 3031 | _sendLogPayload( 3032 | abi.encodeWithSignature( 3033 | "log(string,address,address,string)", 3034 | p0, 3035 | p1, 3036 | p2, 3037 | p3 3038 | ) 3039 | ); 3040 | } 3041 | 3042 | function log( 3043 | string memory p0, 3044 | address p1, 3045 | address p2, 3046 | bool p3 3047 | ) internal view { 3048 | _sendLogPayload( 3049 | abi.encodeWithSignature( 3050 | "log(string,address,address,bool)", 3051 | p0, 3052 | p1, 3053 | p2, 3054 | p3 3055 | ) 3056 | ); 3057 | } 3058 | 3059 | function log( 3060 | string memory p0, 3061 | address p1, 3062 | address p2, 3063 | address p3 3064 | ) internal view { 3065 | _sendLogPayload( 3066 | abi.encodeWithSignature( 3067 | "log(string,address,address,address)", 3068 | p0, 3069 | p1, 3070 | p2, 3071 | p3 3072 | ) 3073 | ); 3074 | } 3075 | 3076 | function log( 3077 | bool p0, 3078 | uint256 p1, 3079 | uint256 p2, 3080 | uint256 p3 3081 | ) internal view { 3082 | _sendLogPayload( 3083 | abi.encodeWithSignature("log(bool,uint,uint,uint)", p0, p1, p2, p3) 3084 | ); 3085 | } 3086 | 3087 | function log( 3088 | bool p0, 3089 | uint256 p1, 3090 | uint256 p2, 3091 | string memory p3 3092 | ) internal view { 3093 | _sendLogPayload( 3094 | abi.encodeWithSignature( 3095 | "log(bool,uint,uint,string)", 3096 | p0, 3097 | p1, 3098 | p2, 3099 | p3 3100 | ) 3101 | ); 3102 | } 3103 | 3104 | function log( 3105 | bool p0, 3106 | uint256 p1, 3107 | uint256 p2, 3108 | bool p3 3109 | ) internal view { 3110 | _sendLogPayload( 3111 | abi.encodeWithSignature("log(bool,uint,uint,bool)", p0, p1, p2, p3) 3112 | ); 3113 | } 3114 | 3115 | function log( 3116 | bool p0, 3117 | uint256 p1, 3118 | uint256 p2, 3119 | address p3 3120 | ) internal view { 3121 | _sendLogPayload( 3122 | abi.encodeWithSignature( 3123 | "log(bool,uint,uint,address)", 3124 | p0, 3125 | p1, 3126 | p2, 3127 | p3 3128 | ) 3129 | ); 3130 | } 3131 | 3132 | function log( 3133 | bool p0, 3134 | uint256 p1, 3135 | string memory p2, 3136 | uint256 p3 3137 | ) internal view { 3138 | _sendLogPayload( 3139 | abi.encodeWithSignature( 3140 | "log(bool,uint,string,uint)", 3141 | p0, 3142 | p1, 3143 | p2, 3144 | p3 3145 | ) 3146 | ); 3147 | } 3148 | 3149 | function log( 3150 | bool p0, 3151 | uint256 p1, 3152 | string memory p2, 3153 | string memory p3 3154 | ) internal view { 3155 | _sendLogPayload( 3156 | abi.encodeWithSignature( 3157 | "log(bool,uint,string,string)", 3158 | p0, 3159 | p1, 3160 | p2, 3161 | p3 3162 | ) 3163 | ); 3164 | } 3165 | 3166 | function log( 3167 | bool p0, 3168 | uint256 p1, 3169 | string memory p2, 3170 | bool p3 3171 | ) internal view { 3172 | _sendLogPayload( 3173 | abi.encodeWithSignature( 3174 | "log(bool,uint,string,bool)", 3175 | p0, 3176 | p1, 3177 | p2, 3178 | p3 3179 | ) 3180 | ); 3181 | } 3182 | 3183 | function log( 3184 | bool p0, 3185 | uint256 p1, 3186 | string memory p2, 3187 | address p3 3188 | ) internal view { 3189 | _sendLogPayload( 3190 | abi.encodeWithSignature( 3191 | "log(bool,uint,string,address)", 3192 | p0, 3193 | p1, 3194 | p2, 3195 | p3 3196 | ) 3197 | ); 3198 | } 3199 | 3200 | function log( 3201 | bool p0, 3202 | uint256 p1, 3203 | bool p2, 3204 | uint256 p3 3205 | ) internal view { 3206 | _sendLogPayload( 3207 | abi.encodeWithSignature("log(bool,uint,bool,uint)", p0, p1, p2, p3) 3208 | ); 3209 | } 3210 | 3211 | function log( 3212 | bool p0, 3213 | uint256 p1, 3214 | bool p2, 3215 | string memory p3 3216 | ) internal view { 3217 | _sendLogPayload( 3218 | abi.encodeWithSignature( 3219 | "log(bool,uint,bool,string)", 3220 | p0, 3221 | p1, 3222 | p2, 3223 | p3 3224 | ) 3225 | ); 3226 | } 3227 | 3228 | function log( 3229 | bool p0, 3230 | uint256 p1, 3231 | bool p2, 3232 | bool p3 3233 | ) internal view { 3234 | _sendLogPayload( 3235 | abi.encodeWithSignature("log(bool,uint,bool,bool)", p0, p1, p2, p3) 3236 | ); 3237 | } 3238 | 3239 | function log( 3240 | bool p0, 3241 | uint256 p1, 3242 | bool p2, 3243 | address p3 3244 | ) internal view { 3245 | _sendLogPayload( 3246 | abi.encodeWithSignature( 3247 | "log(bool,uint,bool,address)", 3248 | p0, 3249 | p1, 3250 | p2, 3251 | p3 3252 | ) 3253 | ); 3254 | } 3255 | 3256 | function log( 3257 | bool p0, 3258 | uint256 p1, 3259 | address p2, 3260 | uint256 p3 3261 | ) internal view { 3262 | _sendLogPayload( 3263 | abi.encodeWithSignature( 3264 | "log(bool,uint,address,uint)", 3265 | p0, 3266 | p1, 3267 | p2, 3268 | p3 3269 | ) 3270 | ); 3271 | } 3272 | 3273 | function log( 3274 | bool p0, 3275 | uint256 p1, 3276 | address p2, 3277 | string memory p3 3278 | ) internal view { 3279 | _sendLogPayload( 3280 | abi.encodeWithSignature( 3281 | "log(bool,uint,address,string)", 3282 | p0, 3283 | p1, 3284 | p2, 3285 | p3 3286 | ) 3287 | ); 3288 | } 3289 | 3290 | function log( 3291 | bool p0, 3292 | uint256 p1, 3293 | address p2, 3294 | bool p3 3295 | ) internal view { 3296 | _sendLogPayload( 3297 | abi.encodeWithSignature( 3298 | "log(bool,uint,address,bool)", 3299 | p0, 3300 | p1, 3301 | p2, 3302 | p3 3303 | ) 3304 | ); 3305 | } 3306 | 3307 | function log( 3308 | bool p0, 3309 | uint256 p1, 3310 | address p2, 3311 | address p3 3312 | ) internal view { 3313 | _sendLogPayload( 3314 | abi.encodeWithSignature( 3315 | "log(bool,uint,address,address)", 3316 | p0, 3317 | p1, 3318 | p2, 3319 | p3 3320 | ) 3321 | ); 3322 | } 3323 | 3324 | function log( 3325 | bool p0, 3326 | string memory p1, 3327 | uint256 p2, 3328 | uint256 p3 3329 | ) internal view { 3330 | _sendLogPayload( 3331 | abi.encodeWithSignature( 3332 | "log(bool,string,uint,uint)", 3333 | p0, 3334 | p1, 3335 | p2, 3336 | p3 3337 | ) 3338 | ); 3339 | } 3340 | 3341 | function log( 3342 | bool p0, 3343 | string memory p1, 3344 | uint256 p2, 3345 | string memory p3 3346 | ) internal view { 3347 | _sendLogPayload( 3348 | abi.encodeWithSignature( 3349 | "log(bool,string,uint,string)", 3350 | p0, 3351 | p1, 3352 | p2, 3353 | p3 3354 | ) 3355 | ); 3356 | } 3357 | 3358 | function log( 3359 | bool p0, 3360 | string memory p1, 3361 | uint256 p2, 3362 | bool p3 3363 | ) internal view { 3364 | _sendLogPayload( 3365 | abi.encodeWithSignature( 3366 | "log(bool,string,uint,bool)", 3367 | p0, 3368 | p1, 3369 | p2, 3370 | p3 3371 | ) 3372 | ); 3373 | } 3374 | 3375 | function log( 3376 | bool p0, 3377 | string memory p1, 3378 | uint256 p2, 3379 | address p3 3380 | ) internal view { 3381 | _sendLogPayload( 3382 | abi.encodeWithSignature( 3383 | "log(bool,string,uint,address)", 3384 | p0, 3385 | p1, 3386 | p2, 3387 | p3 3388 | ) 3389 | ); 3390 | } 3391 | 3392 | function log( 3393 | bool p0, 3394 | string memory p1, 3395 | string memory p2, 3396 | uint256 p3 3397 | ) internal view { 3398 | _sendLogPayload( 3399 | abi.encodeWithSignature( 3400 | "log(bool,string,string,uint)", 3401 | p0, 3402 | p1, 3403 | p2, 3404 | p3 3405 | ) 3406 | ); 3407 | } 3408 | 3409 | function log( 3410 | bool p0, 3411 | string memory p1, 3412 | string memory p2, 3413 | string memory p3 3414 | ) internal view { 3415 | _sendLogPayload( 3416 | abi.encodeWithSignature( 3417 | "log(bool,string,string,string)", 3418 | p0, 3419 | p1, 3420 | p2, 3421 | p3 3422 | ) 3423 | ); 3424 | } 3425 | 3426 | function log( 3427 | bool p0, 3428 | string memory p1, 3429 | string memory p2, 3430 | bool p3 3431 | ) internal view { 3432 | _sendLogPayload( 3433 | abi.encodeWithSignature( 3434 | "log(bool,string,string,bool)", 3435 | p0, 3436 | p1, 3437 | p2, 3438 | p3 3439 | ) 3440 | ); 3441 | } 3442 | 3443 | function log( 3444 | bool p0, 3445 | string memory p1, 3446 | string memory p2, 3447 | address p3 3448 | ) internal view { 3449 | _sendLogPayload( 3450 | abi.encodeWithSignature( 3451 | "log(bool,string,string,address)", 3452 | p0, 3453 | p1, 3454 | p2, 3455 | p3 3456 | ) 3457 | ); 3458 | } 3459 | 3460 | function log( 3461 | bool p0, 3462 | string memory p1, 3463 | bool p2, 3464 | uint256 p3 3465 | ) internal view { 3466 | _sendLogPayload( 3467 | abi.encodeWithSignature( 3468 | "log(bool,string,bool,uint)", 3469 | p0, 3470 | p1, 3471 | p2, 3472 | p3 3473 | ) 3474 | ); 3475 | } 3476 | 3477 | function log( 3478 | bool p0, 3479 | string memory p1, 3480 | bool p2, 3481 | string memory p3 3482 | ) internal view { 3483 | _sendLogPayload( 3484 | abi.encodeWithSignature( 3485 | "log(bool,string,bool,string)", 3486 | p0, 3487 | p1, 3488 | p2, 3489 | p3 3490 | ) 3491 | ); 3492 | } 3493 | 3494 | function log( 3495 | bool p0, 3496 | string memory p1, 3497 | bool p2, 3498 | bool p3 3499 | ) internal view { 3500 | _sendLogPayload( 3501 | abi.encodeWithSignature( 3502 | "log(bool,string,bool,bool)", 3503 | p0, 3504 | p1, 3505 | p2, 3506 | p3 3507 | ) 3508 | ); 3509 | } 3510 | 3511 | function log( 3512 | bool p0, 3513 | string memory p1, 3514 | bool p2, 3515 | address p3 3516 | ) internal view { 3517 | _sendLogPayload( 3518 | abi.encodeWithSignature( 3519 | "log(bool,string,bool,address)", 3520 | p0, 3521 | p1, 3522 | p2, 3523 | p3 3524 | ) 3525 | ); 3526 | } 3527 | 3528 | function log( 3529 | bool p0, 3530 | string memory p1, 3531 | address p2, 3532 | uint256 p3 3533 | ) internal view { 3534 | _sendLogPayload( 3535 | abi.encodeWithSignature( 3536 | "log(bool,string,address,uint)", 3537 | p0, 3538 | p1, 3539 | p2, 3540 | p3 3541 | ) 3542 | ); 3543 | } 3544 | 3545 | function log( 3546 | bool p0, 3547 | string memory p1, 3548 | address p2, 3549 | string memory p3 3550 | ) internal view { 3551 | _sendLogPayload( 3552 | abi.encodeWithSignature( 3553 | "log(bool,string,address,string)", 3554 | p0, 3555 | p1, 3556 | p2, 3557 | p3 3558 | ) 3559 | ); 3560 | } 3561 | 3562 | function log( 3563 | bool p0, 3564 | string memory p1, 3565 | address p2, 3566 | bool p3 3567 | ) internal view { 3568 | _sendLogPayload( 3569 | abi.encodeWithSignature( 3570 | "log(bool,string,address,bool)", 3571 | p0, 3572 | p1, 3573 | p2, 3574 | p3 3575 | ) 3576 | ); 3577 | } 3578 | 3579 | function log( 3580 | bool p0, 3581 | string memory p1, 3582 | address p2, 3583 | address p3 3584 | ) internal view { 3585 | _sendLogPayload( 3586 | abi.encodeWithSignature( 3587 | "log(bool,string,address,address)", 3588 | p0, 3589 | p1, 3590 | p2, 3591 | p3 3592 | ) 3593 | ); 3594 | } 3595 | 3596 | function log( 3597 | bool p0, 3598 | bool p1, 3599 | uint256 p2, 3600 | uint256 p3 3601 | ) internal view { 3602 | _sendLogPayload( 3603 | abi.encodeWithSignature("log(bool,bool,uint,uint)", p0, p1, p2, p3) 3604 | ); 3605 | } 3606 | 3607 | function log( 3608 | bool p0, 3609 | bool p1, 3610 | uint256 p2, 3611 | string memory p3 3612 | ) internal view { 3613 | _sendLogPayload( 3614 | abi.encodeWithSignature( 3615 | "log(bool,bool,uint,string)", 3616 | p0, 3617 | p1, 3618 | p2, 3619 | p3 3620 | ) 3621 | ); 3622 | } 3623 | 3624 | function log( 3625 | bool p0, 3626 | bool p1, 3627 | uint256 p2, 3628 | bool p3 3629 | ) internal view { 3630 | _sendLogPayload( 3631 | abi.encodeWithSignature("log(bool,bool,uint,bool)", p0, p1, p2, p3) 3632 | ); 3633 | } 3634 | 3635 | function log( 3636 | bool p0, 3637 | bool p1, 3638 | uint256 p2, 3639 | address p3 3640 | ) internal view { 3641 | _sendLogPayload( 3642 | abi.encodeWithSignature( 3643 | "log(bool,bool,uint,address)", 3644 | p0, 3645 | p1, 3646 | p2, 3647 | p3 3648 | ) 3649 | ); 3650 | } 3651 | 3652 | function log( 3653 | bool p0, 3654 | bool p1, 3655 | string memory p2, 3656 | uint256 p3 3657 | ) internal view { 3658 | _sendLogPayload( 3659 | abi.encodeWithSignature( 3660 | "log(bool,bool,string,uint)", 3661 | p0, 3662 | p1, 3663 | p2, 3664 | p3 3665 | ) 3666 | ); 3667 | } 3668 | 3669 | function log( 3670 | bool p0, 3671 | bool p1, 3672 | string memory p2, 3673 | string memory p3 3674 | ) internal view { 3675 | _sendLogPayload( 3676 | abi.encodeWithSignature( 3677 | "log(bool,bool,string,string)", 3678 | p0, 3679 | p1, 3680 | p2, 3681 | p3 3682 | ) 3683 | ); 3684 | } 3685 | 3686 | function log( 3687 | bool p0, 3688 | bool p1, 3689 | string memory p2, 3690 | bool p3 3691 | ) internal view { 3692 | _sendLogPayload( 3693 | abi.encodeWithSignature( 3694 | "log(bool,bool,string,bool)", 3695 | p0, 3696 | p1, 3697 | p2, 3698 | p3 3699 | ) 3700 | ); 3701 | } 3702 | 3703 | function log( 3704 | bool p0, 3705 | bool p1, 3706 | string memory p2, 3707 | address p3 3708 | ) internal view { 3709 | _sendLogPayload( 3710 | abi.encodeWithSignature( 3711 | "log(bool,bool,string,address)", 3712 | p0, 3713 | p1, 3714 | p2, 3715 | p3 3716 | ) 3717 | ); 3718 | } 3719 | 3720 | function log( 3721 | bool p0, 3722 | bool p1, 3723 | bool p2, 3724 | uint256 p3 3725 | ) internal view { 3726 | _sendLogPayload( 3727 | abi.encodeWithSignature("log(bool,bool,bool,uint)", p0, p1, p2, p3) 3728 | ); 3729 | } 3730 | 3731 | function log( 3732 | bool p0, 3733 | bool p1, 3734 | bool p2, 3735 | string memory p3 3736 | ) internal view { 3737 | _sendLogPayload( 3738 | abi.encodeWithSignature( 3739 | "log(bool,bool,bool,string)", 3740 | p0, 3741 | p1, 3742 | p2, 3743 | p3 3744 | ) 3745 | ); 3746 | } 3747 | 3748 | function log( 3749 | bool p0, 3750 | bool p1, 3751 | bool p2, 3752 | bool p3 3753 | ) internal view { 3754 | _sendLogPayload( 3755 | abi.encodeWithSignature("log(bool,bool,bool,bool)", p0, p1, p2, p3) 3756 | ); 3757 | } 3758 | 3759 | function log( 3760 | bool p0, 3761 | bool p1, 3762 | bool p2, 3763 | address p3 3764 | ) internal view { 3765 | _sendLogPayload( 3766 | abi.encodeWithSignature( 3767 | "log(bool,bool,bool,address)", 3768 | p0, 3769 | p1, 3770 | p2, 3771 | p3 3772 | ) 3773 | ); 3774 | } 3775 | 3776 | function log( 3777 | bool p0, 3778 | bool p1, 3779 | address p2, 3780 | uint256 p3 3781 | ) internal view { 3782 | _sendLogPayload( 3783 | abi.encodeWithSignature( 3784 | "log(bool,bool,address,uint)", 3785 | p0, 3786 | p1, 3787 | p2, 3788 | p3 3789 | ) 3790 | ); 3791 | } 3792 | 3793 | function log( 3794 | bool p0, 3795 | bool p1, 3796 | address p2, 3797 | string memory p3 3798 | ) internal view { 3799 | _sendLogPayload( 3800 | abi.encodeWithSignature( 3801 | "log(bool,bool,address,string)", 3802 | p0, 3803 | p1, 3804 | p2, 3805 | p3 3806 | ) 3807 | ); 3808 | } 3809 | 3810 | function log( 3811 | bool p0, 3812 | bool p1, 3813 | address p2, 3814 | bool p3 3815 | ) internal view { 3816 | _sendLogPayload( 3817 | abi.encodeWithSignature( 3818 | "log(bool,bool,address,bool)", 3819 | p0, 3820 | p1, 3821 | p2, 3822 | p3 3823 | ) 3824 | ); 3825 | } 3826 | 3827 | function log( 3828 | bool p0, 3829 | bool p1, 3830 | address p2, 3831 | address p3 3832 | ) internal view { 3833 | _sendLogPayload( 3834 | abi.encodeWithSignature( 3835 | "log(bool,bool,address,address)", 3836 | p0, 3837 | p1, 3838 | p2, 3839 | p3 3840 | ) 3841 | ); 3842 | } 3843 | 3844 | function log( 3845 | bool p0, 3846 | address p1, 3847 | uint256 p2, 3848 | uint256 p3 3849 | ) internal view { 3850 | _sendLogPayload( 3851 | abi.encodeWithSignature( 3852 | "log(bool,address,uint,uint)", 3853 | p0, 3854 | p1, 3855 | p2, 3856 | p3 3857 | ) 3858 | ); 3859 | } 3860 | 3861 | function log( 3862 | bool p0, 3863 | address p1, 3864 | uint256 p2, 3865 | string memory p3 3866 | ) internal view { 3867 | _sendLogPayload( 3868 | abi.encodeWithSignature( 3869 | "log(bool,address,uint,string)", 3870 | p0, 3871 | p1, 3872 | p2, 3873 | p3 3874 | ) 3875 | ); 3876 | } 3877 | 3878 | function log( 3879 | bool p0, 3880 | address p1, 3881 | uint256 p2, 3882 | bool p3 3883 | ) internal view { 3884 | _sendLogPayload( 3885 | abi.encodeWithSignature( 3886 | "log(bool,address,uint,bool)", 3887 | p0, 3888 | p1, 3889 | p2, 3890 | p3 3891 | ) 3892 | ); 3893 | } 3894 | 3895 | function log( 3896 | bool p0, 3897 | address p1, 3898 | uint256 p2, 3899 | address p3 3900 | ) internal view { 3901 | _sendLogPayload( 3902 | abi.encodeWithSignature( 3903 | "log(bool,address,uint,address)", 3904 | p0, 3905 | p1, 3906 | p2, 3907 | p3 3908 | ) 3909 | ); 3910 | } 3911 | 3912 | function log( 3913 | bool p0, 3914 | address p1, 3915 | string memory p2, 3916 | uint256 p3 3917 | ) internal view { 3918 | _sendLogPayload( 3919 | abi.encodeWithSignature( 3920 | "log(bool,address,string,uint)", 3921 | p0, 3922 | p1, 3923 | p2, 3924 | p3 3925 | ) 3926 | ); 3927 | } 3928 | 3929 | function log( 3930 | bool p0, 3931 | address p1, 3932 | string memory p2, 3933 | string memory p3 3934 | ) internal view { 3935 | _sendLogPayload( 3936 | abi.encodeWithSignature( 3937 | "log(bool,address,string,string)", 3938 | p0, 3939 | p1, 3940 | p2, 3941 | p3 3942 | ) 3943 | ); 3944 | } 3945 | 3946 | function log( 3947 | bool p0, 3948 | address p1, 3949 | string memory p2, 3950 | bool p3 3951 | ) internal view { 3952 | _sendLogPayload( 3953 | abi.encodeWithSignature( 3954 | "log(bool,address,string,bool)", 3955 | p0, 3956 | p1, 3957 | p2, 3958 | p3 3959 | ) 3960 | ); 3961 | } 3962 | 3963 | function log( 3964 | bool p0, 3965 | address p1, 3966 | string memory p2, 3967 | address p3 3968 | ) internal view { 3969 | _sendLogPayload( 3970 | abi.encodeWithSignature( 3971 | "log(bool,address,string,address)", 3972 | p0, 3973 | p1, 3974 | p2, 3975 | p3 3976 | ) 3977 | ); 3978 | } 3979 | 3980 | function log( 3981 | bool p0, 3982 | address p1, 3983 | bool p2, 3984 | uint256 p3 3985 | ) internal view { 3986 | _sendLogPayload( 3987 | abi.encodeWithSignature( 3988 | "log(bool,address,bool,uint)", 3989 | p0, 3990 | p1, 3991 | p2, 3992 | p3 3993 | ) 3994 | ); 3995 | } 3996 | 3997 | function log( 3998 | bool p0, 3999 | address p1, 4000 | bool p2, 4001 | string memory p3 4002 | ) internal view { 4003 | _sendLogPayload( 4004 | abi.encodeWithSignature( 4005 | "log(bool,address,bool,string)", 4006 | p0, 4007 | p1, 4008 | p2, 4009 | p3 4010 | ) 4011 | ); 4012 | } 4013 | 4014 | function log( 4015 | bool p0, 4016 | address p1, 4017 | bool p2, 4018 | bool p3 4019 | ) internal view { 4020 | _sendLogPayload( 4021 | abi.encodeWithSignature( 4022 | "log(bool,address,bool,bool)", 4023 | p0, 4024 | p1, 4025 | p2, 4026 | p3 4027 | ) 4028 | ); 4029 | } 4030 | 4031 | function log( 4032 | bool p0, 4033 | address p1, 4034 | bool p2, 4035 | address p3 4036 | ) internal view { 4037 | _sendLogPayload( 4038 | abi.encodeWithSignature( 4039 | "log(bool,address,bool,address)", 4040 | p0, 4041 | p1, 4042 | p2, 4043 | p3 4044 | ) 4045 | ); 4046 | } 4047 | 4048 | function log( 4049 | bool p0, 4050 | address p1, 4051 | address p2, 4052 | uint256 p3 4053 | ) internal view { 4054 | _sendLogPayload( 4055 | abi.encodeWithSignature( 4056 | "log(bool,address,address,uint)", 4057 | p0, 4058 | p1, 4059 | p2, 4060 | p3 4061 | ) 4062 | ); 4063 | } 4064 | 4065 | function log( 4066 | bool p0, 4067 | address p1, 4068 | address p2, 4069 | string memory p3 4070 | ) internal view { 4071 | _sendLogPayload( 4072 | abi.encodeWithSignature( 4073 | "log(bool,address,address,string)", 4074 | p0, 4075 | p1, 4076 | p2, 4077 | p3 4078 | ) 4079 | ); 4080 | } 4081 | 4082 | function log( 4083 | bool p0, 4084 | address p1, 4085 | address p2, 4086 | bool p3 4087 | ) internal view { 4088 | _sendLogPayload( 4089 | abi.encodeWithSignature( 4090 | "log(bool,address,address,bool)", 4091 | p0, 4092 | p1, 4093 | p2, 4094 | p3 4095 | ) 4096 | ); 4097 | } 4098 | 4099 | function log( 4100 | bool p0, 4101 | address p1, 4102 | address p2, 4103 | address p3 4104 | ) internal view { 4105 | _sendLogPayload( 4106 | abi.encodeWithSignature( 4107 | "log(bool,address,address,address)", 4108 | p0, 4109 | p1, 4110 | p2, 4111 | p3 4112 | ) 4113 | ); 4114 | } 4115 | 4116 | function log( 4117 | address p0, 4118 | uint256 p1, 4119 | uint256 p2, 4120 | uint256 p3 4121 | ) internal view { 4122 | _sendLogPayload( 4123 | abi.encodeWithSignature( 4124 | "log(address,uint,uint,uint)", 4125 | p0, 4126 | p1, 4127 | p2, 4128 | p3 4129 | ) 4130 | ); 4131 | } 4132 | 4133 | function log( 4134 | address p0, 4135 | uint256 p1, 4136 | uint256 p2, 4137 | string memory p3 4138 | ) internal view { 4139 | _sendLogPayload( 4140 | abi.encodeWithSignature( 4141 | "log(address,uint,uint,string)", 4142 | p0, 4143 | p1, 4144 | p2, 4145 | p3 4146 | ) 4147 | ); 4148 | } 4149 | 4150 | function log( 4151 | address p0, 4152 | uint256 p1, 4153 | uint256 p2, 4154 | bool p3 4155 | ) internal view { 4156 | _sendLogPayload( 4157 | abi.encodeWithSignature( 4158 | "log(address,uint,uint,bool)", 4159 | p0, 4160 | p1, 4161 | p2, 4162 | p3 4163 | ) 4164 | ); 4165 | } 4166 | 4167 | function log( 4168 | address p0, 4169 | uint256 p1, 4170 | uint256 p2, 4171 | address p3 4172 | ) internal view { 4173 | _sendLogPayload( 4174 | abi.encodeWithSignature( 4175 | "log(address,uint,uint,address)", 4176 | p0, 4177 | p1, 4178 | p2, 4179 | p3 4180 | ) 4181 | ); 4182 | } 4183 | 4184 | function log( 4185 | address p0, 4186 | uint256 p1, 4187 | string memory p2, 4188 | uint256 p3 4189 | ) internal view { 4190 | _sendLogPayload( 4191 | abi.encodeWithSignature( 4192 | "log(address,uint,string,uint)", 4193 | p0, 4194 | p1, 4195 | p2, 4196 | p3 4197 | ) 4198 | ); 4199 | } 4200 | 4201 | function log( 4202 | address p0, 4203 | uint256 p1, 4204 | string memory p2, 4205 | string memory p3 4206 | ) internal view { 4207 | _sendLogPayload( 4208 | abi.encodeWithSignature( 4209 | "log(address,uint,string,string)", 4210 | p0, 4211 | p1, 4212 | p2, 4213 | p3 4214 | ) 4215 | ); 4216 | } 4217 | 4218 | function log( 4219 | address p0, 4220 | uint256 p1, 4221 | string memory p2, 4222 | bool p3 4223 | ) internal view { 4224 | _sendLogPayload( 4225 | abi.encodeWithSignature( 4226 | "log(address,uint,string,bool)", 4227 | p0, 4228 | p1, 4229 | p2, 4230 | p3 4231 | ) 4232 | ); 4233 | } 4234 | 4235 | function log( 4236 | address p0, 4237 | uint256 p1, 4238 | string memory p2, 4239 | address p3 4240 | ) internal view { 4241 | _sendLogPayload( 4242 | abi.encodeWithSignature( 4243 | "log(address,uint,string,address)", 4244 | p0, 4245 | p1, 4246 | p2, 4247 | p3 4248 | ) 4249 | ); 4250 | } 4251 | 4252 | function log( 4253 | address p0, 4254 | uint256 p1, 4255 | bool p2, 4256 | uint256 p3 4257 | ) internal view { 4258 | _sendLogPayload( 4259 | abi.encodeWithSignature( 4260 | "log(address,uint,bool,uint)", 4261 | p0, 4262 | p1, 4263 | p2, 4264 | p3 4265 | ) 4266 | ); 4267 | } 4268 | 4269 | function log( 4270 | address p0, 4271 | uint256 p1, 4272 | bool p2, 4273 | string memory p3 4274 | ) internal view { 4275 | _sendLogPayload( 4276 | abi.encodeWithSignature( 4277 | "log(address,uint,bool,string)", 4278 | p0, 4279 | p1, 4280 | p2, 4281 | p3 4282 | ) 4283 | ); 4284 | } 4285 | 4286 | function log( 4287 | address p0, 4288 | uint256 p1, 4289 | bool p2, 4290 | bool p3 4291 | ) internal view { 4292 | _sendLogPayload( 4293 | abi.encodeWithSignature( 4294 | "log(address,uint,bool,bool)", 4295 | p0, 4296 | p1, 4297 | p2, 4298 | p3 4299 | ) 4300 | ); 4301 | } 4302 | 4303 | function log( 4304 | address p0, 4305 | uint256 p1, 4306 | bool p2, 4307 | address p3 4308 | ) internal view { 4309 | _sendLogPayload( 4310 | abi.encodeWithSignature( 4311 | "log(address,uint,bool,address)", 4312 | p0, 4313 | p1, 4314 | p2, 4315 | p3 4316 | ) 4317 | ); 4318 | } 4319 | 4320 | function log( 4321 | address p0, 4322 | uint256 p1, 4323 | address p2, 4324 | uint256 p3 4325 | ) internal view { 4326 | _sendLogPayload( 4327 | abi.encodeWithSignature( 4328 | "log(address,uint,address,uint)", 4329 | p0, 4330 | p1, 4331 | p2, 4332 | p3 4333 | ) 4334 | ); 4335 | } 4336 | 4337 | function log( 4338 | address p0, 4339 | uint256 p1, 4340 | address p2, 4341 | string memory p3 4342 | ) internal view { 4343 | _sendLogPayload( 4344 | abi.encodeWithSignature( 4345 | "log(address,uint,address,string)", 4346 | p0, 4347 | p1, 4348 | p2, 4349 | p3 4350 | ) 4351 | ); 4352 | } 4353 | 4354 | function log( 4355 | address p0, 4356 | uint256 p1, 4357 | address p2, 4358 | bool p3 4359 | ) internal view { 4360 | _sendLogPayload( 4361 | abi.encodeWithSignature( 4362 | "log(address,uint,address,bool)", 4363 | p0, 4364 | p1, 4365 | p2, 4366 | p3 4367 | ) 4368 | ); 4369 | } 4370 | 4371 | function log( 4372 | address p0, 4373 | uint256 p1, 4374 | address p2, 4375 | address p3 4376 | ) internal view { 4377 | _sendLogPayload( 4378 | abi.encodeWithSignature( 4379 | "log(address,uint,address,address)", 4380 | p0, 4381 | p1, 4382 | p2, 4383 | p3 4384 | ) 4385 | ); 4386 | } 4387 | 4388 | function log( 4389 | address p0, 4390 | string memory p1, 4391 | uint256 p2, 4392 | uint256 p3 4393 | ) internal view { 4394 | _sendLogPayload( 4395 | abi.encodeWithSignature( 4396 | "log(address,string,uint,uint)", 4397 | p0, 4398 | p1, 4399 | p2, 4400 | p3 4401 | ) 4402 | ); 4403 | } 4404 | 4405 | function log( 4406 | address p0, 4407 | string memory p1, 4408 | uint256 p2, 4409 | string memory p3 4410 | ) internal view { 4411 | _sendLogPayload( 4412 | abi.encodeWithSignature( 4413 | "log(address,string,uint,string)", 4414 | p0, 4415 | p1, 4416 | p2, 4417 | p3 4418 | ) 4419 | ); 4420 | } 4421 | 4422 | function log( 4423 | address p0, 4424 | string memory p1, 4425 | uint256 p2, 4426 | bool p3 4427 | ) internal view { 4428 | _sendLogPayload( 4429 | abi.encodeWithSignature( 4430 | "log(address,string,uint,bool)", 4431 | p0, 4432 | p1, 4433 | p2, 4434 | p3 4435 | ) 4436 | ); 4437 | } 4438 | 4439 | function log( 4440 | address p0, 4441 | string memory p1, 4442 | uint256 p2, 4443 | address p3 4444 | ) internal view { 4445 | _sendLogPayload( 4446 | abi.encodeWithSignature( 4447 | "log(address,string,uint,address)", 4448 | p0, 4449 | p1, 4450 | p2, 4451 | p3 4452 | ) 4453 | ); 4454 | } 4455 | 4456 | function log( 4457 | address p0, 4458 | string memory p1, 4459 | string memory p2, 4460 | uint256 p3 4461 | ) internal view { 4462 | _sendLogPayload( 4463 | abi.encodeWithSignature( 4464 | "log(address,string,string,uint)", 4465 | p0, 4466 | p1, 4467 | p2, 4468 | p3 4469 | ) 4470 | ); 4471 | } 4472 | 4473 | function log( 4474 | address p0, 4475 | string memory p1, 4476 | string memory p2, 4477 | string memory p3 4478 | ) internal view { 4479 | _sendLogPayload( 4480 | abi.encodeWithSignature( 4481 | "log(address,string,string,string)", 4482 | p0, 4483 | p1, 4484 | p2, 4485 | p3 4486 | ) 4487 | ); 4488 | } 4489 | 4490 | function log( 4491 | address p0, 4492 | string memory p1, 4493 | string memory p2, 4494 | bool p3 4495 | ) internal view { 4496 | _sendLogPayload( 4497 | abi.encodeWithSignature( 4498 | "log(address,string,string,bool)", 4499 | p0, 4500 | p1, 4501 | p2, 4502 | p3 4503 | ) 4504 | ); 4505 | } 4506 | 4507 | function log( 4508 | address p0, 4509 | string memory p1, 4510 | string memory p2, 4511 | address p3 4512 | ) internal view { 4513 | _sendLogPayload( 4514 | abi.encodeWithSignature( 4515 | "log(address,string,string,address)", 4516 | p0, 4517 | p1, 4518 | p2, 4519 | p3 4520 | ) 4521 | ); 4522 | } 4523 | 4524 | function log( 4525 | address p0, 4526 | string memory p1, 4527 | bool p2, 4528 | uint256 p3 4529 | ) internal view { 4530 | _sendLogPayload( 4531 | abi.encodeWithSignature( 4532 | "log(address,string,bool,uint)", 4533 | p0, 4534 | p1, 4535 | p2, 4536 | p3 4537 | ) 4538 | ); 4539 | } 4540 | 4541 | function log( 4542 | address p0, 4543 | string memory p1, 4544 | bool p2, 4545 | string memory p3 4546 | ) internal view { 4547 | _sendLogPayload( 4548 | abi.encodeWithSignature( 4549 | "log(address,string,bool,string)", 4550 | p0, 4551 | p1, 4552 | p2, 4553 | p3 4554 | ) 4555 | ); 4556 | } 4557 | 4558 | function log( 4559 | address p0, 4560 | string memory p1, 4561 | bool p2, 4562 | bool p3 4563 | ) internal view { 4564 | _sendLogPayload( 4565 | abi.encodeWithSignature( 4566 | "log(address,string,bool,bool)", 4567 | p0, 4568 | p1, 4569 | p2, 4570 | p3 4571 | ) 4572 | ); 4573 | } 4574 | 4575 | function log( 4576 | address p0, 4577 | string memory p1, 4578 | bool p2, 4579 | address p3 4580 | ) internal view { 4581 | _sendLogPayload( 4582 | abi.encodeWithSignature( 4583 | "log(address,string,bool,address)", 4584 | p0, 4585 | p1, 4586 | p2, 4587 | p3 4588 | ) 4589 | ); 4590 | } 4591 | 4592 | function log( 4593 | address p0, 4594 | string memory p1, 4595 | address p2, 4596 | uint256 p3 4597 | ) internal view { 4598 | _sendLogPayload( 4599 | abi.encodeWithSignature( 4600 | "log(address,string,address,uint)", 4601 | p0, 4602 | p1, 4603 | p2, 4604 | p3 4605 | ) 4606 | ); 4607 | } 4608 | 4609 | function log( 4610 | address p0, 4611 | string memory p1, 4612 | address p2, 4613 | string memory p3 4614 | ) internal view { 4615 | _sendLogPayload( 4616 | abi.encodeWithSignature( 4617 | "log(address,string,address,string)", 4618 | p0, 4619 | p1, 4620 | p2, 4621 | p3 4622 | ) 4623 | ); 4624 | } 4625 | 4626 | function log( 4627 | address p0, 4628 | string memory p1, 4629 | address p2, 4630 | bool p3 4631 | ) internal view { 4632 | _sendLogPayload( 4633 | abi.encodeWithSignature( 4634 | "log(address,string,address,bool)", 4635 | p0, 4636 | p1, 4637 | p2, 4638 | p3 4639 | ) 4640 | ); 4641 | } 4642 | 4643 | function log( 4644 | address p0, 4645 | string memory p1, 4646 | address p2, 4647 | address p3 4648 | ) internal view { 4649 | _sendLogPayload( 4650 | abi.encodeWithSignature( 4651 | "log(address,string,address,address)", 4652 | p0, 4653 | p1, 4654 | p2, 4655 | p3 4656 | ) 4657 | ); 4658 | } 4659 | 4660 | function log( 4661 | address p0, 4662 | bool p1, 4663 | uint256 p2, 4664 | uint256 p3 4665 | ) internal view { 4666 | _sendLogPayload( 4667 | abi.encodeWithSignature( 4668 | "log(address,bool,uint,uint)", 4669 | p0, 4670 | p1, 4671 | p2, 4672 | p3 4673 | ) 4674 | ); 4675 | } 4676 | 4677 | function log( 4678 | address p0, 4679 | bool p1, 4680 | uint256 p2, 4681 | string memory p3 4682 | ) internal view { 4683 | _sendLogPayload( 4684 | abi.encodeWithSignature( 4685 | "log(address,bool,uint,string)", 4686 | p0, 4687 | p1, 4688 | p2, 4689 | p3 4690 | ) 4691 | ); 4692 | } 4693 | 4694 | function log( 4695 | address p0, 4696 | bool p1, 4697 | uint256 p2, 4698 | bool p3 4699 | ) internal view { 4700 | _sendLogPayload( 4701 | abi.encodeWithSignature( 4702 | "log(address,bool,uint,bool)", 4703 | p0, 4704 | p1, 4705 | p2, 4706 | p3 4707 | ) 4708 | ); 4709 | } 4710 | 4711 | function log( 4712 | address p0, 4713 | bool p1, 4714 | uint256 p2, 4715 | address p3 4716 | ) internal view { 4717 | _sendLogPayload( 4718 | abi.encodeWithSignature( 4719 | "log(address,bool,uint,address)", 4720 | p0, 4721 | p1, 4722 | p2, 4723 | p3 4724 | ) 4725 | ); 4726 | } 4727 | 4728 | function log( 4729 | address p0, 4730 | bool p1, 4731 | string memory p2, 4732 | uint256 p3 4733 | ) internal view { 4734 | _sendLogPayload( 4735 | abi.encodeWithSignature( 4736 | "log(address,bool,string,uint)", 4737 | p0, 4738 | p1, 4739 | p2, 4740 | p3 4741 | ) 4742 | ); 4743 | } 4744 | 4745 | function log( 4746 | address p0, 4747 | bool p1, 4748 | string memory p2, 4749 | string memory p3 4750 | ) internal view { 4751 | _sendLogPayload( 4752 | abi.encodeWithSignature( 4753 | "log(address,bool,string,string)", 4754 | p0, 4755 | p1, 4756 | p2, 4757 | p3 4758 | ) 4759 | ); 4760 | } 4761 | 4762 | function log( 4763 | address p0, 4764 | bool p1, 4765 | string memory p2, 4766 | bool p3 4767 | ) internal view { 4768 | _sendLogPayload( 4769 | abi.encodeWithSignature( 4770 | "log(address,bool,string,bool)", 4771 | p0, 4772 | p1, 4773 | p2, 4774 | p3 4775 | ) 4776 | ); 4777 | } 4778 | 4779 | function log( 4780 | address p0, 4781 | bool p1, 4782 | string memory p2, 4783 | address p3 4784 | ) internal view { 4785 | _sendLogPayload( 4786 | abi.encodeWithSignature( 4787 | "log(address,bool,string,address)", 4788 | p0, 4789 | p1, 4790 | p2, 4791 | p3 4792 | ) 4793 | ); 4794 | } 4795 | 4796 | function log( 4797 | address p0, 4798 | bool p1, 4799 | bool p2, 4800 | uint256 p3 4801 | ) internal view { 4802 | _sendLogPayload( 4803 | abi.encodeWithSignature( 4804 | "log(address,bool,bool,uint)", 4805 | p0, 4806 | p1, 4807 | p2, 4808 | p3 4809 | ) 4810 | ); 4811 | } 4812 | 4813 | function log( 4814 | address p0, 4815 | bool p1, 4816 | bool p2, 4817 | string memory p3 4818 | ) internal view { 4819 | _sendLogPayload( 4820 | abi.encodeWithSignature( 4821 | "log(address,bool,bool,string)", 4822 | p0, 4823 | p1, 4824 | p2, 4825 | p3 4826 | ) 4827 | ); 4828 | } 4829 | 4830 | function log( 4831 | address p0, 4832 | bool p1, 4833 | bool p2, 4834 | bool p3 4835 | ) internal view { 4836 | _sendLogPayload( 4837 | abi.encodeWithSignature( 4838 | "log(address,bool,bool,bool)", 4839 | p0, 4840 | p1, 4841 | p2, 4842 | p3 4843 | ) 4844 | ); 4845 | } 4846 | 4847 | function log( 4848 | address p0, 4849 | bool p1, 4850 | bool p2, 4851 | address p3 4852 | ) internal view { 4853 | _sendLogPayload( 4854 | abi.encodeWithSignature( 4855 | "log(address,bool,bool,address)", 4856 | p0, 4857 | p1, 4858 | p2, 4859 | p3 4860 | ) 4861 | ); 4862 | } 4863 | 4864 | function log( 4865 | address p0, 4866 | bool p1, 4867 | address p2, 4868 | uint256 p3 4869 | ) internal view { 4870 | _sendLogPayload( 4871 | abi.encodeWithSignature( 4872 | "log(address,bool,address,uint)", 4873 | p0, 4874 | p1, 4875 | p2, 4876 | p3 4877 | ) 4878 | ); 4879 | } 4880 | 4881 | function log( 4882 | address p0, 4883 | bool p1, 4884 | address p2, 4885 | string memory p3 4886 | ) internal view { 4887 | _sendLogPayload( 4888 | abi.encodeWithSignature( 4889 | "log(address,bool,address,string)", 4890 | p0, 4891 | p1, 4892 | p2, 4893 | p3 4894 | ) 4895 | ); 4896 | } 4897 | 4898 | function log( 4899 | address p0, 4900 | bool p1, 4901 | address p2, 4902 | bool p3 4903 | ) internal view { 4904 | _sendLogPayload( 4905 | abi.encodeWithSignature( 4906 | "log(address,bool,address,bool)", 4907 | p0, 4908 | p1, 4909 | p2, 4910 | p3 4911 | ) 4912 | ); 4913 | } 4914 | 4915 | function log( 4916 | address p0, 4917 | bool p1, 4918 | address p2, 4919 | address p3 4920 | ) internal view { 4921 | _sendLogPayload( 4922 | abi.encodeWithSignature( 4923 | "log(address,bool,address,address)", 4924 | p0, 4925 | p1, 4926 | p2, 4927 | p3 4928 | ) 4929 | ); 4930 | } 4931 | 4932 | function log( 4933 | address p0, 4934 | address p1, 4935 | uint256 p2, 4936 | uint256 p3 4937 | ) internal view { 4938 | _sendLogPayload( 4939 | abi.encodeWithSignature( 4940 | "log(address,address,uint,uint)", 4941 | p0, 4942 | p1, 4943 | p2, 4944 | p3 4945 | ) 4946 | ); 4947 | } 4948 | 4949 | function log( 4950 | address p0, 4951 | address p1, 4952 | uint256 p2, 4953 | string memory p3 4954 | ) internal view { 4955 | _sendLogPayload( 4956 | abi.encodeWithSignature( 4957 | "log(address,address,uint,string)", 4958 | p0, 4959 | p1, 4960 | p2, 4961 | p3 4962 | ) 4963 | ); 4964 | } 4965 | 4966 | function log( 4967 | address p0, 4968 | address p1, 4969 | uint256 p2, 4970 | bool p3 4971 | ) internal view { 4972 | _sendLogPayload( 4973 | abi.encodeWithSignature( 4974 | "log(address,address,uint,bool)", 4975 | p0, 4976 | p1, 4977 | p2, 4978 | p3 4979 | ) 4980 | ); 4981 | } 4982 | 4983 | function log( 4984 | address p0, 4985 | address p1, 4986 | uint256 p2, 4987 | address p3 4988 | ) internal view { 4989 | _sendLogPayload( 4990 | abi.encodeWithSignature( 4991 | "log(address,address,uint,address)", 4992 | p0, 4993 | p1, 4994 | p2, 4995 | p3 4996 | ) 4997 | ); 4998 | } 4999 | 5000 | function log( 5001 | address p0, 5002 | address p1, 5003 | string memory p2, 5004 | uint256 p3 5005 | ) internal view { 5006 | _sendLogPayload( 5007 | abi.encodeWithSignature( 5008 | "log(address,address,string,uint)", 5009 | p0, 5010 | p1, 5011 | p2, 5012 | p3 5013 | ) 5014 | ); 5015 | } 5016 | 5017 | function log( 5018 | address p0, 5019 | address p1, 5020 | string memory p2, 5021 | string memory p3 5022 | ) internal view { 5023 | _sendLogPayload( 5024 | abi.encodeWithSignature( 5025 | "log(address,address,string,string)", 5026 | p0, 5027 | p1, 5028 | p2, 5029 | p3 5030 | ) 5031 | ); 5032 | } 5033 | 5034 | function log( 5035 | address p0, 5036 | address p1, 5037 | string memory p2, 5038 | bool p3 5039 | ) internal view { 5040 | _sendLogPayload( 5041 | abi.encodeWithSignature( 5042 | "log(address,address,string,bool)", 5043 | p0, 5044 | p1, 5045 | p2, 5046 | p3 5047 | ) 5048 | ); 5049 | } 5050 | 5051 | function log( 5052 | address p0, 5053 | address p1, 5054 | string memory p2, 5055 | address p3 5056 | ) internal view { 5057 | _sendLogPayload( 5058 | abi.encodeWithSignature( 5059 | "log(address,address,string,address)", 5060 | p0, 5061 | p1, 5062 | p2, 5063 | p3 5064 | ) 5065 | ); 5066 | } 5067 | 5068 | function log( 5069 | address p0, 5070 | address p1, 5071 | bool p2, 5072 | uint256 p3 5073 | ) internal view { 5074 | _sendLogPayload( 5075 | abi.encodeWithSignature( 5076 | "log(address,address,bool,uint)", 5077 | p0, 5078 | p1, 5079 | p2, 5080 | p3 5081 | ) 5082 | ); 5083 | } 5084 | 5085 | function log( 5086 | address p0, 5087 | address p1, 5088 | bool p2, 5089 | string memory p3 5090 | ) internal view { 5091 | _sendLogPayload( 5092 | abi.encodeWithSignature( 5093 | "log(address,address,bool,string)", 5094 | p0, 5095 | p1, 5096 | p2, 5097 | p3 5098 | ) 5099 | ); 5100 | } 5101 | 5102 | function log( 5103 | address p0, 5104 | address p1, 5105 | bool p2, 5106 | bool p3 5107 | ) internal view { 5108 | _sendLogPayload( 5109 | abi.encodeWithSignature( 5110 | "log(address,address,bool,bool)", 5111 | p0, 5112 | p1, 5113 | p2, 5114 | p3 5115 | ) 5116 | ); 5117 | } 5118 | 5119 | function log( 5120 | address p0, 5121 | address p1, 5122 | bool p2, 5123 | address p3 5124 | ) internal view { 5125 | _sendLogPayload( 5126 | abi.encodeWithSignature( 5127 | "log(address,address,bool,address)", 5128 | p0, 5129 | p1, 5130 | p2, 5131 | p3 5132 | ) 5133 | ); 5134 | } 5135 | 5136 | function log( 5137 | address p0, 5138 | address p1, 5139 | address p2, 5140 | uint256 p3 5141 | ) internal view { 5142 | _sendLogPayload( 5143 | abi.encodeWithSignature( 5144 | "log(address,address,address,uint)", 5145 | p0, 5146 | p1, 5147 | p2, 5148 | p3 5149 | ) 5150 | ); 5151 | } 5152 | 5153 | function log( 5154 | address p0, 5155 | address p1, 5156 | address p2, 5157 | string memory p3 5158 | ) internal view { 5159 | _sendLogPayload( 5160 | abi.encodeWithSignature( 5161 | "log(address,address,address,string)", 5162 | p0, 5163 | p1, 5164 | p2, 5165 | p3 5166 | ) 5167 | ); 5168 | } 5169 | 5170 | function log( 5171 | address p0, 5172 | address p1, 5173 | address p2, 5174 | bool p3 5175 | ) internal view { 5176 | _sendLogPayload( 5177 | abi.encodeWithSignature( 5178 | "log(address,address,address,bool)", 5179 | p0, 5180 | p1, 5181 | p2, 5182 | p3 5183 | ) 5184 | ); 5185 | } 5186 | 5187 | function log( 5188 | address p0, 5189 | address p1, 5190 | address p2, 5191 | address p3 5192 | ) internal view { 5193 | _sendLogPayload( 5194 | abi.encodeWithSignature( 5195 | "log(address,address,address,address)", 5196 | p0, 5197 | p1, 5198 | p2, 5199 | p3 5200 | ) 5201 | ); 5202 | } 5203 | } 5204 | --------------------------------------------------------------------------------