{ "address": "0x7126F676ac359eCE8D5244120FF9E78eD3222246", "abi": [ { "inputs": [ { "internalType": "contract IDelegationManager", "name": "_delegationManager", "type": "address" } ], "stateMutability": "nonpayable", "type": "constructor" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "address", "name": "delegatedShare", "type": "address" }, { "indexed": false, "internalType": "address", "name": "operator", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "share", "type": "uint256" } ], "name": "DecreaseDelegatedShares", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "address", "name": "delegatior", "type": "address" }, { "indexed": false, "internalType": "address", "name": "operator", "type": "address" } ], "name": "DelegateTo", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "address", "name": "delegatedShare", "type": "address" }, { "indexed": false, "internalType": "address", "name": "operator", "type": "address" }, { "indexed": false, "internalType": "uint256", "name": "share", "type": "uint256" } ], "name": "IncreaseDelegatedShares", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "uint8", "name": "version", "type": "uint8" } ], "name": "Initialized", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "contract IDelegationCallback", "name": "delegationTerms", "type": "address" }, { "indexed": false, "internalType": "bytes32", "name": "returnData", "type": "bytes32" } ], "name": "OnDelegationReceivedCallFailure", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "contract IDelegationCallback", "name": "delegationTerms", "type": "address" }, { "indexed": false, "internalType": "bytes32", "name": "returnData", "type": "bytes32" } ], "name": "OnDelegationWithdrawnCallFailure", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "previousOwner", "type": "address" }, { "indexed": true, "internalType": "address", "name": "newOwner", "type": "address" } ], "name": "OwnershipTransferred", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "address", "name": "account", "type": "address" } ], "name": "Paused", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "address", "name": "delegationCallback", "type": "address" }, { "indexed": false, "internalType": "address", "name": "register", "type": "address" } ], "name": "RegisterOperator", "type": "event" }, { "anonymous": false, "inputs": [ { "indexed": false, "internalType": "address", "name": "account", "type": "address" } ], "name": "Unpaused", "type": "event" }, { "inputs": [], "name": "DELEGATION_TYPEHASH", "outputs": [ { "internalType": "bytes32", "name": "", "type": "bytes32" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "DOMAIN_SEPARATOR", "outputs": [ { "internalType": "bytes32", "name": "", "type": "bytes32" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "DOMAIN_TYPEHASH", "outputs": [ { "internalType": "bytes32", "name": "", "type": "bytes32" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address[]", "name": "toAddAddresses", "type": "address[]" } ], "name": "addToWhitelist", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "staker", "type": "address" }, { "internalType": "contract IDelegationShare", "name": "delegationShare", "type": "address" }, { "internalType": "uint256", "name": "shares", "type": "uint256" } ], "name": "decreaseDelegatedShares", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "staker", "type": "address" }, { "internalType": "contract IDelegationShare[]", "name": "strategies", "type": "address[]" }, { "internalType": "uint256[]", "name": "shares", "type": "uint256[]" } ], "name": "decreaseDelegatedShares", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "operator", "type": "address" }, { "internalType": "address", "name": "staker", "type": "address" } ], "name": "delegateTo", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "operator", "type": "address" } ], "name": "delegateTo", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "staker", "type": "address" }, { "internalType": "address", "name": "operator", "type": "address" }, { "internalType": "uint256", "name": "expiry", "type": "uint256" }, { "internalType": "bytes32", "name": "r", "type": "bytes32" }, { "internalType": "bytes32", "name": "vs", "type": "bytes32" } ], "name": "delegateToSignature", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" } ], "name": "delegatedTo", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" } ], "name": "delegationCallback", "outputs": [ { "internalType": "contract IDelegationCallback", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "delegationManager", "outputs": [ { "internalType": "contract IDelegationManager", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" } ], "name": "delegationStatus", "outputs": [ { "internalType": "enum IDelegation.DelegationStatus", "name": "", "type": "uint8" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "staker", "type": "address" }, { "internalType": "contract IDelegationShare", "name": "delegationShare", "type": "address" }, { "internalType": "uint256", "name": "shares", "type": "uint256" } ], "name": "increaseDelegatedShares", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "initialOwner", "type": "address" } ], "name": "initialize", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "_stakingSlashing", "type": "address" }, { "internalType": "address", "name": "initialOwner", "type": "address" } ], "name": "initializeT", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "staker", "type": "address" } ], "name": "isDelegated", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "staker", "type": "address" } ], "name": "isNotDelegated", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "operator", "type": "address" } ], "name": "isOperator", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" } ], "name": "nonces", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" }, { "internalType": "contract IDelegationShare", "name": "", "type": "address" } ], "name": "operatorShares", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "owner", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "pause", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "paused", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "contract IDelegationCallback", "name": "dt", "type": "address" }, { "internalType": "address", "name": "sender", "type": "address" } ], "name": "registerAsOperator", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "contract IDelegationCallback", "name": "dt", "type": "address" } ], "name": "registerAsOperator", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address[]", "name": "toRemoveAddresses", "type": "address[]" } ], "name": "removeFromWhitelist", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "renounceOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "_address", "type": "address" } ], "name": "setStakingSlash", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "stakingSlash", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "newOwner", "type": "address" } ], "name": "transferOwnership", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "staker", "type": "address" } ], "name": "undelegate", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "unpause", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" } ], "name": "whitelist", "outputs": [ { "internalType": "bool", "name": "", "type": "bool" } ], "stateMutability": "view", "type": "function" } ], "transactionHash": "0xe6aa4f049b4492a965255342b5e892f28b09379c6f601f2cb61d0346b3584149", "receipt": { "to": null, "from": "0x2A2954F3989a83Cc43DD58B0f038D5F276f21333", "contractAddress": "0x7126F676ac359eCE8D5244120FF9E78eD3222246", "transactionIndex": 9, "gasUsed": "2243180", "logsBloom": "0x00000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000400000000008000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", "blockHash": "0x8f5f68e0baa9d777d35fabf7960b8a5af2ce9b27a530aca5870a114b6aeff65b", "transactionHash": "0xe6aa4f049b4492a965255342b5e892f28b09379c6f601f2cb61d0346b3584149", "logs": [ { "transactionIndex": 9, "blockNumber": 17577940, "transactionHash": "0xe6aa4f049b4492a965255342b5e892f28b09379c6f601f2cb61d0346b3584149", "address": "0x7126F676ac359eCE8D5244120FF9E78eD3222246", "topics": [ "0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498" ], "data": "0x00000000000000000000000000000000000000000000000000000000000000ff", "logIndex": 69, "blockHash": "0x8f5f68e0baa9d777d35fabf7960b8a5af2ce9b27a530aca5870a114b6aeff65b" } ], "blockNumber": 17577940, "cumulativeGasUsed": "3677631", "status": 1, "byzantium": true }, "args": [ "0xA90FCe37D274e673f3850b835F18790542b1755d" ], "numDeployments": 1, "solcInputHash": "122d24e54e7a415d06d6c42567deeca7", "metadata": "{\"compiler\":{\"version\":\"0.8.9+commit.e5eed63a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract IDelegationManager\",\"name\":\"_delegationManager\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"delegatedShare\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"share\",\"type\":\"uint256\"}],\"name\":\"DecreaseDelegatedShares\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"delegatior\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"DelegateTo\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"delegatedShare\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"share\",\"type\":\"uint256\"}],\"name\":\"IncreaseDelegatedShares\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"contract IDelegationCallback\",\"name\":\"delegationTerms\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"returnData\",\"type\":\"bytes32\"}],\"name\":\"OnDelegationReceivedCallFailure\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"contract IDelegationCallback\",\"name\":\"delegationTerms\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"returnData\",\"type\":\"bytes32\"}],\"name\":\"OnDelegationWithdrawnCallFailure\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"delegationCallback\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"register\",\"type\":\"address\"}],\"name\":\"RegisterOperator\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Unpaused\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DELEGATION_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DOMAIN_SEPARATOR\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"DOMAIN_TYPEHASH\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"toAddAddresses\",\"type\":\"address[]\"}],\"name\":\"addToWhitelist\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"contract IDelegationShare\",\"name\":\"delegationShare\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"decreaseDelegatedShares\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"contract IDelegationShare[]\",\"name\":\"strategies\",\"type\":\"address[]\"},{\"internalType\":\"uint256[]\",\"name\":\"shares\",\"type\":\"uint256[]\"}],\"name\":\"decreaseDelegatedShares\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"}],\"name\":\"delegateTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"delegateTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"expiry\",\"type\":\"uint256\"},{\"internalType\":\"bytes32\",\"name\":\"r\",\"type\":\"bytes32\"},{\"internalType\":\"bytes32\",\"name\":\"vs\",\"type\":\"bytes32\"}],\"name\":\"delegateToSignature\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"delegatedTo\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"delegationCallback\",\"outputs\":[{\"internalType\":\"contract IDelegationCallback\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"delegationManager\",\"outputs\":[{\"internalType\":\"contract IDelegationManager\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"delegationStatus\",\"outputs\":[{\"internalType\":\"enum IDelegation.DelegationStatus\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"},{\"internalType\":\"contract IDelegationShare\",\"name\":\"delegationShare\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"shares\",\"type\":\"uint256\"}],\"name\":\"increaseDelegatedShares\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"initialOwner\",\"type\":\"address\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_stakingSlashing\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"initialOwner\",\"type\":\"address\"}],\"name\":\"initializeT\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"}],\"name\":\"isDelegated\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"}],\"name\":\"isNotDelegated\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"operator\",\"type\":\"address\"}],\"name\":\"isOperator\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"nonces\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"},{\"internalType\":\"contract IDelegationShare\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"operatorShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IDelegationCallback\",\"name\":\"dt\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"registerAsOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IDelegationCallback\",\"name\":\"dt\",\"type\":\"address\"}],\"name\":\"registerAsOperator\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"toRemoveAddresses\",\"type\":\"address[]\"}],\"name\":\"removeFromWhitelist\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"setStakingSlash\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"stakingSlash\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"staker\",\"type\":\"address\"}],\"name\":\"undelegate\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"whitelist\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"decreaseDelegatedShares(address,address,uint256)\":{\"details\":\"Callable only by the InvestmentManager\"},\"delegateTo(address)\":{\"params\":{\"operator\":\"is the operator to whom staker (msg.sender) is delegating its assets\"}},\"delegateToSignature(address,address,uint256,bytes32,bytes32)\":{\"details\":\"requires that r, vs are a valid ECSDA signature from `staker` indicating their intention for this action\"},\"increaseDelegatedShares(address,address,uint256)\":{\"details\":\"Callable only by the InvestmentManager\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"paused()\":{\"details\":\"Returns true if the contract is paused, and false otherwise.\"},\"registerAsOperator(address)\":{\"details\":\"An operator can set `dt` equal to their own address (or another EOA address), in the event that they want to split payments in a more 'trustful' manner.In the present design, once set, there is no way for an operator to ever modify the address of their DelegationTerms contract.\",\"params\":{\"dt\":\"is the `DelegationTerms` contract that the operator has for those who delegate to them.\"}},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"undelegate(address)\":{\"details\":\"Should only ever be called in the event that the `staker` has no active deposits.\"}},\"title\":\"The primary delegation contract.\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"DELEGATION_TYPEHASH()\":{\"notice\":\"The EIP-712 typehash for the delegation struct used by the contract\"},\"DOMAIN_SEPARATOR()\":{\"notice\":\"EIP-712 Domain separator\"},\"DOMAIN_TYPEHASH()\":{\"notice\":\"The EIP-712 typehash for the contract's domain\"},\"addToWhitelist(address[])\":{\"notice\":\"Add to whitelist\"},\"decreaseDelegatedShares(address,address,uint256)\":{\"notice\":\"Decreases the `staker`'s delegated shares in `strategy` by `shares, typically called when the staker withdraws\"},\"decreaseDelegatedShares(address,address[],uint256[])\":{\"notice\":\"Version of `decreaseDelegatedShares` that accepts an array of inputs.\"},\"delegateTo(address)\":{\"notice\":\"This will be called by a staker to delegate its assets to some operator.\"},\"delegateToSignature(address,address,uint256,bytes32,bytes32)\":{\"notice\":\"Delegates from `staker` to `operator`.\"},\"delegatedTo(address)\":{\"notice\":\"returns the address of the operator that `staker` is delegated to.\"},\"delegationCallback(address)\":{\"notice\":\"returns the delegationCallback of the `operator`, which may mediate their interactions with stakers who delegate to them.\"},\"delegationManager()\":{\"notice\":\"The InvestmentManager contract\"},\"increaseDelegatedShares(address,address,uint256)\":{\"notice\":\"Increases the `staker`'s delegated shares in `strategy` by `shares, typically called when the staker has further deposits\"},\"isDelegated(address)\":{\"notice\":\"Returns 'true' if `staker` *is* actively delegated, and 'false' otherwise.\"},\"isNotDelegated(address)\":{\"notice\":\"Returns 'true' if `staker` is *not* actively delegated, and 'false' otherwise.\"},\"isOperator(address)\":{\"notice\":\"Returns if an operator can be delegated to, i.e. it has called `registerAsOperator`.\"},\"operatorShares(address,address)\":{\"notice\":\"returns the total number of shares in `DelegationShare` that are delegated to `operator`.\"},\"registerAsOperator(address)\":{\"notice\":\"This will be called by an operator to register itself as an operator that stakers can choose to delegate to.\"},\"removeFromWhitelist(address[])\":{\"notice\":\"Remove from whitelist\"},\"undelegate(address)\":{\"notice\":\"Undelegates `staker` from the operator who they are delegated to.Callable only by the InvestmentManager\"}},\"notice\":\"This is the contract for delegation. The main functionalities of this contract are - for enabling any staker to register as a delegate and specify the delegation terms it has agreed to - for enabling anyone to register as an operator - for a registered staker to delegate its stake to the operator of its agreed upon delegation terms contract - for a staker to undelegate its assets - for anyone to challenge a staker's claim to have fulfilled all its obligation before undelegation\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/L1/tss/delegation/TssDelegation.sol\":\"TssDelegation\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n function __Ownable_init() internal onlyInitializing {\\n __Ownable_init_unchained();\\n }\\n\\n function __Ownable_init_unchained() internal onlyInitializing {\\n _transferOwnership(_msgSender());\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n _checkOwner();\\n _;\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if the sender is not the owner.\\n */\\n function _checkOwner() internal view virtual {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _transferOwnership(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _transferOwnership(newOwner);\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Internal function without access restriction.\\n */\\n function _transferOwnership(address newOwner) internal virtual {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x247c62047745915c0af6b955470a72d1696ebad4352d7d3011aef1a2463cd888\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (proxy/utils/Initializable.sol)\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\\n * reused. This mechanism prevents re-execution of each \\\"step\\\" but allows the creation of new initialization steps in\\n * case an upgrade adds a module that needs to be initialized.\\n *\\n * For example:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * contract MyToken is ERC20Upgradeable {\\n * function initialize() initializer public {\\n * __ERC20_init(\\\"MyToken\\\", \\\"MTK\\\");\\n * }\\n * }\\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\\n * function initializeV2() reinitializer(2) public {\\n * __ERC20Permit_init(\\\"MyToken\\\");\\n * }\\n * }\\n * ```\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n *\\n * [CAUTION]\\n * ====\\n * Avoid leaving a contract uninitialized.\\n *\\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\\n *\\n * [.hljs-theme-light.nopadding]\\n * ```\\n * /// @custom:oz-upgrades-unsafe-allow constructor\\n * constructor() {\\n * _disableInitializers();\\n * }\\n * ```\\n * ====\\n */\\nabstract contract Initializable {\\n /**\\n * @dev Indicates that the contract has been initialized.\\n * @custom:oz-retyped-from bool\\n */\\n uint8 private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Triggered when the contract has been initialized or reinitialized.\\n */\\n event Initialized(uint8 version);\\n\\n /**\\n * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\\n * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.\\n */\\n modifier initializer() {\\n bool isTopLevelCall = !_initializing;\\n require(\\n (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\\n \\\"Initializable: contract is already initialized\\\"\\n );\\n _initialized = 1;\\n if (isTopLevelCall) {\\n _initializing = true;\\n }\\n _;\\n if (isTopLevelCall) {\\n _initializing = false;\\n emit Initialized(1);\\n }\\n }\\n\\n /**\\n * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\\n * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\\n * used to initialize parent contracts.\\n *\\n * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original\\n * initialization step. This is essential to configure modules that are added through upgrades and that require\\n * initialization.\\n *\\n * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\\n * a contract, executing them in the right order is up to the developer or operator.\\n */\\n modifier reinitializer(uint8 version) {\\n require(!_initializing && _initialized < version, \\\"Initializable: contract is already initialized\\\");\\n _initialized = version;\\n _initializing = true;\\n _;\\n _initializing = false;\\n emit Initialized(version);\\n }\\n\\n /**\\n * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\\n * {initializer} and {reinitializer} modifiers, directly or indirectly.\\n */\\n modifier onlyInitializing() {\\n require(_initializing, \\\"Initializable: contract is not initializing\\\");\\n _;\\n }\\n\\n /**\\n * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\\n * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\\n * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\\n * through proxies.\\n */\\n function _disableInitializers() internal virtual {\\n require(!_initializing, \\\"Initializable: contract is initializing\\\");\\n if (_initialized < type(uint8).max) {\\n _initialized = type(uint8).max;\\n emit Initialized(type(uint8).max);\\n }\\n }\\n}\\n\",\"keccak256\":\"0x0203dcadc5737d9ef2c211d6fa15d18ebc3b30dfa51903b64870b01a062b0b4e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/ContextUpgradeable.sol\\\";\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module which allows children to implement an emergency stop\\n * mechanism that can be triggered by an authorized account.\\n *\\n * This module is used through inheritance. It will make available the\\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\\n * the functions of your contract. Note that they will not be pausable by\\n * simply including this module, only once the modifiers are put in place.\\n */\\nabstract contract PausableUpgradeable is Initializable, ContextUpgradeable {\\n /**\\n * @dev Emitted when the pause is triggered by `account`.\\n */\\n event Paused(address account);\\n\\n /**\\n * @dev Emitted when the pause is lifted by `account`.\\n */\\n event Unpaused(address account);\\n\\n bool private _paused;\\n\\n /**\\n * @dev Initializes the contract in unpaused state.\\n */\\n function __Pausable_init() internal onlyInitializing {\\n __Pausable_init_unchained();\\n }\\n\\n function __Pausable_init_unchained() internal onlyInitializing {\\n _paused = false;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is not paused.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n modifier whenNotPaused() {\\n _requireNotPaused();\\n _;\\n }\\n\\n /**\\n * @dev Modifier to make a function callable only when the contract is paused.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n modifier whenPaused() {\\n _requirePaused();\\n _;\\n }\\n\\n /**\\n * @dev Returns true if the contract is paused, and false otherwise.\\n */\\n function paused() public view virtual returns (bool) {\\n return _paused;\\n }\\n\\n /**\\n * @dev Throws if the contract is paused.\\n */\\n function _requireNotPaused() internal view virtual {\\n require(!paused(), \\\"Pausable: paused\\\");\\n }\\n\\n /**\\n * @dev Throws if the contract is not paused.\\n */\\n function _requirePaused() internal view virtual {\\n require(paused(), \\\"Pausable: not paused\\\");\\n }\\n\\n /**\\n * @dev Triggers stopped state.\\n *\\n * Requirements:\\n *\\n * - The contract must not be paused.\\n */\\n function _pause() internal virtual whenNotPaused {\\n _paused = true;\\n emit Paused(_msgSender());\\n }\\n\\n /**\\n * @dev Returns to normal state.\\n *\\n * Requirements:\\n *\\n * - The contract must be paused.\\n */\\n function _unpause() internal virtual whenPaused {\\n _paused = false;\\n emit Unpaused(_msgSender());\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[49] private __gap;\\n}\\n\",\"keccak256\":\"0x40c636b4572ff5f1dc50cf22097e93c0723ee14eff87e99ac2b02636eeca1250\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\\n\\npragma solidity ^0.8.1;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n *\\n * [IMPORTANT]\\n * ====\\n * You shouldn't rely on `isContract` to protect against flash loan attacks!\\n *\\n * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\\n * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\\n * constructor.\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize/address.code.length, which returns 0\\n // for contracts in construction, since the code is only stored at the end\\n // of the constructor execution.\\n\\n return account.code.length > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n (bool success, ) = recipient.call{value: amount}(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain `call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value\\n ) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(\\n address target,\\n bytes memory data,\\n uint256 value,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.call{value: value}(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\\n * revert reason using the provided one.\\n *\\n * _Available since v4.3._\\n */\\n function verifyCallResult(\\n bool success,\\n bytes memory returndata,\\n string memory errorMessage\\n ) internal pure returns (bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n /// @solidity memory-safe-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0x611aa3f23e59cfdd1863c536776407b3e33d695152a266fa7cfb34440a29a8a3\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract ContextUpgradeable is Initializable {\\n function __Context_init() internal onlyInitializing {\\n }\\n\\n function __Context_init_unchained() internal onlyInitializing {\\n }\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n\\n /**\\n * @dev This empty reserved space is put in place to allow future versions to add new\\n * variables without shifting down storage in the inheritance chain.\\n * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\\n */\\n uint256[50] private __gap;\\n}\\n\",\"keccak256\":\"0x963ea7f0b48b032eef72fe3a7582edf78408d6f834115b9feadd673a4d5bd149\",\"license\":\"MIT\"},\"@openzeppelin/contracts/access/Ownable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../utils/Context.sol\\\";\\n\\n/**\\n * @dev Contract module which provides a basic access control mechanism, where\\n * there is an account (an owner) that can be granted exclusive access to\\n * specific functions.\\n *\\n * By default, the owner account will be the one that deploys the contract. This\\n * can later be changed with {transferOwnership}.\\n *\\n * This module is used through inheritance. It will make available the modifier\\n * `onlyOwner`, which can be applied to your functions to restrict their use to\\n * the owner.\\n */\\nabstract contract Ownable is Context {\\n address private _owner;\\n\\n event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\\n\\n /**\\n * @dev Initializes the contract setting the deployer as the initial owner.\\n */\\n constructor() {\\n _setOwner(_msgSender());\\n }\\n\\n /**\\n * @dev Returns the address of the current owner.\\n */\\n function owner() public view virtual returns (address) {\\n return _owner;\\n }\\n\\n /**\\n * @dev Throws if called by any account other than the owner.\\n */\\n modifier onlyOwner() {\\n require(owner() == _msgSender(), \\\"Ownable: caller is not the owner\\\");\\n _;\\n }\\n\\n /**\\n * @dev Leaves the contract without owner. It will not be possible to call\\n * `onlyOwner` functions anymore. Can only be called by the current owner.\\n *\\n * NOTE: Renouncing ownership will leave the contract without an owner,\\n * thereby removing any functionality that is only available to the owner.\\n */\\n function renounceOwnership() public virtual onlyOwner {\\n _setOwner(address(0));\\n }\\n\\n /**\\n * @dev Transfers ownership of the contract to a new account (`newOwner`).\\n * Can only be called by the current owner.\\n */\\n function transferOwnership(address newOwner) public virtual onlyOwner {\\n require(newOwner != address(0), \\\"Ownable: new owner is the zero address\\\");\\n _setOwner(newOwner);\\n }\\n\\n function _setOwner(address newOwner) private {\\n address oldOwner = _owner;\\n _owner = newOwner;\\n emit OwnershipTransferred(oldOwner, newOwner);\\n }\\n}\\n\",\"keccak256\":\"0x6bb804a310218875e89d12c053e94a13a4607cdf7cc2052f3e52bd32a0dc50a1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20 {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(\\n address sender,\\n address recipient,\\n uint256 amount\\n ) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0x027b891937d20ccf213fdb9c31531574256de774bda99d3a70ecef6e1913ed2a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Context.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Provides information about the current execution context, including the\\n * sender of the transaction and its data. While these are generally available\\n * via msg.sender and msg.data, they should not be accessed in such a direct\\n * manner, since when dealing with meta-transactions the account sending and\\n * paying for execution may not be the actual sender (as far as an application\\n * is concerned).\\n *\\n * This contract is only required for intermediate, library-like contracts.\\n */\\nabstract contract Context {\\n function _msgSender() internal view virtual returns (address) {\\n return msg.sender;\\n }\\n\\n function _msgData() internal view virtual returns (bytes calldata) {\\n return msg.data;\\n }\\n}\\n\",\"keccak256\":\"0x90565a39ae45c80f0468dc96c7b20d0afc3055f344c8203a0c9258239f350b9f\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\\n *\\n * These functions can be used to verify that a message was signed by the holder\\n * of the private keys of a given address.\\n */\\nlibrary ECDSA {\\n enum RecoverError {\\n NoError,\\n InvalidSignature,\\n InvalidSignatureLength,\\n InvalidSignatureS,\\n InvalidSignatureV\\n }\\n\\n function _throwError(RecoverError error) private pure {\\n if (error == RecoverError.NoError) {\\n return; // no error: do nothing\\n } else if (error == RecoverError.InvalidSignature) {\\n revert(\\\"ECDSA: invalid signature\\\");\\n } else if (error == RecoverError.InvalidSignatureLength) {\\n revert(\\\"ECDSA: invalid signature length\\\");\\n } else if (error == RecoverError.InvalidSignatureS) {\\n revert(\\\"ECDSA: invalid signature 's' value\\\");\\n } else if (error == RecoverError.InvalidSignatureV) {\\n revert(\\\"ECDSA: invalid signature 'v' value\\\");\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature` or error string. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n *\\n * Documentation for signature generation:\\n * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\\n * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {\\n // Check the signature length\\n // - case 65: r,s,v signature (standard)\\n // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._\\n if (signature.length == 65) {\\n bytes32 r;\\n bytes32 s;\\n uint8 v;\\n // ecrecover takes the signature parameters, and the only way to get them\\n // currently is to use assembly.\\n assembly {\\n r := mload(add(signature, 0x20))\\n s := mload(add(signature, 0x40))\\n v := byte(0, mload(add(signature, 0x60)))\\n }\\n return tryRecover(hash, v, r, s);\\n } else if (signature.length == 64) {\\n bytes32 r;\\n bytes32 vs;\\n // ecrecover takes the signature parameters, and the only way to get them\\n // currently is to use assembly.\\n assembly {\\n r := mload(add(signature, 0x20))\\n vs := mload(add(signature, 0x40))\\n }\\n return tryRecover(hash, r, vs);\\n } else {\\n return (address(0), RecoverError.InvalidSignatureLength);\\n }\\n }\\n\\n /**\\n * @dev Returns the address that signed a hashed message (`hash`) with\\n * `signature`. This address can then be used for verification purposes.\\n *\\n * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\\n * this function rejects them by requiring the `s` value to be in the lower\\n * half order, and the `v` value to be either 27 or 28.\\n *\\n * IMPORTANT: `hash` _must_ be the result of a hash operation for the\\n * verification to be secure: it is possible to craft signatures that\\n * recover to arbitrary addresses for non-hashed data. A safe way to ensure\\n * this is by receiving a hash of the original message (which may otherwise\\n * be too long), and then calling {toEthSignedMessageHash} on it.\\n */\\n function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, signature);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\\n *\\n * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address, RecoverError) {\\n bytes32 s;\\n uint8 v;\\n assembly {\\n s := and(vs, 0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)\\n v := add(shr(255, vs), 27)\\n }\\n return tryRecover(hash, v, r, s);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\\n *\\n * _Available since v4.2._\\n */\\n function recover(\\n bytes32 hash,\\n bytes32 r,\\n bytes32 vs\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, r, vs);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n *\\n * _Available since v4.3._\\n */\\n function tryRecover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address, RecoverError) {\\n // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\\n // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\\n // the valid range for s in (301): 0 < s < secp256k1n \\u00f7 2 + 1, and for v in (302): v \\u2208 {27, 28}. Most\\n // signatures from current libraries generate a unique signature with an s-value in the lower half order.\\n //\\n // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\\n // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\\n // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\\n // these malleable signatures as well.\\n if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\\n return (address(0), RecoverError.InvalidSignatureS);\\n }\\n if (v != 27 && v != 28) {\\n return (address(0), RecoverError.InvalidSignatureV);\\n }\\n\\n // If the signature is valid (and not malleable), return the signer address\\n address signer = ecrecover(hash, v, r, s);\\n if (signer == address(0)) {\\n return (address(0), RecoverError.InvalidSignature);\\n }\\n\\n return (signer, RecoverError.NoError);\\n }\\n\\n /**\\n * @dev Overload of {ECDSA-recover} that receives the `v`,\\n * `r` and `s` signature fields separately.\\n */\\n function recover(\\n bytes32 hash,\\n uint8 v,\\n bytes32 r,\\n bytes32 s\\n ) internal pure returns (address) {\\n (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\\n _throwError(error);\\n return recovered;\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Message, created from a `hash`. This\\n * produces hash corresponding to the one signed with the\\n * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\\n * JSON-RPC method as part of EIP-191.\\n *\\n * See {recover}.\\n */\\n function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\\n // 32 is the length in bytes of hash,\\n // enforced by the type signature above\\n return keccak256(abi.encodePacked(\\\"\\\\x19Ethereum Signed Message:\\\\n32\\\", hash));\\n }\\n\\n /**\\n * @dev Returns an Ethereum Signed Typed Data, created from a\\n * `domainSeparator` and a `structHash`. This produces hash corresponding\\n * to the one signed with the\\n * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\\n * JSON-RPC method as part of EIP-712.\\n *\\n * See {recover}.\\n */\\n function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", domainSeparator, structHash));\\n }\\n}\\n\",\"keccak256\":\"0xbc991a1cf357ce19480831a40792c814238a3b5458134703682abd8aa39719fb\",\"license\":\"MIT\"},\"contracts/L1/delegation/Delegation.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts/access/Ownable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\n\\nimport \\\"./DelegationStorage.sol\\\";\\nimport \\\"./DelegationSlasher.sol\\\";\\nimport \\\"./WhiteListBase.sol\\\";\\n/**\\n * @title The primary delegation contract.\\n * @notice This is the contract for delegation. The main functionalities of this contract are\\n * - for enabling any staker to register as a delegate and specify the delegation terms it has agreed to\\n * - for enabling anyone to register as an operator\\n * - for a registered staker to delegate its stake to the operator of its agreed upon delegation terms contract\\n * - for a staker to undelegate its assets\\n * - for anyone to challenge a staker's claim to have fulfilled all its obligation before undelegation\\n */\\nabstract contract Delegation is Initializable, OwnableUpgradeable, PausableUpgradeable, WhiteList, DelegationStorage {\\n /// @notice Simple permission for functions that are only callable by the InvestmentManager contract.\\n modifier onlyDelegationManager() {\\n require(msg.sender == address(delegationManager), \\\"onlyDelegationManager\\\");\\n _;\\n }\\n\\n // INITIALIZING FUNCTIONS\\n constructor(IDelegationManager _delegationManager)\\n DelegationStorage(_delegationManager)\\n {\\n _disableInitializers();\\n }\\n\\n /// @dev Emitted when a low-level call to `delegationTerms.onDelegationReceived` fails, returning `returnData`\\n event OnDelegationReceivedCallFailure(IDelegationCallback indexed delegationTerms, bytes32 returnData);\\n\\n /// @dev Emitted when a low-level call to `delegationTerms.onDelegationWithdrawn` fails, returning `returnData`\\n event OnDelegationWithdrawnCallFailure(IDelegationCallback indexed delegationTerms, bytes32 returnData);\\n\\n event RegisterOperator(address delegationCallback, address register);\\n\\n event DelegateTo(address delegatior, address operator);\\n\\n event DecreaseDelegatedShares(address delegatedShare, address operator, uint256 share);\\n\\n event IncreaseDelegatedShares(address delegatedShare, address operator, uint256 share);\\n\\n function initialize(address initialOwner)\\n external\\n initializer\\n {\\n DOMAIN_SEPARATOR = keccak256(abi.encode(DOMAIN_TYPEHASH, bytes(\\\"Mantle\\\"), block.chainid, address(this)));\\n _transferOwnership(initialOwner);\\n }\\n\\n // PERMISSION FUNCTIONS\\n function pause() external onlyOwner {\\n _pause();\\n }\\n\\n function unpause() external onlyOwner {\\n _unpause();\\n }\\n\\n // EXTERNAL FUNCTIONS\\n /**\\n * @notice This will be called by an operator to register itself as an operator that stakers can choose to delegate to.\\n * @param dt is the `DelegationTerms` contract that the operator has for those who delegate to them.\\n * @dev An operator can set `dt` equal to their own address (or another EOA address), in the event that they want to split payments\\n * in a more 'trustful' manner.\\n * @dev In the present design, once set, there is no way for an operator to ever modify the address of their DelegationTerms contract.\\n */\\n function registerAsOperator(IDelegationCallback dt) external whitelistOnly(msg.sender) {\\n require(\\n address(delegationCallback[msg.sender]) == address(0),\\n \\\"Delegation.registerAsOperator: Delegate has already registered\\\"\\n );\\n // store the address of the delegation contract that the operator is providing.\\n delegationCallback[msg.sender] = dt;\\n _delegate(msg.sender, msg.sender);\\n emit RegisterOperator(address(dt),msg.sender);\\n }\\n\\n /**\\n * @notice This will be called by a staker to delegate its assets to some operator.\\n * @param operator is the operator to whom staker (msg.sender) is delegating its assets\\n */\\n function delegateTo(address operator) external whenNotPaused {\\n _delegate(msg.sender, operator);\\n }\\n\\n /**\\n * @notice Delegates from `staker` to `operator`.\\n * @dev requires that r, vs are a valid ECSDA signature from `staker` indicating their intention for this action\\n */\\n function delegateToSignature(address staker, address operator, uint256 expiry, bytes32 r, bytes32 vs)\\n external\\n whenNotPaused\\n {\\n require(expiry == 0 || expiry >= block.timestamp, \\\"delegation signature expired\\\");\\n // calculate struct hash, then increment `staker`'s nonce\\n // EIP-712 standard\\n bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, staker, operator, nonces[staker]++, expiry));\\n bytes32 digestHash = keccak256(abi.encodePacked(\\\"\\\\x19\\\\x01\\\", DOMAIN_SEPARATOR, structHash));\\n //check validity of signature\\n\\n address recoveredAddress = ECDSA.recover(digestHash, r, vs);\\n\\n require(recoveredAddress == staker, \\\"Delegation.delegateToBySignature: sig not from staker\\\");\\n _delegate(staker, operator);\\n }\\n\\n /**\\n * @notice Undelegates `staker` from the operator who they are delegated to.\\n * @notice Callable only by the InvestmentManager\\n * @dev Should only ever be called in the event that the `staker` has no active deposits.\\n */\\n function undelegate(address staker) external onlyDelegationManager {\\n delegationStatus[staker] = DelegationStatus.UNDELEGATED;\\n delegatedTo[staker] = address(0);\\n }\\n\\n /**\\n * @notice Increases the `staker`'s delegated shares in `strategy` by `shares, typically called when the staker has further deposits\\n * @dev Callable only by the InvestmentManager\\n */\\n function increaseDelegatedShares(address staker, IDelegationShare delegationShare, uint256 shares)\\n external\\n onlyDelegationManager\\n {\\n //if the staker is delegated to an operator\\n if (isDelegated(staker)) {\\n address operator = delegatedTo[staker];\\n\\n // add strategy shares to delegate's shares\\n operatorShares[operator][delegationShare] += shares;\\n\\n //Calls into operator's delegationTerms contract to update weights of individual staker\\n IDelegationShare[] memory investorDelegations = new IDelegationShare[](1);\\n uint256[] memory investorShares = new uint[](1);\\n investorDelegations[0] = delegationShare;\\n investorShares[0] = shares;\\n\\n // call into hook in delegationCallback contract\\n IDelegationCallback dt = delegationCallback[operator];\\n _delegationReceivedHook(dt, staker, operator, investorDelegations, investorShares);\\n emit IncreaseDelegatedShares(address(delegationShare), operator, shares);\\n }\\n }\\n\\n /**\\n * @notice Decreases the `staker`'s delegated shares in `strategy` by `shares, typically called when the staker withdraws\\n * @dev Callable only by the InvestmentManager\\n */\\n function decreaseDelegatedShares(address staker, IDelegationShare delegationShare, uint256 shares)\\n external\\n onlyDelegationManager\\n {\\n //if the staker is delegated to an operator\\n if (isDelegated(staker)) {\\n address operator = delegatedTo[staker];\\n\\n // subtract strategy shares from delegate's shares\\n operatorShares[operator][delegationShare] -= shares;\\n\\n //Calls into operator's delegationCallback contract to update weights of individual staker\\n IDelegationShare[] memory investorDelegationShares = new IDelegationShare[](1);\\n uint256[] memory investorShares = new uint[](1);\\n investorDelegationShares[0] = delegationShare;\\n investorShares[0] = shares;\\n\\n // call into hook in delegationCallback contract\\n IDelegationCallback dt = delegationCallback[operator];\\n _delegationWithdrawnHook(dt, staker, operator, investorDelegationShares, investorShares);\\n emit DecreaseDelegatedShares(address(delegationShare), operator, shares);\\n }\\n }\\n\\n /// @notice Version of `decreaseDelegatedShares` that accepts an array of inputs.\\n function decreaseDelegatedShares(\\n address staker,\\n IDelegationShare[] calldata strategies,\\n uint256[] calldata shares\\n )\\n external\\n onlyDelegationManager\\n {\\n if (isDelegated(staker)) {\\n address operator = delegatedTo[staker];\\n\\n // subtract strategy shares from delegate's shares\\n uint256 stratsLength = strategies.length;\\n for (uint256 i = 0; i < stratsLength;) {\\n operatorShares[operator][strategies[i]] -= shares[i];\\n emit DecreaseDelegatedShares(address(strategies[i]), operator, shares[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n\\n // call into hook in delegationCallback contract\\n IDelegationCallback dt = delegationCallback[operator];\\n _delegationWithdrawnHook(dt, staker, operator, strategies, shares);\\n }\\n }\\n\\n // INTERNAL FUNCTIONS\\n\\n /**\\n * @notice Makes a low-level call to `dt.onDelegationReceived(staker, strategies, shares)`, ignoring reverts and with a gas budget\\n * equal to `LOW_LEVEL_GAS_BUDGET` (a constant defined in this contract).\\n * @dev *If* the low-level call fails, then this function emits the event `OnDelegationReceivedCallFailure(dt, returnData)`, where\\n * `returnData` is *only the first 32 bytes* returned by the call to `dt`.\\n */\\n function _delegationReceivedHook(\\n IDelegationCallback dt,\\n address staker,\\n address operator,\\n IDelegationShare[] memory delegationShares,\\n uint256[] memory shares\\n )\\n internal\\n {\\n /**\\n * We use low-level call functionality here to ensure that an operator cannot maliciously make this function fail in order to prevent undelegation.\\n * In particular, in-line assembly is also used to prevent the copying of uncapped return data which is also a potential DoS vector.\\n */\\n // format calldata\\n (bool success, bytes memory returnData) = address(dt).call{gas: LOW_LEVEL_GAS_BUDGET}(\\n abi.encodeWithSelector(IDelegationCallback.onDelegationReceived.selector, staker, operator, delegationShares, shares)\\n );\\n\\n // if the call fails, we emit a special event rather than reverting\\n if (!success) {\\n emit OnDelegationReceivedCallFailure(dt, returnData[0]);\\n }\\n }\\n\\n /**\\n * @notice Makes a low-level call to `dt.onDelegationWithdrawn(staker, strategies, shares)`, ignoring reverts and with a gas budget\\n * equal to `LOW_LEVEL_GAS_BUDGET` (a constant defined in this contract).\\n * @dev *If* the low-level call fails, then this function emits the event `OnDelegationReceivedCallFailure(dt, returnData)`, where\\n * `returnData` is *only the first 32 bytes* returned by the call to `dt`.\\n */\\n function _delegationWithdrawnHook(\\n IDelegationCallback dt,\\n address staker,\\n address operator,\\n IDelegationShare[] memory delegationShares,\\n uint256[] memory shares\\n )\\n internal\\n {\\n /**\\n * We use low-level call functionality here to ensure that an operator cannot maliciously make this function fail in order to prevent undelegation.\\n * In particular, in-line assembly is also used to prevent the copying of uncapped return data which is also a potential DoS vector.\\n */\\n\\n (bool success, bytes memory returnData) = address(dt).call{gas: LOW_LEVEL_GAS_BUDGET}(\\n abi.encodeWithSelector(IDelegationCallback.onDelegationWithdrawn.selector, staker, operator, delegationShares, shares)\\n );\\n\\n // if the call fails, we emit a special event rather than reverting\\n if (!success) {\\n emit OnDelegationWithdrawnCallFailure(dt, returnData[0]);\\n }\\n }\\n\\n /**\\n * @notice Internal function implementing the delegation *from* `staker` *to* `operator`.\\n * @param staker The address to delegate *from* -- this address is delegating control of its own assets.\\n * @param operator The address to delegate *to* -- this address is being given power to place the `staker`'s assets at risk on services\\n * @dev Ensures that the operator has registered as a delegate (`address(dt) != address(0)`), verifies that `staker` is not already\\n * delegated, and records the new delegation.\\n */\\n function _delegate(address staker, address operator) internal {\\n\\n IDelegationCallback dt = delegationCallback[operator];\\n require(\\n address(dt) != address(0), \\\"Delegation._delegate: operator has not yet registered as a delegate\\\"\\n );\\n require(isNotDelegated(staker), \\\"Delegation._delegate: staker has existing delegation\\\");\\n\\n // checks that operator has not been frozen\\n IDelegationSlasher slasher = delegationManager.delegationSlasher();\\n require(!slasher.isFrozen(operator), \\\"Delegation._delegate: cannot delegate to a frozen operator\\\");\\n // record delegation relation between the staker and operator\\n delegatedTo[staker] = operator;\\n\\n // record that the staker is delegated\\n delegationStatus[staker] = DelegationStatus.DELEGATED;\\n // retrieve list of strategies and their shares from investment manager\\n (IDelegationShare[] memory delegationShares, uint256[] memory shares) = delegationManager.getDeposits(staker);\\n\\n // add strategy shares to delegate's shares\\n uint256 delegationLength = delegationShares.length;\\n for (uint256 i = 0; i < delegationLength;) {\\n // update the share amounts for each of the operator's strategies\\n operatorShares[operator][delegationShares[i]] += shares[i];\\n unchecked {\\n ++i;\\n }\\n }\\n // call into hook in delegationCallback contract\\n _delegationReceivedHook(dt, staker, operator, delegationShares, shares);\\n emit DelegateTo(staker, operator);\\n }\\n\\n // VIEW FUNCTIONS\\n\\n /// @notice Returns 'true' if `staker` *is* actively delegated, and 'false' otherwise.\\n function isDelegated(address staker) public view returns (bool) {\\n return (delegationStatus[staker] == DelegationStatus.DELEGATED);\\n }\\n\\n /// @notice Returns 'true' if `staker` is *not* actively delegated, and 'false' otherwise.\\n function isNotDelegated(address staker) public view returns (bool) {\\n return (delegationStatus[staker] == DelegationStatus.UNDELEGATED);\\n }\\n\\n /// @notice Returns if an operator can be delegated to, i.e. it has called `registerAsOperator`.\\n function isOperator(address operator) external view returns (bool) {\\n return (address(delegationCallback[operator]) != address(0));\\n }\\n}\\n\",\"keccak256\":\"0xc4066c4ef2aeb305a90635c4d9cf09603747c14970dfa8eb3486fbd2bea2b7d1\",\"license\":\"MIT\"},\"contracts/L1/delegation/DelegationSlasher.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\n\\nimport { PausableUpgradeable } from \\\"@openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol\\\";\\n\\nimport \\\"./interfaces/IDelegationSlasher.sol\\\";\\nimport \\\"./interfaces/IDelegation.sol\\\";\\nimport \\\"./interfaces/IDelegationManager.sol\\\";\\n\\n/**\\n * @title The primary 'slashing' contract.\\n * @notice This contract specifies details on slashing. The functionalities are:\\n * - adding contracts who have permission to perform slashing,\\n * - revoking permission for slashing from specified contracts,\\n * - calling investManager to do actual slashing.\\n */\\nabstract contract DelegationSlasher is Initializable, OwnableUpgradeable, PausableUpgradeable, IDelegationSlasher {\\n // ,DSTest\\n /// @notice The central InvestmentManager contract\\n IDelegationManager public immutable investmentManager;\\n /// @notice The Delegation contract\\n IDelegation public immutable delegation;\\n // contract address => whether or not the contract is allowed to slash any staker (or operator)\\n mapping(address => bool) public globallyPermissionedContracts;\\n // user => contract => the time before which the contract is allowed to slash the user\\n mapping(address => mapping(address => uint32)) public bondedUntil;\\n // staker => if their funds are 'frozen' and potentially subject to slashing or not\\n mapping(address => bool) internal frozenStatus;\\n\\n uint32 internal constant MAX_BONDED_UNTIL = type(uint32).max;\\n\\n event GloballyPermissionedContractAdded(address indexed contractAdded);\\n event GloballyPermissionedContractRemoved(address indexed contractRemoved);\\n event OptedIntoSlashing(address indexed operator, address indexed contractAddress);\\n event SlashingAbilityRevoked(address indexed operator, address indexed contractAddress, uint32 unbondedAfter);\\n event OperatorSlashed(address indexed slashedOperator, address indexed slashingContract);\\n event FrozenStatusReset(address indexed previouslySlashedAddress);\\n\\n constructor(IDelegationManager _investmentManager, IDelegation _delegation) {\\n investmentManager = _investmentManager;\\n delegation = _delegation;\\n _disableInitializers();\\n }\\n\\n // EXTERNAL FUNCTIONS\\n function initialize(\\n address initialOwner\\n ) external initializer {\\n _transferOwnership(initialOwner);\\n // add InvestmentManager & Delegation to list of permissioned contracts\\n _addGloballyPermissionedContract(address(investmentManager));\\n _addGloballyPermissionedContract(address(delegation));\\n }\\n\\n /**\\n * @notice Gives the `contractAddress` permission to slash the funds of the caller.\\n * @dev Typically, this function must be called prior to registering for a middleware.\\n */\\n function allowToSlash(address contractAddress) external {\\n _optIntoSlashing(msg.sender, contractAddress);\\n }\\n\\n /*\\n TODO: we still need to figure out how/when to appropriately call this function\\n perhaps a registry can safely call this function after an operator has been deregistered for a very safe amount of time (like a month)\\n */\\n /// @notice Called by a contract to revoke its ability to slash `operator`, once `unbondedAfter` is reached.\\n function revokeSlashingAbility(address operator, uint32 unbondedAfter) external {\\n _revokeSlashingAbility(operator, msg.sender, unbondedAfter);\\n }\\n\\n /**\\n * @notice Used for 'slashing' a certain operator.\\n * @param toBeFrozen The operator to be frozen.\\n * @dev Technically the operator is 'frozen' (hence the name of this function), and then subject to slashing pending a decision by a human-in-the-loop.\\n * @dev The operator must have previously given the caller (which should be a contract) the ability to slash them, through a call to `allowToSlash`.\\n */\\n function freezeOperator(address toBeFrozen) external whenNotPaused {\\n require(\\n canSlash(toBeFrozen, msg.sender),\\n \\\"Slasher.freezeOperator: msg.sender does not have permission to slash this operator\\\"\\n );\\n _freezeOperator(toBeFrozen, msg.sender);\\n }\\n\\n /**\\n * @notice Used to give global slashing permission to `contracts`.\\n * @dev Callable only by the contract owner (i.e. governance).\\n */\\n function addGloballyPermissionedContracts(address[] calldata contracts) external onlyOwner {\\n for (uint256 i = 0; i < contracts.length;) {\\n _addGloballyPermissionedContract(contracts[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /**\\n * @notice Used to revoke global slashing permission from `contracts`.\\n * @dev Callable only by the contract owner (i.e. governance).\\n */\\n function removeGloballyPermissionedContracts(address[] calldata contracts) external onlyOwner {\\n for (uint256 i = 0; i < contracts.length;) {\\n _removeGloballyPermissionedContract(contracts[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n /**\\n * @notice Removes the 'frozen' status from each of the `frozenAddresses`\\n * @dev Callable only by the contract owner (i.e. governance).\\n */\\n function resetFrozenStatus(address[] calldata frozenAddresses) external onlyOwner {\\n for (uint256 i = 0; i < frozenAddresses.length;) {\\n _resetFrozenStatus(frozenAddresses[i]);\\n unchecked {\\n ++i;\\n }\\n }\\n }\\n\\n // INTERNAL FUNCTIONS\\n function _optIntoSlashing(address operator, address contractAddress) internal {\\n //allow the contract to slash anytime before a time VERY far in the future\\n bondedUntil[operator][contractAddress] = MAX_BONDED_UNTIL;\\n emit OptedIntoSlashing(operator, contractAddress);\\n }\\n\\n function _revokeSlashingAbility(address operator, address contractAddress, uint32 unbondedAfter) internal {\\n if (bondedUntil[operator][contractAddress] == MAX_BONDED_UNTIL) {\\n //contractAddress can now only slash operator before unbondedAfter\\n bondedUntil[operator][contractAddress] = unbondedAfter;\\n emit SlashingAbilityRevoked(operator, contractAddress, unbondedAfter);\\n }\\n }\\n\\n function _addGloballyPermissionedContract(address contractToAdd) internal {\\n if (!globallyPermissionedContracts[contractToAdd]) {\\n globallyPermissionedContracts[contractToAdd] = true;\\n emit GloballyPermissionedContractAdded(contractToAdd);\\n }\\n }\\n\\n function _removeGloballyPermissionedContract(address contractToRemove) internal {\\n if (globallyPermissionedContracts[contractToRemove]) {\\n globallyPermissionedContracts[contractToRemove] = false;\\n emit GloballyPermissionedContractRemoved(contractToRemove);\\n }\\n }\\n\\n function _freezeOperator(address toBeFrozen, address slashingContract) internal {\\n if (!frozenStatus[toBeFrozen]) {\\n frozenStatus[toBeFrozen] = true;\\n emit OperatorSlashed(toBeFrozen, slashingContract);\\n }\\n }\\n\\n function _resetFrozenStatus(address previouslySlashedAddress) internal {\\n if (frozenStatus[previouslySlashedAddress]) {\\n frozenStatus[previouslySlashedAddress] = false;\\n emit FrozenStatusReset(previouslySlashedAddress);\\n }\\n }\\n\\n // VIEW FUNCTIONS\\n /**\\n * @notice Used to determine whether `staker` is actively 'frozen'. If a staker is frozen, then they are potentially subject to\\n * slashing of their funds, and cannot cannot deposit or withdraw from the investmentManager until the slashing process is completed\\n * and the staker's status is reset (to 'unfrozen').\\n * @return Returns 'true' if `staker` themselves has their status set to frozen, OR if the staker is delegated\\n * to an operator who has their status set to frozen. Otherwise returns 'false'.\\n */\\n function isFrozen(address staker) external view returns (bool) {\\n if (frozenStatus[staker]) {\\n return true;\\n } else if (delegation.isDelegated(staker)) {\\n address operatorAddress = delegation.delegatedTo(staker);\\n return (frozenStatus[operatorAddress]);\\n } else {\\n return false;\\n }\\n }\\n\\n /// @notice Returns true if `slashingContract` is currently allowed to slash `toBeSlashed`.\\n function canSlash(address toBeSlashed, address slashingContract) public view returns (bool) {\\n if (globallyPermissionedContracts[slashingContract]) {\\n return true;\\n } else if (block.timestamp < bondedUntil[toBeSlashed][slashingContract]) {\\n return true;\\n } else {\\n return false;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xb845bf8a425b107cfbd0b0e769d660dbde0f22f2ac421985663aacf78d2c5aac\",\"license\":\"MIT\"},\"contracts/L1/delegation/DelegationStorage.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"./interfaces/IDelegationManager.sol\\\";\\nimport \\\"./interfaces/IDelegationCallback.sol\\\";\\nimport \\\"./interfaces/IDelegation.sol\\\";\\n\\n/**\\n * @title Storage variables for the `Delegation` contract.\\n * @author Layr Labs, Inc.\\n * @notice This storage contract is separate from the logic to simplify the upgrade process.\\n */\\nabstract contract DelegationStorage is IDelegation {\\n /// @notice Gas budget provided in calls to DelegationTerms contracts\\n uint256 internal constant LOW_LEVEL_GAS_BUDGET = 1e5;\\n\\n /// @notice The EIP-712 typehash for the contract's domain\\n bytes32 public constant DOMAIN_TYPEHASH =\\n keccak256(\\\"EIP712Domain(string name,uint256 chainId,address verifyingContract)\\\");\\n\\n /// @notice The EIP-712 typehash for the delegation struct used by the contract\\n bytes32 public constant DELEGATION_TYPEHASH =\\n keccak256(\\\"Delegation(address delegator,address operator,uint256 nonce,uint256 expiry)\\\");\\n\\n /// @notice EIP-712 Domain separator\\n bytes32 public DOMAIN_SEPARATOR;\\n\\n /// @notice The InvestmentManager contract\\n IDelegationManager public immutable delegationManager;\\n\\n // operator => investment strategy => total number of shares delegated to them\\n mapping(address => mapping(IDelegationShare => uint256)) public operatorShares;\\n\\n // operator => delegation terms contract\\n mapping(address => IDelegationCallback) public delegationCallback;\\n\\n // staker => operator\\n mapping(address => address) public delegatedTo;\\n\\n // staker => whether they are delegated or not\\n mapping(address => IDelegation.DelegationStatus) public delegationStatus;\\n\\n // delegator => number of signed delegation nonce (used in delegateToBySignature)\\n mapping(address => uint256) public nonces;\\n\\n constructor(IDelegationManager _investmentManager) {\\n delegationManager = _investmentManager;\\n }\\n}\\n\",\"keccak256\":\"0x67e031ef0cf500e43d7304093de36858b5967a2edee0398256849bc0256674bb\",\"license\":\"MIT\"},\"contracts/L1/delegation/WhiteListBase.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\n\\nabstract contract WhiteList is OwnableUpgradeable {\\n modifier whitelistOnly(address checkAddr) {\\n if (!whitelist[checkAddr]) {\\n revert(\\\"NOT_IN_WHITELIST\\\");\\n }\\n _;\\n }\\n\\n mapping(address => bool) public whitelist;\\n\\n /**\\n * @notice Add to whitelist\\n */\\n function addToWhitelist(address[] calldata toAddAddresses) external onlyOwner {\\n for (uint i = 0; i < toAddAddresses.length; i++) {\\n whitelist[toAddAddresses[i]] = true;\\n }\\n }\\n\\n /**\\n * @notice Remove from whitelist\\n */\\n function removeFromWhitelist(address[] calldata toRemoveAddresses) external onlyOwner {\\n for (uint i = 0; i < toRemoveAddresses.length; i++) {\\n delete whitelist[toRemoveAddresses[i]];\\n }\\n }\\n}\\n\",\"keccak256\":\"0x4a046eb1133e2e94b6743056d6b2067d221b88e1093b1a2deaf0068ebbf29059\",\"license\":\"MIT\"},\"contracts/L1/delegation/interfaces/IDelegation.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"./IDelegationCallback.sol\\\";\\n\\n/**\\n * @title Interface for the primary delegation contract.\\n * @notice See the `Delegation` contract itself for implementation details.\\n */\\ninterface IDelegation {\\n enum DelegationStatus {\\n UNDELEGATED,\\n DELEGATED\\n }\\n\\n /**\\n * @notice This will be called by an operator to register itself as an operator that stakers can choose to delegate to.\\n * @param dt is the `DelegationTerms` contract that the operator has for those who delegate to them.\\n * @dev An operator can set `dt` equal to their own address (or another EOA address), in the event that they want to split payments\\n * in a more 'trustful' manner.\\n * @dev In the present design, once set, there is no way for an operator to ever modify the address of their DelegationTerms contract.\\n */\\n function registerAsOperator(IDelegationCallback dt) external;\\n\\n /**\\n * @notice This will be called by a staker to delegate its assets to some operator.\\n * @param operator is the operator to whom staker (msg.sender) is delegating its assets\\n */\\n function delegateTo(address operator) external;\\n\\n /**\\n * @notice Delegates from `staker` to `operator`.\\n * @dev requires that r, vs are a valid ECSDA signature from `staker` indicating their intention for this action\\n */\\n function delegateToSignature(address staker, address operator, uint256 expiry, bytes32 r, bytes32 vs) external;\\n\\n /**\\n * @notice Undelegates `staker` from the operator who they are delegated to.\\n * @notice Callable only by the InvestmentManager\\n * @dev Should only ever be called in the event that the `staker` has no active deposits.\\n */\\n function undelegate(address staker) external;\\n\\n /// @notice returns the address of the operator that `staker` is delegated to.\\n function delegatedTo(address staker) external view returns (address);\\n\\n /// @notice returns the delegationCallback of the `operator`, which may mediate their interactions with stakers who delegate to them.\\n function delegationCallback(address operator) external view returns (IDelegationCallback);\\n\\n /// @notice returns the total number of shares in `DelegationShare` that are delegated to `operator`.\\n function operatorShares(address operator, IDelegationShare delegationShare) external view returns (uint256);\\n\\n /// @notice Returns 'true' if `staker` *is* actively delegated, and 'false' otherwise.\\n function isDelegated(address staker) external view returns (bool);\\n\\n /// @notice Returns 'true' if `staker` is *not* actively delegated, and 'false' otherwise.\\n function isNotDelegated(address staker) external returns (bool);\\n\\n /// @notice Returns if an operator can be delegated to, i.e. it has called `registerAsOperator`.\\n function isOperator(address operator) external view returns (bool);\\n\\n /**\\n * @notice Increases the `staker`'s delegated shares in `delegationShare` by `shares`, typically called when the staker has further deposits.\\n * @dev Callable only by the DelegationManager\\n */\\n function increaseDelegatedShares(address staker, IDelegationShare delegationShare, uint256 shares) external;\\n\\n /**\\n * @notice Decreases the `staker`'s delegated shares in `delegationShare` by `shares, typically called when the staker withdraws\\n * @dev Callable only by the DelegationManager\\n */\\n function decreaseDelegatedShares(address staker, IDelegationShare delegationShare, uint256 shares) external;\\n\\n /// @notice Version of `decreaseDelegatedShares` that accepts an array of inputs.\\n function decreaseDelegatedShares(\\n address staker,\\n IDelegationShare[] calldata delegationShares,\\n uint256[] calldata shares\\n ) external;\\n}\\n\",\"keccak256\":\"0x74a6e95e0fceefae2e95a4da46889c392dbad8ced9527f56654ede584f5798c3\",\"license\":\"MIT\"},\"contracts/L1/delegation/interfaces/IDelegationCallback.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"./IDelegationShare.sol\\\";\\n\\n/**\\n * @title Abstract interface for a contract that helps structure the delegation relationship.\\n * @notice The gas budget provided to this contract in calls from contracts is limited.\\n */\\n//TODO: discuss if we can structure the inputs of these functions better\\ninterface IDelegationCallback {\\n function payForService(IERC20 token, uint256 amount) external payable;\\n\\n function onDelegationReceived(\\n address delegator,\\n address operator,\\n IDelegationShare[] memory delegationShares,\\n uint256[] memory investorShares\\n ) external;\\n\\n function onDelegationWithdrawn(\\n address delegator,\\n address operator,\\n IDelegationShare[] memory delegationShares,\\n uint256[] memory investorShares\\n ) external;\\n}\\n\",\"keccak256\":\"0x7eb42fdfd9e9a2cddfcd5910d9e7cee042935f8c8918cc53580b9a3033695236\",\"license\":\"MIT\"},\"contracts/L1/delegation/interfaces/IDelegationManager.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"./IDelegationShare.sol\\\";\\nimport \\\"./IDelegationSlasher.sol\\\";\\nimport \\\"./IDelegation.sol\\\";\\n\\n/**\\n * @title Interface for the primary entrypoint for funds.\\n * @author Layr Labs, Inc.\\n * @notice See the `DelegationManager` contract itself for implementation details.\\n */\\ninterface IDelegationManager {\\n // used for storing details of queued withdrawals\\n struct WithdrawalStorage {\\n uint32 initTimestamp;\\n uint32 unlockTimestamp;\\n address withdrawer;\\n }\\n\\n // packed struct for queued withdrawals\\n struct WithdrawerAndNonce {\\n address withdrawer;\\n uint96 nonce;\\n }\\n\\n /**\\n * Struct type used to specify an existing queued withdrawal. Rather than storing the entire struct, only a hash is stored.\\n * In functions that operate on existing queued withdrawals -- e.g. `startQueuedWithdrawalWaitingPeriod` or `completeQueuedWithdrawal`,\\n * the data is resubmitted and the hash of the submitted data is computed by `calculateWithdrawalRoot` and checked against the\\n * stored hash in order to confirm the integrity of the submitted data.\\n */\\n struct QueuedWithdrawal {\\n IDelegationShare[] delegations;\\n IERC20[] tokens;\\n uint256[] shares;\\n address depositor;\\n WithdrawerAndNonce withdrawerAndNonce;\\n address delegatedAddress;\\n }\\n\\n /**\\n * @notice Deposits `amount` of `token` into the specified `DelegationShare`, with the resultant shares credited to `depositor`\\n * @param delegationShare is the specified shares record where investment is to be made,\\n * @param token is the ERC20 token in which the investment is to be made,\\n * @param amount is the amount of token to be invested in the delegationShare by the depositor\\n */\\n function depositInto(IDelegationShare delegationShare, IERC20 token, uint256 amount)\\n external\\n returns (uint256);\\n\\n /// @notice Returns the current shares of `user` in `delegationShare`\\n function investorDelegationShares(address user, IDelegationShare delegationShare) external view returns (uint256 shares);\\n\\n /**\\n * @notice Get all details on the depositor's investments and corresponding shares\\n * @return (depositor's delegationShare record, shares in these DelegationShare contract)\\n */\\n function getDeposits(address depositor) external view returns (IDelegationShare[] memory, uint256[] memory);\\n\\n /// @notice Simple getter function that returns `investorDelegations[staker].length`.\\n function investorDelegationLength(address staker) external view returns (uint256);\\n\\n /**\\n * @notice Called by a staker to queue a withdraw in the given token and shareAmount from each of the respective given strategies.\\n * @dev Stakers will complete their withdrawal by calling the 'completeQueuedWithdrawal' function.\\n * User shares are decreased in this function, but the total number of shares in each delegation strategy remains the same.\\n * The total number of shares is decremented in the 'completeQueuedWithdrawal' function instead, which is where\\n * the funds are actually sent to the user through use of the delegation strategies' 'withdrawal' function. This ensures\\n * that the value per share reported by each strategy will remain consistent, and that the shares will continue\\n * to accrue gains during the enforced WITHDRAWAL_WAITING_PERIOD.\\n * @param delegationShareIndexes is a list of the indices in `investorDelegationShare[msg.sender]` that correspond to the delegation strategies\\n * for which `msg.sender` is withdrawing 100% of their shares\\n * @dev strategies are removed from `delegationShare` by swapping the last entry with the entry to be removed, then\\n * popping off the last entry in `delegationShares`. The simplest way to calculate the correct `delegationShareIndexes` to input\\n * is to order the strategies *for which `msg.sender` is withdrawing 100% of their shares* from highest index in\\n * `delegationShares` to lowest index\\n */\\n function queueWithdrawal(\\n uint256[] calldata delegationShareIndexes,\\n IDelegationShare[] calldata delegationShares,\\n IERC20[] calldata tokens,\\n uint256[] calldata shareAmounts,\\n WithdrawerAndNonce calldata withdrawerAndNonce,\\n bool undelegateIfPossible\\n )\\n external returns(bytes32);\\n\\n function startQueuedWithdrawalWaitingPeriod(\\n bytes32 withdrawalRoot,\\n uint32 stakeInactiveAfter\\n ) external;\\n\\n /**\\n * @notice Used to complete the specified `queuedWithdrawal`. The function caller must match `queuedWithdrawal.withdrawer`\\n * @param queuedWithdrawal The QueuedWithdrawal to complete.\\n * @param receiveAsTokens If true, the shares specified in the queued withdrawal will be withdrawn from the specified delegation strategies themselves\\n * and sent to the caller, through calls to `queuedWithdrawal.strategies[i].withdraw`. If false, then the shares in the specified delegation strategies\\n * will simply be transferred to the caller directly.\\n */\\n function completeQueuedWithdrawal(\\n QueuedWithdrawal calldata queuedWithdrawal,\\n bool receiveAsTokens\\n )\\n external;\\n\\n /**\\n * @notice Slashes the shares of 'frozen' operator (or a staker delegated to one)\\n * @param slashedAddress is the frozen address that is having its shares slashes\\n * @param delegationShareIndexes is a list of the indices in `investorStrats[msg.sender]` that correspond to the strategies\\n * for which `msg.sender` is withdrawing 100% of their shares\\n * @param recipient The slashed funds are withdrawn as tokens to this address.\\n * @dev strategies are removed from `investorStrats` by swapping the last entry with the entry to be removed, then\\n * popping off the last entry in `investorStrats`. The simplest way to calculate the correct `strategyIndexes` to input\\n * is to order the strategies *for which `msg.sender` is withdrawing 100% of their shares* from highest index in\\n * `investorStrats` to lowest index\\n */\\n function slashShares(\\n address slashedAddress,\\n address recipient,\\n IDelegationShare[] calldata delegationShares,\\n IERC20[] calldata tokens,\\n uint256[] calldata delegationShareIndexes,\\n uint256[] calldata shareAmounts\\n )\\n external;\\n\\n function slashQueuedWithdrawal(\\n address recipient,\\n QueuedWithdrawal calldata queuedWithdrawal\\n )\\n external;\\n\\n /**\\n * @notice Used to check if a queued withdrawal can be completed. Returns 'true' if the withdrawal can be immediately\\n * completed, and 'false' otherwise.\\n * @dev This function will revert if the specified `queuedWithdrawal` does not exist\\n */\\n function canCompleteQueuedWithdrawal(\\n QueuedWithdrawal calldata queuedWithdrawal\\n )\\n external\\n returns (bool);\\n\\n /// @notice Returns the keccak256 hash of `queuedWithdrawal`.\\n function calculateWithdrawalRoot(\\n QueuedWithdrawal memory queuedWithdrawal\\n )\\n external\\n pure\\n returns (bytes32);\\n\\n /// @notice Returns the single, central Delegation contract\\n function delegation() external view returns (IDelegation);\\n\\n /// @notice Returns the single, central DelegationSlasher contract\\n function delegationSlasher() external view returns (IDelegationSlasher);\\n}\\n\",\"keccak256\":\"0x04c93ba37c2c333e38fc5315aef7e6f1d052586defe5490e3a54ee428263f2c4\",\"license\":\"UNLICENSED\"},\"contracts/L1/delegation/interfaces/IDelegationShare.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/**\\n * @title Minimal interface for an `IDelegationShares` contract.\\n * @notice Custom `DelegationShares` implementations may expand extensively on this interface.\\n */\\ninterface IDelegationShare {\\n /**\\n * @notice Used to deposit tokens into this DelegationShares\\n * @param token is the ERC20 token being deposited\\n * @param amount is the amount of token being deposited\\n * @dev This function is only callable by the delegationManager contract. It is invoked inside of the delegationManager's\\n * `depositInto` function, and individual share balances are recorded in the delegationManager as well.\\n * @return newShares is the number of new shares issued at the current exchange ratio.\\n */\\n function deposit(address depositor, IERC20 token, uint256 amount) external returns (uint256);\\n\\n /**\\n * @notice Used to withdraw tokens from this DelegationLedger, to the `depositor`'s address\\n * @param token is the ERC20 token being transferred out\\n * @param amountShares is the amount of shares being withdrawn\\n * @dev This function is only callable by the delegationManager contract. It is invoked inside of the delegationManager's\\n * other functions, and individual share balances are recorded in the delegationManager as well.\\n */\\n function withdraw(address depositor, IERC20 token, uint256 amountShares) external;\\n\\n /**\\n * @notice Used to convert a number of shares to the equivalent amount of underlying tokens for this strategy.\\n * @notice In contrast to `sharesToUnderlyingView`, this function **may** make state modifications\\n * @param amountShares is the amount of shares to calculate its conversion into the underlying token\\n * @dev Implementation for these functions in particular may vary signifcantly for different strategies\\n */\\n function sharesToUnderlying(uint256 amountShares) external returns (uint256);\\n\\n /**\\n * @notice Used to convert an amount of underlying tokens to the equivalent amount of shares in this ledger.\\n * @notice In contrast to `underlyingToSharesView`, this function **may** make state modifications\\n * @param amountUnderlying is the amount of `underlyingToken` to calculate its conversion into ledger shares\\n * @dev Implementation for these functions in particular may vary signifcantly for different ledgers\\n */\\n function underlyingToShares(uint256 amountUnderlying) external view returns (uint256);\\n\\n /**\\n * @notice convenience function for fetching the current underlying value of all of the `user`'s shares in\\n * this ledger. In contrast to `userUnderlyingView`, this function **may** make state modifications\\n */\\n function userUnderlying(address user) external returns (uint256);\\n\\n /**\\n * @notice Used to convert a number of shares to the equivalent amount of underlying tokens for this ledger.\\n * @notice In contrast to `sharesToUnderlying`, this function guarantees no state modifications\\n * @param amountShares is the amount of shares to calculate its conversion into the underlying token\\n * @dev Implementation for these functions in particular may vary signifcantly for different ledgers\\n */\\n function sharesToUnderlyingView(uint256 amountShares) external view returns (uint256);\\n\\n /**\\n * @notice Used to convert an amount of underlying tokens to the equivalent amount of shares in this ledger.\\n * @notice In contrast to `underlyingToShares`, this function guarantees no state modifications\\n * @param amountUnderlying is the amount of `underlyingToken` to calculate its conversion into ledger shares\\n * @dev Implementation for these functions in particular may vary signifcantly for different ledgers\\n */\\n function underlyingToSharesView(uint256 amountUnderlying) external view returns (uint256);\\n\\n /**\\n * @notice convenience function for fetching the current underlying value of all of the `user`'s shares in\\n * this ledger. In contrast to `userUnderlying`, this function guarantees no state modifications\\n */\\n function userUnderlyingView(address user) external view returns (uint256);\\n\\n /// @notice The underyling token for shares in this DelegationShares\\n function underlyingToken() external view returns (IERC20);\\n\\n /// @notice The total number of extant shares in thie InvestmentStrategy\\n function totalShares() external view returns (uint256);\\n\\n /// @notice Returns either a brief string explaining the strategy's goal & purpose, or a link to metadata that explains in more detail.\\n function explanation() external view returns (string memory);\\n}\\n\",\"keccak256\":\"0xafef22ce9d64eadc4a1177a1eca0feaa243aac318fc7b7e9e3de776ca0302701\",\"license\":\"MIT\"},\"contracts/L1/delegation/interfaces/IDelegationSlasher.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Interface for the primary 'slashing' contract for EigenLayr.\\n * @author Layr Labs, Inc.\\n * @notice See the `Slasher` contract itself for implementation details.\\n */\\ninterface IDelegationSlasher {\\n /**\\n * @notice Gives the `contractAddress` permission to slash the funds of the caller.\\n * @dev Typically, this function must be called prior to registering for a middleware.\\n */\\n function allowToSlash(address contractAddress) external;\\n\\n /// @notice Called by a contract to revoke its ability to slash `operator`, once `unbondedAfter` is reached.\\n function revokeSlashingAbility(address operator, uint32 unbondedAfter) external;\\n\\n /**\\n * @notice Used for 'slashing' a certain operator.\\n * @param toBeFrozen The operator to be frozen.\\n * @dev Technically the operator is 'frozen' (hence the name of this function), and then subject to slashing pending a decision by a human-in-the-loop.\\n * @dev The operator must have previously given the caller (which should be a contract) the ability to slash them, through a call to `allowToSlash`.\\n */\\n function freezeOperator(address toBeFrozen) external;\\n\\n /**\\n * @notice Used to determine whether `staker` is actively 'frozen'. If a staker is frozen, then they are potentially subject to\\n * slashing of their funds, and cannot cannot deposit or withdraw from the investmentManager until the slashing process is completed\\n * and the staker's status is reset (to 'unfrozen').\\n * @return Returns 'true' if `staker` themselves has their status set to frozen, OR if the staker is delegated\\n * to an operator who has their status set to frozen. Otherwise returns 'false'.\\n */\\n function isFrozen(address staker) external view returns (bool);\\n\\n /// @notice Returns true if `slashingContract` is currently allowed to slash `toBeSlashed`.\\n function canSlash(address toBeSlashed, address slashingContract) external view returns (bool);\\n\\n /// @notice Returns the UTC timestamp until which `slashingContract` is allowed to slash the `operator`.\\n function bondedUntil(address operator, address slashingContract) external view returns (uint32);\\n\\n /**\\n * @notice Removes the 'frozen' status from each of the `frozenAddresses`\\n * @dev Callable only by the contract owner (i.e. governance).\\n */\\n function resetFrozenStatus(address[] calldata frozenAddresses) external;\\n\\n /**\\n * @notice Used to give global slashing permission to `contracts`.\\n * @dev Callable only by the contract owner (i.e. governance).\\n */\\n function addGloballyPermissionedContracts(address[] calldata contracts) external;\\n\\n /**\\n * @notice Used to revoke global slashing permission from `contracts`.\\n * @dev Callable only by the contract owner (i.e. governance).\\n */\\n function removeGloballyPermissionedContracts(address[] calldata contracts) external;\\n}\\n\",\"keccak256\":\"0x82568e400a4fcd69fdb669db0f6dd194fb6f7a515f6f113535fa58762dc68f6b\",\"license\":\"UNLICENSED\"},\"contracts/L1/tss/delegation/TssDelegation.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8.9;\\n\\nimport \\\"../../delegation/Delegation.sol\\\";\\nimport \\\"../../delegation/WhiteListBase.sol\\\";\\n\\n\\n/**\\n * @title The primary delegation contract.\\n * @notice This is the contract for delegation. The main functionalities of this contract are\\n * - for enabling any staker to register as a delegate and specify the delegation terms it has agreed to\\n * - for enabling anyone to register as an operator\\n * - for a registered staker to delegate its stake to the operator of its agreed upon delegation terms contract\\n * - for a staker to undelegate its assets\\n * - for anyone to challenge a staker's claim to have fulfilled all its obligation before undelegation\\n */\\ncontract TssDelegation is Delegation {\\n\\n\\n address public stakingSlash;\\n\\n\\n\\n\\n // INITIALIZING FUNCTIONS\\n constructor(IDelegationManager _delegationManager)\\n Delegation(_delegationManager)\\n {\\n _disableInitializers();\\n }\\n\\n\\n function initializeT(\\n address _stakingSlashing,\\n address initialOwner\\n ) external initializer {\\n DOMAIN_SEPARATOR = keccak256(abi.encode(DOMAIN_TYPEHASH, bytes(\\\"Mantle\\\"), block.chainid, address(this)));\\n stakingSlash = _stakingSlashing;\\n _transferOwnership(initialOwner);\\n }\\n\\n modifier onlyStakingSlash() {\\n require(msg.sender == stakingSlash, \\\"contract call is not staking slashing\\\");\\n _;\\n }\\n\\n function setStakingSlash(address _address) public onlyOwner {\\n stakingSlash = _address;\\n }\\n\\n function registerAsOperator(IDelegationCallback dt, address sender) external whitelistOnly(sender) onlyStakingSlash {\\n\\n require(\\n address(delegationCallback[sender]) == address(0),\\n \\\"Delegation.registerAsOperator: Delegate has already registered\\\"\\n );\\n // store the address of the delegation contract that the operator is providing.\\n delegationCallback[sender] = dt;\\n _delegate(sender, sender);\\n emit RegisterOperator(address(dt), sender);\\n }\\n\\n function delegateTo(address operator, address staker) external onlyStakingSlash whenNotPaused {\\n _delegate(staker, operator);\\n }\\n\\n\\n}\\n\",\"keccak256\":\"0xcd0a3658ec6d6b573fe91d51a8a8a7282ee20c833aa1c6aebe6dfd2d4736b8af\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "kind": "dev", "methods": { "decreaseDelegatedShares(address,address,uint256)": { "details": "Callable only by the InvestmentManager" }, "delegateTo(address)": { "params": { "operator": "is the operator to whom staker (msg.sender) is delegating its assets" } }, "delegateToSignature(address,address,uint256,bytes32,bytes32)": { "details": "requires that r, vs are a valid ECSDA signature from `staker` indicating their intention for this action" }, "increaseDelegatedShares(address,address,uint256)": { "details": "Callable only by the InvestmentManager" }, "owner()": { "details": "Returns the address of the current owner." }, "paused()": { "details": "Returns true if the contract is paused, and false otherwise." }, "registerAsOperator(address)": { "details": "An operator can set `dt` equal to their own address (or another EOA address), in the event that they want to split payments in a more 'trustful' manner.In the present design, once set, there is no way for an operator to ever modify the address of their DelegationTerms contract.", "params": { "dt": "is the `DelegationTerms` contract that the operator has for those who delegate to them." } }, "renounceOwnership()": { "details": "Leaves the contract without owner. It will not be possible to call `onlyOwner` functions anymore. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is only available to the owner." }, "transferOwnership(address)": { "details": "Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner." }, "undelegate(address)": { "details": "Should only ever be called in the event that the `staker` has no active deposits." } }, "title": "The primary delegation contract.", "version": 1 }, "userdoc": { "kind": "user", "methods": { "DELEGATION_TYPEHASH()": { "notice": "The EIP-712 typehash for the delegation struct used by the contract" }, "DOMAIN_SEPARATOR()": { "notice": "EIP-712 Domain separator" }, "DOMAIN_TYPEHASH()": { "notice": "The EIP-712 typehash for the contract's domain" }, "addToWhitelist(address[])": { "notice": "Add to whitelist" }, "decreaseDelegatedShares(address,address,uint256)": { "notice": "Decreases the `staker`'s delegated shares in `strategy` by `shares, typically called when the staker withdraws" }, "decreaseDelegatedShares(address,address[],uint256[])": { "notice": "Version of `decreaseDelegatedShares` that accepts an array of inputs." }, "delegateTo(address)": { "notice": "This will be called by a staker to delegate its assets to some operator." }, "delegateToSignature(address,address,uint256,bytes32,bytes32)": { "notice": "Delegates from `staker` to `operator`." }, "delegatedTo(address)": { "notice": "returns the address of the operator that `staker` is delegated to." }, "delegationCallback(address)": { "notice": "returns the delegationCallback of the `operator`, which may mediate their interactions with stakers who delegate to them." }, "delegationManager()": { "notice": "The InvestmentManager contract" }, "increaseDelegatedShares(address,address,uint256)": { "notice": "Increases the `staker`'s delegated shares in `strategy` by `shares, typically called when the staker has further deposits" }, "isDelegated(address)": { "notice": "Returns 'true' if `staker` *is* actively delegated, and 'false' otherwise." }, "isNotDelegated(address)": { "notice": "Returns 'true' if `staker` is *not* actively delegated, and 'false' otherwise." }, "isOperator(address)": { "notice": "Returns if an operator can be delegated to, i.e. it has called `registerAsOperator`." }, "operatorShares(address,address)": { "notice": "returns the total number of shares in `DelegationShare` that are delegated to `operator`." }, "registerAsOperator(address)": { "notice": "This will be called by an operator to register itself as an operator that stakers can choose to delegate to." }, "removeFromWhitelist(address[])": { "notice": "Remove from whitelist" }, "undelegate(address)": { "notice": "Undelegates `staker` from the operator who they are delegated to.Callable only by the InvestmentManager" } }, "notice": "This is the contract for delegation. The main functionalities of this contract are - for enabling any staker to register as a delegate and specify the delegation terms it has agreed to - for enabling anyone to register as an operator - for a registered staker to delegate its stake to the operator of its agreed upon delegation terms contract - for a staker to undelegate its assets - for anyone to challenge a staker's claim to have fulfilled all its obligation before undelegation", "version": 1 }, "storageLayout": { "storage": [ { "astId": 216, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "_initialized", "offset": 0, "slot": "0", "type": "t_uint8" }, { "astId": 219, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "_initializing", "offset": 1, "slot": "0", "type": "t_bool" }, { "astId": 2492, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "__gap", "offset": 0, "slot": "1", "type": "t_array(t_uint256)50_storage" }, { "astId": 10, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "_owner", "offset": 0, "slot": "51", "type": "t_address" }, { "astId": 130, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "__gap", "offset": 0, "slot": "52", "type": "t_array(t_uint256)49_storage" }, { "astId": 381, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "_paused", "offset": 0, "slot": "101", "type": "t_bool" }, { "astId": 486, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "__gap", "offset": 0, "slot": "102", "type": "t_array(t_uint256)49_storage" }, { "astId": 12474, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "whitelist", "offset": 0, "slot": "151", "type": "t_mapping(t_address,t_bool)" }, { "astId": 12408, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "DOMAIN_SEPARATOR", "offset": 0, "slot": "152", "type": "t_bytes32" }, { "astId": 12419, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "operatorShares", "offset": 0, "slot": "153", "type": "t_mapping(t_address,t_mapping(t_contract(IDelegationShare)12988,t_uint256))" }, { "astId": 12424, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "delegationCallback", "offset": 0, "slot": "154", "type": "t_mapping(t_address,t_contract(IDelegationCallback)12705)" }, { "astId": 12428, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "delegatedTo", "offset": 0, "slot": "155", "type": "t_mapping(t_address,t_address)" }, { "astId": 12433, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "delegationStatus", "offset": 0, "slot": "156", "type": "t_mapping(t_address,t_enum(DelegationStatus)12543)" }, { "astId": 12437, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "nonces", "offset": 0, "slot": "157", "type": "t_mapping(t_address,t_uint256)" }, { "astId": 43382, "contract": "contracts/L1/tss/delegation/TssDelegation.sol:TssDelegation", "label": "stakingSlash", "offset": 0, "slot": "158", "type": "t_address" } ], "types": { "t_address": { "encoding": "inplace", "label": "address", "numberOfBytes": "20" }, "t_array(t_uint256)49_storage": { "base": "t_uint256", "encoding": "inplace", "label": "uint256[49]", "numberOfBytes": "1568" }, "t_array(t_uint256)50_storage": { "base": "t_uint256", "encoding": "inplace", "label": "uint256[50]", "numberOfBytes": "1600" }, "t_bool": { "encoding": "inplace", "label": "bool", "numberOfBytes": "1" }, "t_bytes32": { "encoding": "inplace", "label": "bytes32", "numberOfBytes": "32" }, "t_contract(IDelegationCallback)12705": { "encoding": "inplace", "label": "contract IDelegationCallback", "numberOfBytes": "20" }, "t_contract(IDelegationShare)12988": { "encoding": "inplace", "label": "contract IDelegationShare", "numberOfBytes": "20" }, "t_enum(DelegationStatus)12543": { "encoding": "inplace", "label": "enum IDelegation.DelegationStatus", "numberOfBytes": "1" }, "t_mapping(t_address,t_address)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => address)", "numberOfBytes": "32", "value": "t_address" }, "t_mapping(t_address,t_bool)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => bool)", "numberOfBytes": "32", "value": "t_bool" }, "t_mapping(t_address,t_contract(IDelegationCallback)12705)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => contract IDelegationCallback)", "numberOfBytes": "32", "value": "t_contract(IDelegationCallback)12705" }, "t_mapping(t_address,t_enum(DelegationStatus)12543)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => enum IDelegation.DelegationStatus)", "numberOfBytes": "32", "value": "t_enum(DelegationStatus)12543" }, "t_mapping(t_address,t_mapping(t_contract(IDelegationShare)12988,t_uint256))": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => mapping(contract IDelegationShare => uint256))", "numberOfBytes": "32", "value": "t_mapping(t_contract(IDelegationShare)12988,t_uint256)" }, "t_mapping(t_address,t_uint256)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => uint256)", "numberOfBytes": "32", "value": "t_uint256" }, "t_mapping(t_contract(IDelegationShare)12988,t_uint256)": { "encoding": "mapping", "key": "t_contract(IDelegationShare)12988", "label": "mapping(contract IDelegationShare => uint256)", "numberOfBytes": "32", "value": "t_uint256" }, "t_uint256": { "encoding": "inplace", "label": "uint256", "numberOfBytes": "32" }, "t_uint8": { "encoding": "inplace", "label": "uint8", "numberOfBytes": "1" } } } }