From d0abb4a64abb9d5541a7ed6be02da8a5a64de33b Mon Sep 17 00:00:00 2001 From: Yoda Date: Sun, 2 Jul 2023 08:34:47 +0000 Subject: [PATCH] update EigenDataLayrChain deployment --- .../mainnet/BVM_EigenDataLayrChain.json | 40 +++++------ .../Proxy__BVM_EigenDataLayrChain.json | 72 +++++++++---------- 2 files changed, 56 insertions(+), 56 deletions(-) diff --git a/packages/contracts/deployments/mainnet/BVM_EigenDataLayrChain.json b/packages/contracts/deployments/mainnet/BVM_EigenDataLayrChain.json index 281c8fa64..2223e294a 100644 --- a/packages/contracts/deployments/mainnet/BVM_EigenDataLayrChain.json +++ b/packages/contracts/deployments/mainnet/BVM_EigenDataLayrChain.json @@ -1,5 +1,5 @@ { - "address": "0x4215bFD622ea609C0da9d3d53DFEc26CDDAe324C", + "address": "0xDF401d4229Fc6cA52238f7e55A04FA8EBc24C55a", "abi": [ { "inputs": [], @@ -1200,41 +1200,41 @@ "type": "function" } ], - "transactionHash": "0x3b9797e99c98e8595b55c0aed89b0ee24896dab2b1b92147ea13c2c6fd4bb59b", + "transactionHash": "0x43117a5cc902fd130fddec881d5e4dbb156aa30827a8611bc3c4bd33cdb49c38", "receipt": { "to": null, "from": "0x2A2954F3989a83Cc43DD58B0f038D5F276f21333", - "contractAddress": "0x4215bFD622ea609C0da9d3d53DFEc26CDDAe324C", - "transactionIndex": 13, - "gasUsed": "3941073", - "logsBloom": "0x00000000000000000000000000000080000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", - "blockHash": "0x55502cbbe1a80b1ac41a689c87c384ee5fcd82752f2c5980450c95971137e519", - "transactionHash": "0x3b9797e99c98e8595b55c0aed89b0ee24896dab2b1b92147ea13c2c6fd4bb59b", + "contractAddress": "0xDF401d4229Fc6cA52238f7e55A04FA8EBc24C55a", + "transactionIndex": 11, + "gasUsed": "3889163", + "logsBloom": "0x00000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000040000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0xa47a29215caa5ceda4ae098e276af749263f101ad62d95ea1b80de645663ada7", + "transactionHash": "0x43117a5cc902fd130fddec881d5e4dbb156aa30827a8611bc3c4bd33cdb49c38", "logs": [ { - "transactionIndex": 13, - "blockNumber": 17578139, - "transactionHash": "0x3b9797e99c98e8595b55c0aed89b0ee24896dab2b1b92147ea13c2c6fd4bb59b", - "address": "0x4215bFD622ea609C0da9d3d53DFEc26CDDAe324C", + "transactionIndex": 11, + "blockNumber": 17604771, + "transactionHash": "0x43117a5cc902fd130fddec881d5e4dbb156aa30827a8611bc3c4bd33cdb49c38", + "address": "0xDF401d4229Fc6cA52238f7e55A04FA8EBc24C55a", "topics": [ "0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498" ], "data": "0x00000000000000000000000000000000000000000000000000000000000000ff", - "logIndex": 41, - "blockHash": "0x55502cbbe1a80b1ac41a689c87c384ee5fcd82752f2c5980450c95971137e519" + "logIndex": 66, + "blockHash": "0xa47a29215caa5ceda4ae098e276af749263f101ad62d95ea1b80de645663ada7" } ], - "blockNumber": 17578139, - "cumulativeGasUsed": "5081108", + "blockNumber": 17604771, + "cumulativeGasUsed": "8768644", "status": 1, "byzantium": true }, "args": [], "numDeployments": 1, - "solcInputHash": "d2a2626cfe7e2953801cc1308f1f5db0", - "metadata": "{\"compiler\":{\"version\":\"0.8.9+commit.e5eed63a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldDataLayrManagerAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newDataLayrManagerAddress\",\"type\":\"address\"}],\"name\":\"DataLayrManagerAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldFraudProofPeriod\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newFraudProofPeriod\",\"type\":\"uint256\"}],\"name\":\"FraudProofPeriodUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldL2ConfirmedBlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newL2ConfirmedBlockNumber\",\"type\":\"uint256\"}],\"name\":\"L2ConfirmedBlockNumberUpdated\",\"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\":\"uint256\",\"name\":\"reRollupIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"rollupBatchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stratL2BlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"endL2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"ReRollupBatchData\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldReSubmitterAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newReSubmitterAddress\",\"type\":\"address\"}],\"name\":\"ReSubmitterAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldRollupBatchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newRollupBatchIndex\",\"type\":\"uint256\"}],\"name\":\"RollupBatchIndexUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"rollupBatchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stratL2BlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"endL2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"RollupStoreConfirmed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stratL2BlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"endL2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"RollupStoreInitialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"rollupBatchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stratL2BlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"endL2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"RollupStoreReverted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldSequencerAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSequencerAddress\",\"type\":\"address\"}],\"name\":\"SequencerAddressUpdated\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BLOCK_STALE_MEASURE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FRAUD_STRING\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"headerHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"durationDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"globalDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"referenceBlockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"blockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint96\",\"name\":\"fee\",\"type\":\"uint96\"},{\"internalType\":\"address\",\"name\":\"confirmer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"signatoryRecordHash\",\"type\":\"bytes32\"}],\"internalType\":\"struct IDataLayrServiceManager.DataStoreMetadata\",\"name\":\"metadata\",\"type\":\"tuple\"},{\"internalType\":\"uint8\",\"name\":\"duration\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"internalType\":\"struct IDataLayrServiceManager.DataStoreSearchData\",\"name\":\"searchData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"startL2Block\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endL2Block\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"originDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint256\",\"name\":\"reConfirmedBatchIndex\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isReRollup\",\"type\":\"bool\"}],\"name\":\"confirmData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"dataManageAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"name\":\"dataStoreIdToL2RollUpBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"startL2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endBL2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isReRollup\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"name\":\"dataStoreIdToRollupStoreNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"fraudProofPeriod\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getL2ConfirmedBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"_dataStoreId\",\"type\":\"uint32\"}],\"name\":\"getL2RollUpBlockByDataStoreId\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"startL2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endBL2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isReRollup\",\"type\":\"bool\"}],\"internalType\":\"struct BVM_EigenDataLayrChain.BatchRollupBlock\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getL2StoredBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_rollupBatchIndex\",\"type\":\"uint256\"}],\"name\":\"getRollupStoreByRollupBatchIndex\",\"outputs\":[{\"components\":[{\"internalType\":\"uint32\",\"name\":\"originDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"confirmAt\",\"type\":\"uint32\"},{\"internalType\":\"enum BVM_EigenDataLayrChain.RollupStoreStatus\",\"name\":\"status\",\"type\":\"uint8\"}],\"internalType\":\"struct BVM_EigenDataLayrChain.RollupStore\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_sequencer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_dataManageAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_reSubmitterAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_block_stale_measure\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_fraudProofPeriod\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_l2SubmittedBlockNumber\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2ConfirmedBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2StoredBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"polys\",\"type\":\"bytes[]\"},{\"internalType\":\"uint256\",\"name\":\"startIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"name\":\"parse\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"provenString\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"fraudulentStoreNumber\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startIndex\",\"type\":\"uint256\"},{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"headerHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"durationDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"globalDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"referenceBlockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"blockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint96\",\"name\":\"fee\",\"type\":\"uint96\"},{\"internalType\":\"address\",\"name\":\"confirmer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"signatoryRecordHash\",\"type\":\"bytes32\"}],\"internalType\":\"struct IDataLayrServiceManager.DataStoreMetadata\",\"name\":\"metadata\",\"type\":\"tuple\"},{\"internalType\":\"uint8\",\"name\":\"duration\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"internalType\":\"struct IDataLayrServiceManager.DataStoreSearchData\",\"name\":\"searchData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"bytes\",\"name\":\"header\",\"type\":\"bytes\"},{\"internalType\":\"uint32\",\"name\":\"firstChunkNumber\",\"type\":\"uint32\"},{\"internalType\":\"bytes[]\",\"name\":\"polys\",\"type\":\"bytes[]\"},{\"components\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"X\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"Y\",\"type\":\"uint256\"}],\"internalType\":\"struct BN254.G1Point\",\"name\":\"interpolationPoly\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"X\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"Y\",\"type\":\"uint256\"}],\"internalType\":\"struct BN254.G1Point\",\"name\":\"revealProof\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256[2]\",\"name\":\"X\",\"type\":\"uint256[2]\"},{\"internalType\":\"uint256[2]\",\"name\":\"Y\",\"type\":\"uint256[2]\"}],\"internalType\":\"struct BN254.G2Point\",\"name\":\"zeroPoly\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"zeroPolyProof\",\"type\":\"bytes\"}],\"internalType\":\"struct DataLayrDisclosureLogic.MultiRevealProof[]\",\"name\":\"multiRevealProofs\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint256[2]\",\"name\":\"X\",\"type\":\"uint256[2]\"},{\"internalType\":\"uint256[2]\",\"name\":\"Y\",\"type\":\"uint256[2]\"}],\"internalType\":\"struct BN254.G2Point\",\"name\":\"polyEquivalenceProof\",\"type\":\"tuple\"}],\"internalType\":\"struct BVM_EigenDataLayrChain.DisclosureProofs\",\"name\":\"disclosureProofs\",\"type\":\"tuple\"}],\"name\":\"proveFraud\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"reRollupBatchIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"reRollupIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"reSubmitterAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"removeFraudProofAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_rollupBatchIndex\",\"type\":\"uint256\"}],\"name\":\"resetRollupBatchData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupBatchIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"rollupBatchIndexRollupStores\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"originDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"confirmAt\",\"type\":\"uint32\"},{\"internalType\":\"enum BVM_EigenDataLayrChain.RollupStoreStatus\",\"name\":\"status\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"sequencer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"setFraudProofAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"header\",\"type\":\"bytes\"},{\"internalType\":\"uint8\",\"name\":\"duration\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"blockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint256\",\"name\":\"startL2Block\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endL2Block\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"totalOperatorsIndex\",\"type\":\"uint32\"},{\"internalType\":\"bool\",\"name\":\"isReRollup\",\"type\":\"bool\"}],\"name\":\"storeData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"batchIndex\",\"type\":\"uint256\"}],\"name\":\"submitReRollUpInfo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"unavailableFraudProofAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_dataManageAddress\",\"type\":\"address\"}],\"name\":\"updateDataLayrManagerAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_fraudProofPeriod\",\"type\":\"uint256\"}],\"name\":\"updateFraudProofPeriod\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2ConfirmedBlockNumber\",\"type\":\"uint256\"}],\"name\":\"updateL2ConfirmedBlockNumber\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2StoredBlockNumber\",\"type\":\"uint256\"}],\"name\":\"updateL2StoredBlockNumber\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_reSubmitterAddress\",\"type\":\"address\"}],\"name\":\"updateReSubmitterAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_rollupBatchIndex\",\"type\":\"uint256\"}],\"name\":\"updateRollupBatchIndex\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_sequencer\",\"type\":\"address\"}],\"name\":\"updateSequencerAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"confirmData(bytes,((bytes32,uint32,uint32,uint32,uint32,uint96,address,bytes32),uint8,uint256,uint32),uint256,uint256,uint32,uint256,bool)\":{\"details\":\"Only dataStores created through this contract can be confirmed by calling this function.\",\"params\":{\"data\":\"Input of the header information for a dataStore and signatures for confirming the dataStore -- used as input to the `confirmDataStore` function of the DataLayrServiceManager -- see the DataLayr docs for more info on this.\",\"searchData\":\"Data used to specify the dataStore being confirmed. Must be provided so other contracts can properly look up the dataStore.\"}},\"getL2ConfirmedBlockNumber()\":{\"returns\":{\"_0\":\"Latest stored L2 block number.\"}},\"getL2RollUpBlockByDataStoreId(uint32)\":{\"returns\":{\"_0\":\"BatchRollupBlock.\"}},\"getL2StoredBlockNumber()\":{\"returns\":{\"_0\":\"Latest stored L2 block number.\"}},\"getRollupStoreByRollupBatchIndex(uint256)\":{\"returns\":{\"_0\":\"RollupStore.\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"parse(bytes[],uint256,uint256)\":{\"params\":{\"length\":\"The length of data to parse, in bytes.\",\"polys\":\"The non-interactive polynomial proofs themselves\",\"startIndex\":\"The byte index from which to begin reading data.\"},\"returns\":{\"provenString\":\"The parsed data.\"}},\"proveFraud(uint256,uint256,((bytes32,uint32,uint32,uint32,uint32,uint96,address,bytes32),uint8,uint256,uint32),(bytes,uint32,bytes[],((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2]),bytes)[],(uint256[2],uint256[2])))\":{\"details\":\"This function is only callable if: -the sequencer is staked, -the dataStore in question has been confirmed, and -the fraudproof period for the dataStore has not yet passed.\",\"params\":{\"disclosureProofs\":\"Non-interactive polynomial proofs that prove that the specific data of interest was part of the dataStore in question.\",\"fraudulentStoreNumber\":\"The rollup l2Block to prove fraud on\",\"searchData\":\"Data used to specify the dataStore being fraud-proven. Must be provided so other contracts can properly look up the dataStore.\",\"startIndex\":\"The index to begin reading the proven data from\"}},\"removeFraudProofAddress(address)\":{\"params\":{\"_address\":\"for fraud proof\"}},\"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.\"},\"resetRollupBatchData(uint256)\":{\"params\":{\"_rollupBatchIndex\":\"update rollup index\"}},\"setFraudProofAddress(address)\":{\"params\":{\"_address\":\"for fraud proof\"}},\"storeData(bytes,uint8,uint32,uint256,uint256,uint32,bool)\":{\"details\":\"The specified `blockNumber `must be less than `BLOCK_STALE_MEASURE` blocks in the past.\",\"params\":{\"blockNumber\":\"is the previous block number which was used to encode the data for storage\",\"duration\":\"is the duration to store the datastore for\",\"header\":\"of data to be stored\",\"totalOperatorsIndex\":\"is index in the totalOperators array of DataLayr referring to what the total number of operators was at `blockNumber`\"}},\"submitReRollUpInfo(uint256)\":{\"params\":{\"batchIndex\":\"need re-rollup batch index\"}},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"unavailableFraudProofAddress(address)\":{\"params\":{\"_address\":\"for fraud proof\"}},\"updateDataLayrManagerAddress(address)\":{\"params\":{\"_dataManageAddress\":\"dlsm address\"}},\"updateFraudProofPeriod(uint256)\":{\"params\":{\"_fraudProofPeriod\":\"fraud proof period\"}},\"updateL2ConfirmedBlockNumber(uint256)\":{\"params\":{\"_l2ConfirmedBlockNumber\":\"l2 latest block number\"}},\"updateL2StoredBlockNumber(uint256)\":{\"params\":{\"_l2StoredBlockNumber\":\"l2 latest block number\"}},\"updateRollupBatchIndex(uint256)\":{\"params\":{\"_rollupBatchIndex\":\"update rollup batch index\"}},\"updateSequencerAddress(address)\":{\"params\":{\"_sequencer\":\"update sequencer address\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"confirmData(bytes,((bytes32,uint32,uint32,uint32,uint32,uint96,address,bytes32),uint8,uint256,uint32),uint256,uint256,uint32,uint256,bool)\":{\"notice\":\"After the `storeData `transaction is included in a block and doesn\\u2019t revert, the sequencer will disperse the data to the DataLayr nodes off chain and get their signatures that they have stored the data. Now, the sequencer has to post the signature on chain and get it verified.\"},\"getL2ConfirmedBlockNumber()\":{\"notice\":\"Returns the block number of the latest stored L2.\"},\"getL2RollUpBlockByDataStoreId(uint32)\":{\"notice\":\"Returns the l2 block number by store id\"},\"getL2StoredBlockNumber()\":{\"notice\":\"Returns the block number of the latest stored L2.\"},\"getRollupStoreByRollupBatchIndex(uint256)\":{\"notice\":\"Returns the rollup store by l2 block number\"},\"parse(bytes[],uint256,uint256)\":{\"notice\":\"Parses data from non-interactive polynomial proofs.\"},\"proveFraud(uint256,uint256,((bytes32,uint32,uint32,uint32,uint32,uint96,address,bytes32),uint8,uint256,uint32),(bytes,uint32,bytes[],((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2]),bytes)[],(uint256[2],uint256[2])))\":{\"notice\":\"Called by a challenger (this could be anyone -- \\\"challenger\\\" is not a permissioned role) to prove that fraud has occurred. First, a subset of data included in a dataStore that was initiated by the sequencer is proven, and then the presence of fraud in the data is checked. For the sake of this example, \\\"fraud occurring\\\" means that the sequencer included the forbidden `FRAUD_STRING` in a dataStore that they initiated. In pratical use, \\\"fraud occurring\\\" might mean including data that specifies an invalid transaction or invalid state transition.\"},\"removeFraudProofAddress(address)\":{\"notice\":\"remove fraud proof address\"},\"resetRollupBatchData(uint256)\":{\"notice\":\"reset batch rollup batch data\"},\"setFraudProofAddress(address)\":{\"notice\":\"set fraud proof address\"},\"storeData(bytes,uint8,uint32,uint256,uint256,uint32,bool)\":{\"notice\":\"Called by the (staked) sequencer to pay for a datastore and post some metadata (in the `header` parameter) about it on chain. Since the sequencer must encode the data before they post the header on chain, they must use a *snapshot* of the number and stakes of DataLayr operators from a previous block number, specified by the `blockNumber` input.\"},\"submitReRollUpInfo(uint256)\":{\"notice\":\"submit re-rollup batch index\"},\"unavailableFraudProofAddress(address)\":{\"notice\":\"unavailable fraud proof address\"},\"updateDataLayrManagerAddress(address)\":{\"notice\":\"update dlsm address\"},\"updateFraudProofPeriod(uint256)\":{\"notice\":\"update fraud proof period\"},\"updateL2ConfirmedBlockNumber(uint256)\":{\"notice\":\"update l2 latest confirm block number\"},\"updateL2StoredBlockNumber(uint256)\":{\"notice\":\"update l2 latest store block number\"},\"updateRollupBatchIndex(uint256)\":{\"notice\":\"update rollup batch index\"},\"updateSequencerAddress(address)\":{\"notice\":\"update sequencer address\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/da/BVM_EigenDataLayrChain.sol\":\"BVM_EigenDataLayrChain\"},\"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/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n function __ReentrancyGuard_init() internal onlyInitializing {\\n __ReentrancyGuard_init_unchained();\\n }\\n\\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n // On the first call to nonReentrant, _notEntered will be true\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n\\n _;\\n\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\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\":\"0x8cc03c5ac17e8a7396e487cda41fc1f1dfdb91db7d528e6da84bee3b6dd7e167\",\"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-upgradeable/utils/math/SafeMathUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMathUpgradeable {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcaa8b7861115ea691c77ddbeac140a444e0edcd1d9812a43942c0f6b42b36a49\",\"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\"},\"contracts/da/BVM_EigenDataLayrChain.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\\\";\\nimport { DataLayrDisclosureLogic } from \\\"../libraries/eigenda/DataLayrDisclosureLogic.sol\\\";\\nimport { IDataLayrServiceManager } from \\\"../libraries/eigenda/interfaces/IDataLayrServiceManager.sol\\\";\\nimport { BN254 } from \\\"../libraries/eigenda/BN254.sol\\\";\\nimport { DataStoreUtils } from \\\"../libraries/eigenda/DataStoreUtils.sol\\\";\\nimport { Parser } from \\\"../libraries/eigenda/Parse.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\n\\n\\ncontract BVM_EigenDataLayrChain is Initializable, OwnableUpgradeable, ReentrancyGuardUpgradeable, Parser {\\n using SafeMathUpgradeable for uint256;\\n using AddressUpgradeable for address;\\n\\n enum RollupStoreStatus {\\n UNCOMMITTED,\\n COMMITTED,\\n REVERTED\\n }\\n\\n struct DisclosureProofs {\\n bytes header;\\n uint32 firstChunkNumber;\\n bytes[] polys;\\n DataLayrDisclosureLogic.MultiRevealProof[] multiRevealProofs;\\n BN254.G2Point polyEquivalenceProof;\\n }\\n\\n address public sequencer;\\n address public dataManageAddress;\\n uint256 public BLOCK_STALE_MEASURE;\\n uint256 public l2StoredBlockNumber;\\n uint256 public l2ConfirmedBlockNumber;\\n uint256 public fraudProofPeriod;\\n uint256 public rollupBatchIndex;\\n\\n bytes public constant FRAUD_STRING = '--This is a bad string. Nobody says this string.--';\\n uint256 internal constant DATA_STORE_INITIALIZED_BUT_NOT_CONFIRMED = type(uint256).max;\\n\\n struct RollupStore {\\n uint32 originDataStoreId;\\n uint32 dataStoreId;\\n uint32 confirmAt;\\n RollupStoreStatus status;\\n }\\n\\n struct BatchRollupBlock {\\n uint256 startL2BlockNumber;\\n uint256 endBL2BlockNumber;\\n bool isReRollup;\\n }\\n\\n mapping(uint256 => RollupStore) public rollupBatchIndexRollupStores;\\n mapping(uint32 => BatchRollupBlock) public dataStoreIdToL2RollUpBlock;\\n mapping(uint32 => uint256) public dataStoreIdToRollupStoreNumber;\\n mapping(address => bool) private fraudProofWhitelist;\\n\\n address public reSubmitterAddress;\\n uint256 public reRollupIndex;\\n mapping(uint256 => uint256) public reRollupBatchIndex;\\n\\n event RollupStoreInitialized(uint32 dataStoreId, uint256 stratL2BlockNumber, uint256 endL2BlockNumber);\\n event RollupStoreConfirmed(uint256 rollupBatchIndex, uint32 dataStoreId, uint256 stratL2BlockNumber, uint256 endL2BlockNumber);\\n event RollupStoreReverted(uint256 rollupBatchIndex, uint32 dataStoreId, uint256 stratL2BlockNumber, uint256 endL2BlockNumber);\\n event ReRollupBatchData(uint256 reRollupIndex, uint256 rollupBatchIndex, uint256 stratL2BlockNumber, uint256 endL2BlockNumber);\\n event SequencerAddressUpdated(address oldSequencerAddress, address newSequencerAddress);\\n event FraudProofPeriodUpdated(uint256 oldFraudProofPeriod, uint256 newFraudProofPeriod);\\n event ReSubmitterAddressUpdated(address oldReSubmitterAddress, address newReSubmitterAddress);\\n event RollupBatchIndexUpdated(uint256 oldRollupBatchIndex, uint256 newRollupBatchIndex);\\n event L2ConfirmedBlockNumberUpdated(uint256 oldL2ConfirmedBlockNumber, uint256 newL2ConfirmedBlockNumber);\\n event DataLayrManagerAddressUpdated(address oldDataLayrManagerAddress, address newDataLayrManagerAddress);\\n\\n constructor() {\\n _disableInitializers();\\n }\\n\\n function initialize(address _sequencer, address _dataManageAddress, address _reSubmitterAddress, uint256 _block_stale_measure, uint256 _fraudProofPeriod, uint256 _l2SubmittedBlockNumber) public initializer {\\n __Ownable_init();\\n sequencer = _sequencer;\\n dataManageAddress = _dataManageAddress;\\n reSubmitterAddress = _reSubmitterAddress;\\n BLOCK_STALE_MEASURE = _block_stale_measure;\\n fraudProofPeriod = _fraudProofPeriod;\\n l2StoredBlockNumber = _l2SubmittedBlockNumber;\\n l2ConfirmedBlockNumber = _l2SubmittedBlockNumber;\\n }\\n\\n modifier onlySequencer() {\\n require(msg.sender == sequencer, \\\"Only the sequencer can do this action\\\");\\n _;\\n }\\n\\n /**\\n * @notice Returns the block number of the latest stored L2.\\n * @return Latest stored L2 block number.\\n */\\n function getL2StoredBlockNumber() public view returns (uint256) {\\n return l2StoredBlockNumber;\\n }\\n\\n /**\\n * @notice Returns the block number of the latest stored L2.\\n * @return Latest stored L2 block number.\\n */\\n function getL2ConfirmedBlockNumber() public view returns (uint256) {\\n return l2ConfirmedBlockNumber;\\n }\\n\\n /**\\n * @notice Returns the rollup store by l2 block number\\n * @return RollupStore.\\n */\\n function getRollupStoreByRollupBatchIndex(uint256 _rollupBatchIndex) public view returns (RollupStore memory) {\\n return rollupBatchIndexRollupStores[_rollupBatchIndex];\\n }\\n\\n /**\\n * @notice Returns the l2 block number by store id\\n * @return BatchRollupBlock.\\n */\\n function getL2RollUpBlockByDataStoreId(uint32 _dataStoreId) public view returns (BatchRollupBlock memory) {\\n return dataStoreIdToL2RollUpBlock[_dataStoreId];\\n }\\n\\n /**\\n * @notice set fraud proof address\\n * @param _address for fraud proof\\n */\\n function setFraudProofAddress(address _address) external onlySequencer {\\n require(_address != address(0), \\\"setFraudProofAddress: address is the zero address\\\");\\n fraudProofWhitelist[_address] = true;\\n }\\n\\n /**\\n * @notice unavailable fraud proof address\\n * @param _address for fraud proof\\n */\\n function unavailableFraudProofAddress(address _address) external onlySequencer {\\n require(_address != address(0), \\\"unavailableFraudProofAddress: unavailableFraudProofAddress: address is the zero address\\\");\\n fraudProofWhitelist[_address] = false;\\n }\\n\\n /**\\n * @notice remove fraud proof address\\n * @param _address for fraud proof\\n */\\n function removeFraudProofAddress(address _address) external onlySequencer {\\n require(_address != address(0), \\\"removeFraudProofAddress: removeFraudProofAddress: address is the zero address\\\");\\n delete fraudProofWhitelist[_address];\\n }\\n\\n /**\\n * @notice update fraud proof period\\n * @param _fraudProofPeriod fraud proof period\\n */\\n function updateFraudProofPeriod(uint256 _fraudProofPeriod) external onlySequencer {\\n uint256 oldFraudProofPeriod = fraudProofPeriod;\\n fraudProofPeriod = _fraudProofPeriod;\\n emit FraudProofPeriodUpdated(oldFraudProofPeriod, fraudProofPeriod);\\n }\\n\\n /**\\n * @notice update dlsm address\\n * @param _dataManageAddress dlsm address\\n */\\n function updateDataLayrManagerAddress(address _dataManageAddress) external onlySequencer {\\n require(_dataManageAddress != address(0), \\\"updateDataLayrManagerAddress: _dataManageAddress is the zero address\\\");\\n address oldDataManageAddress = dataManageAddress;\\n dataManageAddress = _dataManageAddress;\\n emit DataLayrManagerAddressUpdated(oldDataManageAddress, dataManageAddress);\\n }\\n\\n /**\\n * @notice update l2 latest store block number\\n * @param _l2StoredBlockNumber l2 latest block number\\n */\\n function updateL2StoredBlockNumber(uint256 _l2StoredBlockNumber) external onlySequencer {\\n uint256 oldL2StoredBlockNumber = l2StoredBlockNumber;\\n l2StoredBlockNumber = _l2StoredBlockNumber;\\n emit L2ConfirmedBlockNumberUpdated(oldL2StoredBlockNumber, l2StoredBlockNumber);\\n }\\n\\n /**\\n * @notice update l2 latest confirm block number\\n * @param _l2ConfirmedBlockNumber l2 latest block number\\n */\\n function updateL2ConfirmedBlockNumber(uint256 _l2ConfirmedBlockNumber) external onlySequencer {\\n l2ConfirmedBlockNumber = _l2ConfirmedBlockNumber;\\n }\\n\\n /**\\n * @notice update sequencer address\\n * @param _sequencer update sequencer address\\n */\\n function updateSequencerAddress(address _sequencer) external onlyOwner {\\n require(_sequencer != address(0), \\\"updateSequencerAddress: _sequencer is the zero address\\\");\\n address oldSequencer = sequencer;\\n sequencer = _sequencer;\\n emit SequencerAddressUpdated(oldSequencer, sequencer);\\n }\\n\\n function updateReSubmitterAddress(address _reSubmitterAddress) external onlySequencer {\\n require(_reSubmitterAddress != address(0), \\\"updateReSubmitterAddress: _reSubmitterAddress is the zero address\\\");\\n address oldReSubmitterAddress = reSubmitterAddress;\\n reSubmitterAddress = _reSubmitterAddress;\\n emit ReSubmitterAddressUpdated(oldReSubmitterAddress, reSubmitterAddress);\\n }\\n\\n /**\\n * @notice update rollup batch index\\n * @param _rollupBatchIndex update rollup batch index\\n */\\n function updateRollupBatchIndex(uint256 _rollupBatchIndex) external onlySequencer {\\n uint256 oldRollupBatchIndex = rollupBatchIndex;\\n rollupBatchIndex = _rollupBatchIndex;\\n emit RollupBatchIndexUpdated(oldRollupBatchIndex, rollupBatchIndex);\\n }\\n\\n /**\\n * @notice reset batch rollup batch data\\n * @param _rollupBatchIndex update rollup index\\n */\\n function resetRollupBatchData(uint256 _rollupBatchIndex) external onlySequencer {\\n for (uint256 i = _rollupBatchIndex; i < rollupBatchIndex; i++) {\\n delete rollupBatchIndexRollupStores[i];\\n }\\n rollupBatchIndex = _rollupBatchIndex;\\n l2StoredBlockNumber = 1;\\n l2ConfirmedBlockNumber = 1;\\n }\\n\\n /**\\n * @notice submit re-rollup batch index\\n * @param batchIndex need re-rollup batch index\\n */\\n function submitReRollUpInfo(\\n uint256 batchIndex\\n ) external {\\n require(msg.sender == reSubmitterAddress, \\\"submitReRollUpInfo: Only the re submitter can submit re rollup data\\\");\\n RollupStore memory rStore = rollupBatchIndexRollupStores[batchIndex];\\n if (rStore.dataStoreId > 0) {\\n reRollupBatchIndex[reRollupIndex] = batchIndex;\\n emit ReRollupBatchData(\\n reRollupIndex++,\\n batchIndex,\\n dataStoreIdToL2RollUpBlock[rStore.dataStoreId].startL2BlockNumber,\\n dataStoreIdToL2RollUpBlock[rStore.dataStoreId].endBL2BlockNumber\\n );\\n }\\n }\\n\\n /**\\n * @notice Called by the (staked) sequencer to pay for a datastore and post some metadata (in the `header` parameter) about it on chain.\\n * Since the sequencer must encode the data before they post the header on chain, they must use a *snapshot* of the number and stakes of DataLayr operators\\n * from a previous block number, specified by the `blockNumber` input.\\n * @param header of data to be stored\\n * @param duration is the duration to store the datastore for\\n * @param blockNumber is the previous block number which was used to encode the data for storage\\n * @param totalOperatorsIndex is index in the totalOperators array of DataLayr referring to what the total number of operators was at `blockNumber`\\n * @dev The specified `blockNumber `must be less than `BLOCK_STALE_MEASURE` blocks in the past.\\n */\\n function storeData(\\n bytes calldata header,\\n uint8 duration,\\n uint32 blockNumber,\\n uint256 startL2Block,\\n uint256 endL2Block,\\n uint32 totalOperatorsIndex,\\n bool isReRollup\\n ) external onlySequencer {\\n require(startL2Block == l2ConfirmedBlockNumber, \\\"storeData: startL2Block must equal last l2ConfirmedBlockNumber\\\");\\n require(endL2Block > startL2Block, \\\"storeData: endL2Block must more than startL2Block\\\");\\n require(block.number - blockNumber < BLOCK_STALE_MEASURE, \\\"storeData: stakes taken from too long ago\\\");\\n uint32 dataStoreId = IDataLayrServiceManager(dataManageAddress).taskNumber();\\n IDataLayrServiceManager(dataManageAddress).initDataStore(\\n msg.sender,\\n address(this),\\n duration,\\n blockNumber,\\n totalOperatorsIndex,\\n header\\n );\\n dataStoreIdToL2RollUpBlock[dataStoreId] = BatchRollupBlock({\\n startL2BlockNumber: startL2Block,\\n endBL2BlockNumber: endL2Block,\\n isReRollup: isReRollup\\n });\\n dataStoreIdToRollupStoreNumber[dataStoreId] = DATA_STORE_INITIALIZED_BUT_NOT_CONFIRMED;\\n if (!isReRollup) {\\n l2StoredBlockNumber = endL2Block;\\n }\\n emit RollupStoreInitialized(dataStoreId, startL2Block, endL2Block);\\n }\\n\\n /**\\n * @notice After the `storeData `transaction is included in a block and doesn\\u2019t revert, the sequencer will disperse the data to the DataLayr nodes off chain\\n * and get their signatures that they have stored the data. Now, the sequencer has to post the signature on chain and get it verified.\\n * @param data Input of the header information for a dataStore and signatures for confirming the dataStore -- used as input to the `confirmDataStore` function\\n * of the DataLayrServiceManager -- see the DataLayr docs for more info on this.\\n * @param searchData Data used to specify the dataStore being confirmed. Must be provided so other contracts can properly look up the dataStore.\\n * @dev Only dataStores created through this contract can be confirmed by calling this function.\\n */\\n function confirmData(\\n bytes calldata data,\\n IDataLayrServiceManager.DataStoreSearchData memory searchData,\\n uint256 startL2Block,\\n uint256 endL2Block,\\n uint32 originDataStoreId,\\n uint256 reConfirmedBatchIndex,\\n bool isReRollup\\n ) external onlySequencer {\\n require(startL2Block == l2ConfirmedBlockNumber, \\\"confirmData: startL2Block must equal last l2ConfirmedBlockNumber\\\");\\n require(endL2Block > startL2Block, \\\"confirmData: endL2Block must more than startL2Block\\\");\\n BatchRollupBlock memory batchRollupBlock = dataStoreIdToL2RollUpBlock[searchData.metadata.globalDataStoreId];\\n require(batchRollupBlock.startL2BlockNumber == startL2Block &&\\n batchRollupBlock.endBL2BlockNumber == endL2Block &&\\n batchRollupBlock.isReRollup == isReRollup,\\n \\\"confirmData: Data store either was not initialized by the rollup contract, or is already confirmed\\\"\\n );\\n require(\\n dataStoreIdToRollupStoreNumber[searchData.metadata.globalDataStoreId] == DATA_STORE_INITIALIZED_BUT_NOT_CONFIRMED,\\n \\\"confirmData: Data store either was not initialized by the rollup contract, or is already confirmed\\\"\\n );\\n IDataLayrServiceManager(dataManageAddress).confirmDataStore(data, searchData);\\n if (!isReRollup) {\\n rollupBatchIndexRollupStores[rollupBatchIndex] = RollupStore({\\n originDataStoreId: searchData.metadata.globalDataStoreId,\\n dataStoreId: searchData.metadata.globalDataStoreId,\\n confirmAt: uint32(block.timestamp + fraudProofPeriod),\\n status: RollupStoreStatus.COMMITTED\\n });\\n l2ConfirmedBlockNumber = endL2Block;\\n dataStoreIdToRollupStoreNumber[searchData.metadata.globalDataStoreId] = rollupBatchIndex;\\n emit RollupStoreConfirmed(uint32(rollupBatchIndex++), searchData.metadata.globalDataStoreId, startL2Block, endL2Block);\\n } else {\\n rollupBatchIndexRollupStores[reConfirmedBatchIndex] = RollupStore({\\n originDataStoreId: originDataStoreId,\\n dataStoreId: searchData.metadata.globalDataStoreId,\\n confirmAt: uint32(block.timestamp + fraudProofPeriod),\\n status: RollupStoreStatus.COMMITTED\\n });\\n dataStoreIdToRollupStoreNumber[searchData.metadata.globalDataStoreId] = reConfirmedBatchIndex;\\n emit RollupStoreConfirmed(reConfirmedBatchIndex, searchData.metadata.globalDataStoreId, startL2Block, endL2Block);\\n }\\n }\\n\\n /**\\n * @notice Called by a challenger (this could be anyone -- \\\"challenger\\\" is not a permissioned role) to prove that fraud has occurred.\\n * First, a subset of data included in a dataStore that was initiated by the sequencer is proven, and then the presence of fraud in the data is checked.\\n * For the sake of this example, \\\"fraud occurring\\\" means that the sequencer included the forbidden `FRAUD_STRING` in a dataStore that they initiated.\\n * In pratical use, \\\"fraud occurring\\\" might mean including data that specifies an invalid transaction or invalid state transition.\\n * @param fraudulentStoreNumber The rollup l2Block to prove fraud on\\n * @param startIndex The index to begin reading the proven data from\\n * @param searchData Data used to specify the dataStore being fraud-proven. Must be provided so other contracts can properly look up the dataStore.\\n * @param disclosureProofs Non-interactive polynomial proofs that prove that the specific data of interest was part of the dataStore in question.\\n * @dev This function is only callable if:\\n * -the sequencer is staked,\\n * -the dataStore in question has been confirmed, and\\n * -the fraudproof period for the dataStore has not yet passed.\\n */\\n function proveFraud(\\n uint256 fraudulentStoreNumber,\\n uint256 startIndex,\\n IDataLayrServiceManager.DataStoreSearchData memory searchData,\\n DisclosureProofs calldata disclosureProofs\\n ) external {\\n require(fraudProofWhitelist[msg.sender], \\\"proveFraud: Only fraud proof white list can challenge data\\\");\\n RollupStore memory rollupStore = rollupBatchIndexRollupStores[fraudulentStoreNumber];\\n require(rollupStore.status == RollupStoreStatus.COMMITTED && rollupStore.confirmAt > block.timestamp, \\\"RollupStore must be committed and unconfirmed\\\");\\n require(\\n IDataLayrServiceManager(dataManageAddress).getDataStoreHashesForDurationAtTimestamp(\\n searchData.duration,\\n searchData.timestamp,\\n searchData.index\\n ) == DataStoreUtils.computeDataStoreHash(searchData.metadata),\\n \\\"proveFraud: metadata preimage is incorrect\\\"\\n );\\n require(searchData.metadata.globalDataStoreId == rollupStore.dataStoreId, \\\"seachData's datastore id is not consistent with given rollup store\\\");\\n require(searchData.metadata.headerHash == keccak256(disclosureProofs.header), \\\"disclosure proofs headerhash preimage is incorrect\\\");\\n require(DataLayrDisclosureLogic.batchNonInteractivePolynomialProofs(\\n disclosureProofs.header,\\n disclosureProofs.firstChunkNumber,\\n disclosureProofs.polys,\\n disclosureProofs.multiRevealProofs,\\n disclosureProofs.polyEquivalenceProof\\n ), \\\"disclosure proofs are invalid\\\");\\n uint32 numSys = DataLayrDisclosureLogic.getNumSysFromHeader(disclosureProofs.header);\\n require(disclosureProofs.firstChunkNumber + disclosureProofs.polys.length <= numSys, \\\"Can only prove data from the systematic chunks\\\");\\n bytes memory provenString = parse(disclosureProofs.polys, startIndex, FRAUD_STRING.length);\\n require(provenString.length == FRAUD_STRING.length, \\\"Parsing error, proven string is different length than fraud string\\\");\\n require(keccak256(provenString) == keccak256(FRAUD_STRING), \\\"proven string != fraud string\\\");\\n rollupBatchIndexRollupStores[fraudulentStoreNumber].status = RollupStoreStatus.REVERTED;\\n emit RollupStoreReverted(\\n fraudulentStoreNumber,\\n searchData.metadata.globalDataStoreId,\\n dataStoreIdToL2RollUpBlock[searchData.metadata.globalDataStoreId].startL2BlockNumber,\\n dataStoreIdToL2RollUpBlock[searchData.metadata.globalDataStoreId].endBL2BlockNumber\\n );\\n }\\n}\\n\",\"keccak256\":\"0x1b8d036f004c9bd1f2c9a32efb8f746b75f7d8b1d41ade493372c7c0e57f6210\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/BN254.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED AND MIT\\n// several functions are taken or adapted from https://github.com/HarryR/solcrypto/blob/master/contracts/altbn128.sol (MIT license):\\n// Copyright 2017 Christian Reitwiessner\\n// Permission is hereby granted, free of charge, to any person obtaining a copy\\n// of this software and associated documentation files (the \\\"Software\\\"), to\\n// deal in the Software without restriction, including without limitation the\\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\\n// sell copies of the Software, and to permit persons to whom the Software is\\n// furnished to do so, subject to the following conditions:\\n// The above copyright notice and this permission notice shall be included in\\n// all copies or substantial portions of the Software.\\n// THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\\n// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\\n// IN THE SOFTWARE.\\n\\n// The remainder of the code is written by LayrLabs Inc. and UNLICENSED\\n\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Library for operations on the BN254 elliptic curve.\\n * @author Layr Labs, Inc.\\n * @notice Contains BN254 parameters, common operations (addition, scalar mul, pairing), and BLS signature functionality.\\n */\\nlibrary BN254 {\\n // modulus for the underlying field F_p of the elliptic curve\\n uint256 internal constant FP_MODULUS =\\n 21888242871839275222246405745257275088696311157297823662689037894645226208583;\\n // modulus for the underlying field F_r of the elliptic curve\\n uint256 internal constant FR_MODULUS =\\n 21888242871839275222246405745257275088548364400416034343698204186575808495617;\\n\\n // primitive root of unity\\n uint256 internal constant OMEGA = 10359452186428527605436343203440067497552205259388878191021578220384701716497;\\n\\n\\n struct G1Point {\\n uint256 X;\\n uint256 Y;\\n }\\n\\n // Encoding of field elements is: X[1] * i + X[0]\\n struct G2Point {\\n uint256[2] X;\\n uint256[2] Y;\\n }\\n\\n // generator of group G2\\n /// @dev Generator point in F_q2 is of the form: (x0 + ix1, y0 + iy1).\\n uint256 internal constant G2x1 =\\n 11559732032986387107991004021392285783925812861821192530917403151452391805634;\\n uint256 internal constant G2x0 =\\n 10857046999023057135944570762232829481370756359578518086990519993285655852781;\\n uint256 internal constant G2y1 =\\n 4082367875863433681332203403145435568316851327593401208105741076214120093531;\\n uint256 internal constant G2y0 =\\n 8495653923123431417604973247489272438418190587263600148770280649306958101930;\\n /// @notice returns the G2 generator\\n /// @dev mind the ordering of the 1s and 0s!\\n /// this is because of the (unknown to us) convention used in the bn254 pairing precompile contract\\n /// \\\"Elements a * i + b of F_p^2 are encoded as two elements of F_p, (a, b).\\\"\\n /// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-197.md#encoding\\n function generatorG2() internal pure returns (G2Point memory) {\\n return G2Point(\\n [G2x1, G2x0], [G2y1, G2y0]\\n );\\n }\\n\\n // negation of the generator of group G2\\n /// @dev Generator point in F_q2 is of the form: (x0 + ix1, y0 + iy1).\\n uint256 internal constant nG2x1 =\\n 11559732032986387107991004021392285783925812861821192530917403151452391805634;\\n uint256 internal constant nG2x0 =\\n 10857046999023057135944570762232829481370756359578518086990519993285655852781;\\n uint256 internal constant nG2y1 =\\n 17805874995975841540914202342111839520379459829704422454583296818431106115052;\\n uint256 internal constant nG2y0 =\\n 13392588948715843804641432497768002650278120570034223513918757245338268106653;\\n function negGeneratorG2() internal pure returns (G2Point memory) {\\n return G2Point(\\n [nG2x1, nG2x0], [nG2y1, nG2y0]\\n );\\n }\\n\\n // first power of srs in G2\\n // TODO: change in production\\n uint256 internal constant G2SRSx1 = 7912312892787135728292535536655271843828059318189722219035249994421084560563;\\n uint256 internal constant G2SRSx0 = 21039730876973405969844107393779063362038454413254731404052240341412356318284;\\n uint256 internal constant G2SRSy1 = 18697407556011630376420900106252341752488547575648825575049647403852275261247;\\n uint256 internal constant G2SRSy0 = 7586489485579523767759120334904353546627445333297951253230866312564920951171;\\n function G2SRSFirstPower() internal pure returns (G2Point memory) {\\n return G2Point(\\n [G2SRSx0, G2SRSx1], [G2SRSy0, G2SRSy1]\\n );\\n }\\n\\n bytes32 internal constant powersOfTauMerkleRoot =\\n 0x22c998e49752bbb1918ba87d6d59dd0e83620a311ba91dd4b2cc84990b31b56f;\\n\\n\\n /**\\n * @param p Some point in G1.\\n * @return The negation of `p`, i.e. p.plus(p.negate()) should be zero.\\n */\\n function negate(G1Point memory p) internal pure returns (G1Point memory) {\\n // The prime q in the base field F_q for G1\\n if (p.X == 0 && p.Y == 0) {\\n return G1Point(0, 0);\\n } else {\\n return G1Point(p.X, FP_MODULUS - (p.Y % FP_MODULUS));\\n }\\n }\\n\\n /**\\n * @return r the sum of two points of G1\\n */\\n function plus(\\n G1Point memory p1,\\n G1Point memory p2\\n ) internal view returns (G1Point memory r) {\\n uint256[4] memory input;\\n input[0] = p1.X;\\n input[1] = p1.Y;\\n input[2] = p2.X;\\n input[3] = p2.Y;\\n bool success;\\n\\n // solium-disable-next-line security/no-inline-assembly\\n assembly {\\n success := staticcall(sub(gas(), 2000), 6, input, 0x80, r, 0x40)\\n // Use \\\"invalid\\\" to make gas estimation work\\n switch success\\n case 0 {\\n invalid()\\n }\\n }\\n\\n require(success, \\\"ec-add-failed\\\");\\n }\\n\\n /**\\n * @return r the product of a point on G1 and a scalar, i.e.\\n * p == p.scalar_mul(1) and p.plus(p) == p.scalar_mul(2) for all\\n * points p.\\n */\\n function scalar_mul(\\n G1Point memory p,\\n uint256 s\\n ) internal view returns (G1Point memory r) {\\n uint256[3] memory input;\\n input[0] = p.X;\\n input[1] = p.Y;\\n input[2] = s;\\n bool success;\\n // solium-disable-next-line security/no-inline-assembly\\n assembly {\\n success := staticcall(sub(gas(), 2000), 7, input, 0x60, r, 0x40)\\n // Use \\\"invalid\\\" to make gas estimation work\\n switch success\\n case 0 {\\n invalid()\\n }\\n }\\n require(success, \\\"ec-mul-failed\\\");\\n }\\n\\n /**\\n * @return The result of computing the pairing check\\n * e(p1[0], p2[0]) * .... * e(p1[n], p2[n]) == 1\\n * For example,\\n * pairing([P1(), P1().negate()], [P2(), P2()]) should return true.\\n */\\n function pairing(\\n G1Point memory a1,\\n G2Point memory a2,\\n G1Point memory b1,\\n G2Point memory b2\\n ) internal view returns (bool) {\\n G1Point[2] memory p1 = [a1, b1];\\n G2Point[2] memory p2 = [a2, b2];\\n\\n uint256[12] memory input;\\n\\n for (uint256 i = 0; i < 2; i++) {\\n uint256 j = i * 6;\\n input[j + 0] = p1[i].X;\\n input[j + 1] = p1[i].Y;\\n input[j + 2] = p2[i].X[0];\\n input[j + 3] = p2[i].X[1];\\n input[j + 4] = p2[i].Y[0];\\n input[j + 5] = p2[i].Y[1];\\n }\\n\\n uint256[1] memory out;\\n bool success;\\n\\n // solium-disable-next-line security/no-inline-assembly\\n assembly {\\n success := staticcall(\\n sub(gas(), 2000),\\n 8,\\n input,\\n mul(12, 0x20),\\n out,\\n 0x20\\n )\\n // Use \\\"invalid\\\" to make gas estimation work\\n switch success\\n case 0 {\\n invalid()\\n }\\n }\\n\\n require(success, \\\"pairing-opcode-failed\\\");\\n\\n return out[0] != 0;\\n }\\n\\n /**\\n * @notice This function is functionally the same as pairing(), however it specifies a gas limit\\n * the user can set, as a precompile may use the entire gas budget if it reverts.\\n */\\n function safePairing(\\n G1Point memory a1,\\n G2Point memory a2,\\n G1Point memory b1,\\n G2Point memory b2,\\n uint256 pairingGas\\n ) internal view returns (bool, bool) {\\n G1Point[2] memory p1 = [a1, b1];\\n G2Point[2] memory p2 = [a2, b2];\\n\\n uint256[12] memory input;\\n\\n for (uint256 i = 0; i < 2; i++) {\\n uint256 j = i * 6;\\n input[j + 0] = p1[i].X;\\n input[j + 1] = p1[i].Y;\\n input[j + 2] = p2[i].X[0];\\n input[j + 3] = p2[i].X[1];\\n input[j + 4] = p2[i].Y[0];\\n input[j + 5] = p2[i].Y[1];\\n }\\n\\n uint256[1] memory out;\\n bool success;\\n\\n // solium-disable-next-line security/no-inline-assembly\\n assembly {\\n success := staticcall(\\n pairingGas,\\n 8,\\n input,\\n mul(12, 0x20),\\n out,\\n 0x20\\n )\\n }\\n\\n //Out is the output of the pairing precompile, either 0 or 1 based on whether the two pairings are equal.\\n //Success is true if the precompile actually goes through (aka all inputs are valid)\\n\\n return (success, out[0] != 0);\\n }\\n\\n /// @return the keccak256 hash of the G1 Point\\n /// @dev used for BLS signatures\\n function hashG1Point(\\n BN254.G1Point memory pk\\n ) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(pk.X, pk.Y));\\n }\\n\\n\\n /**\\n * @notice adapted from https://github.com/HarryR/solcrypto/blob/master/contracts/altbn128.sol\\n */\\n function hashToG1(bytes32 _x) internal view returns (uint256, uint256) {\\n uint256 beta = 0;\\n uint256 y = 0;\\n\\n // XXX: Gen Order (n) or Field Order (p) ?\\n uint256 x = uint256(_x) % FP_MODULUS;\\n\\n while( true ) {\\n (beta, y) = findYFromX(x);\\n\\n // y^2 == beta\\n if( beta == mulmod(y, y, FP_MODULUS) ) {\\n return (x, y);\\n }\\n\\n x = addmod(x, 1, FP_MODULUS);\\n }\\n return (0, 0);\\n }\\n\\n /**\\n * Given X, find Y\\n *\\n * where y = sqrt(x^3 + b)\\n *\\n * Returns: (x^3 + b), y\\n */\\n function findYFromX(uint256 x)\\n internal view returns(uint256, uint256)\\n {\\n // beta = (x^3 + b) % p\\n uint256 beta = addmod(mulmod(mulmod(x, x, FP_MODULUS), x, FP_MODULUS), 3, FP_MODULUS);\\n\\n // y^2 = x^3 + b\\n // this acts like: y = sqrt(beta) = beta^((p+1) / 4)\\n uint256 y = expMod(beta, 0xc19139cb84c680a6e14116da060561765e05aa45a1c72a34f082305b61f3f52, FP_MODULUS);\\n\\n return (beta, y);\\n }\\n\\n function expMod(uint256 _base, uint256 _exponent, uint256 _modulus) internal view returns (uint256 retval) {\\n bool success;\\n uint256[1] memory output;\\n uint[6] memory input;\\n input[0] = 0x20; // baseLen = new(big.Int).SetBytes(getData(input, 0, 32))\\n input[1] = 0x20; // expLen = new(big.Int).SetBytes(getData(input, 32, 32))\\n input[2] = 0x20; // modLen = new(big.Int).SetBytes(getData(input, 64, 32))\\n input[3] = _base;\\n input[4] = _exponent;\\n input[5] = _modulus;\\n assembly {\\n success := staticcall(sub(gas(), 2000), 5, input, 0xc0, output, 0x20)\\n // Use \\\"invalid\\\" to make gas estimation work\\n switch success case 0 { invalid() }\\n }\\n require(success);\\n return output[0];\\n }\\n}\\n\",\"keccak256\":\"0xfa39af1ea6c1dd15972030b6ce7cbe29f6a32b020977633cd4f31caa4bc08d07\",\"license\":\"UNLICENSED AND MIT\"},\"contracts/libraries/eigenda/DataLayrDisclosureLogic.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"./Merkle.sol\\\";\\nimport \\\"./BN254.sol\\\";\\nimport \\\"./interfaces/IDataLayrServiceManager.sol\\\";\\n\\nlibrary DataLayrDisclosureLogic {\\n uint256 constant MODULUS =\\n 21888242871839275222246405745257275088548364400416034343698204186575808495617;\\n\\n struct MultiRevealProof {\\n BN254.G1Point interpolationPoly;\\n BN254.G1Point revealProof;\\n BN254.G2Point zeroPoly;\\n bytes zeroPolyProof;\\n }\\n\\n struct DataStoreKZGMetadata {\\n BN254.G1Point c;\\n uint48 degree;\\n uint32 numSys;\\n uint32 numPar;\\n }\\n\\n function getDataCommitmentAndMultirevealDegreeAndSymbolBreakdownFromHeader(\\n // bytes calldata header\\n bytes calldata header\\n ) internal pure returns (DataStoreKZGMetadata memory) {\\n // return x, y coordinate of overall data poly commitment\\n // then return degree of multireveal polynomial\\n BN254.G1Point memory point;\\n uint48 degree;\\n uint32 numSys;\\n uint32 numPar;\\n uint256 pointer;\\n\\n assembly {\\n pointer := header.offset\\n mstore(point, calldataload(pointer))\\n mstore(add(point, 0x20), calldataload(add(pointer, 32)))\\n //TODO: PUT THE LOW DEGREENESS PROOF HERE\\n degree := shr(224, calldataload(add(pointer, 64)))\\n\\n numSys := shr(224, calldataload(add(pointer, 68)))\\n numPar := shr(224, calldataload(add(pointer, 72)))\\n }\\n\\n return\\n DataStoreKZGMetadata({\\n c: point,\\n degree: degree,\\n numSys: numSys,\\n numPar: numPar\\n });\\n }\\n\\n function getNumSysFromHeader(\\n // bytes calldata header\\n bytes calldata header\\n ) internal pure returns (uint32) {\\n uint32 numSys;\\n\\n assembly {\\n numSys := shr(224, calldataload(add(header.offset, 68)))\\n }\\n\\n return numSys;\\n }\\n\\n function getLeadingCosetIndexFromHighestRootOfUnity(\\n uint32 i,\\n uint32 numSys,\\n uint32 numPar\\n ) internal pure returns (uint32) {\\n uint32 numNode = numSys + numPar;\\n uint32 numSysE = uint32(nextPowerOf2(numSys));\\n uint32 ratio = numNode / numSys + (numNode % numSys == 0 ? 0 : 1);\\n uint32 numNodeE = uint32(nextPowerOf2(numSysE * ratio));\\n\\n if (i < numSys) {\\n return\\n (reverseBitsLimited(uint32(numNodeE), uint32(i)) * 256) /\\n numNodeE;\\n } else if (i < numNodeE - (numSysE - numSys)) {\\n return\\n (reverseBitsLimited(\\n uint32(numNodeE),\\n uint32((i - numSys) + numSysE)\\n ) * 256) / numNodeE;\\n } else {\\n revert(\\\"Cannot create number of frame higher than possible\\\");\\n }\\n }\\n\\n function reverseBitsLimited(uint32 length, uint32 value)\\n internal\\n pure\\n returns (uint32)\\n {\\n uint32 unusedBitLen = 32 - uint32(log2(length));\\n return reverseBits(value) >> unusedBitLen;\\n }\\n\\n function reverseBits(uint32 value) internal pure returns (uint32) {\\n uint256 reversed = 0;\\n for (uint i = 0; i < 32; i++) {\\n uint256 mask = 1 << i;\\n if (value & mask != 0) {\\n reversed |= (1 << (31 - i));\\n }\\n }\\n return uint32(reversed);\\n }\\n\\n //takes the log base 2 of n and returns it\\n function log2(uint256 n) internal pure returns (uint256) {\\n require(n > 0, \\\"Log must be defined\\\");\\n uint256 log = 0;\\n while (n >> log != 1) {\\n log++;\\n }\\n return log;\\n }\\n\\n //finds the next power of 2 greater than n and returns it\\n function nextPowerOf2(uint256 n) internal pure returns (uint256) {\\n uint256 res = 1;\\n while (1 << res < n) {\\n res++;\\n }\\n res = 1 << res;\\n return res;\\n }\\n\\n // gets the merkle root of a tree where all the leaves are the hashes of the zero/vanishing polynomials of the given multireveal\\n // degree at different roots of unity. We are assuming a max of 512 datalayr nodes right now, so, for merkle root for \\\"degree\\\"\\n // will be of the tree where the leaves are the hashes of the G2 kzg commitments to the following polynomials:\\n // l = degree (for brevity)\\n // w^(512*l) = 1\\n // (s^l - 1), (s^l - w^l), (s^l - w^2l), (s^l - w^3l), (s^l - w^4l), ...\\n // we have precomputed these values and return them directly because it's cheap. currently we\\n // tolerate up to degree 2^10, which means up to (31 bytes/point)(1024 points/dln)(256 dln) = 8 MB in a datastore\\n function getZeroPolyMerkleRoot(uint256 degree)\\n internal\\n pure\\n returns (bytes32)\\n {\\n uint256 log = log2(degree);\\n\\n if (log == 0) {\\n return\\n 0xe82cea94884b1b895ea0742840a3b19249a723810fd1b04d8564d675b0a416f1;\\n } else if (log == 1) {\\n return\\n 0x4843774a80fc8385b31024f5bd18b42e62de439206ab9468d42d826796d41f67;\\n } else if (log == 2) {\\n return\\n 0x092d3e5f87f5293e7ab0cc2ca6b0b5e4adb5e0011656544915f7cea34e69e5ab;\\n } else if (log == 3) {\\n return\\n 0x494b208540ec8624fbbb3f2c64ffccdaf6253f8f4e50c0d93922d88195b07755;\\n } else if (log == 4) {\\n return\\n 0xfdb44b84a82893cfa0e37a97f09ffc4298ad5e62be1bea1d03320ae836213d22;\\n } else if (log == 5) {\\n return\\n 0x3f50cb08231d2a76853ba9dbb20dad45a1b75c57cdaff6223bfe069752cff3d4;\\n } else if (log == 6) {\\n return\\n 0xbb39eebd8138eefd5802a49d571e65b3e0d4e32277c28fbf5fbca66e7fb04310;\\n } else if (log == 7) {\\n return\\n 0xf0a39b513e11fa80cbecbf352f69310eddd5cd03148768e0e9542bd600b133ec;\\n } else if (log == 8) {\\n return\\n 0x038cca2238865414efb752cc004fffec9e6069b709f495249cdf36efbd5952f6;\\n } else if (log == 9) {\\n return\\n 0x2a26b054ed559dd255d8ac9060ebf6b95b768d87de767f8174ad2f9a4e48dd01;\\n } else if (log == 10) {\\n return\\n 0x1fe180d0bc4ff7c69fefa595b3b5f3c284535a280f6fdcf69b20770d1e20e1fc;\\n } else if (log == 11) {\\n return\\n 0x60e34ad57c61cd6fdd8177437c30e4a30334e63d7683989570cf27020efc8201;\\n } else if (log == 12) {\\n return\\n 0xeda2417e770ddbe88f083acf06b6794dfb76301314a32bd0697440d76f6cd9cc;\\n } else if (log == 13) {\\n return\\n 0x8cbe9b8cf92ce70e3bec8e1e72a0f85569017a7e43c3db50e4a5badb8dea7ce8;\\n } else {\\n revert(\\\"Log not in valid range\\\");\\n }\\n }\\n\\n // opens up kzg commitment c(x) at r and makes sure c(r) = s. proof (pi) is in G2 to allow for calculation of Z in G1\\n function openPolynomialAtPoint(\\n BN254.G1Point memory c,\\n BN254.G2Point calldata pi,\\n uint256 r,\\n uint256 s\\n ) internal view returns (bool) {\\n //we use and overwrite z as temporary storage\\n //g1 = (1, 2)\\n BN254.G1Point memory g1Gen = BN254.G1Point({X: 1, Y: 2});\\n //calculate -g1*r = -[r]_1\\n BN254.G1Point memory z = BN254.scalar_mul(BN254.negate(g1Gen), r);\\n\\n //add [x]_1 - [r]_1 = Z and store in first 2 slots of input\\n //CRITIC TODO: SWITCH THESE TO [x]_1 of Powers of Tau!\\n BN254.G1Point memory firstPowerOfTau = BN254.G1Point({\\n X: 15397661830938158195220872607788450164522003659458108417904919983213308643927,\\n Y: 4051901473739185471504766068400292374549287637553596337727654132125147894034\\n });\\n z = BN254.plus(firstPowerOfTau, z);\\n //calculate -g1*s = -[s]_1\\n BN254.G1Point memory negativeS = BN254.scalar_mul(\\n BN254.negate(g1Gen),\\n s\\n );\\n //calculate C-[s]_1\\n BN254.G1Point memory cMinusS = BN254.plus(c, negativeS);\\n\\n //check e(z, pi)e(C-[s]_1, -g2) = 1\\n return BN254.pairing(z, pi, cMinusS, BN254.negGeneratorG2());\\n }\\n\\n function validateDisclosureResponse(\\n DataStoreKZGMetadata memory dskzgMetadata,\\n uint32 chunkNumber,\\n BN254.G1Point calldata interpolationPoly,\\n BN254.G1Point calldata revealProof,\\n BN254.G2Point memory zeroPoly,\\n bytes calldata zeroPolyProof\\n ) internal view returns (bool) {\\n // check that [zeroPoly.x0, zeroPoly.x1, zeroPoly.y0, zeroPoly.y1] is actually the \\\"chunkNumber\\\" leaf\\n // of the zero polynomial Merkle tree\\n\\n {\\n //deterministic assignment of \\\"y\\\" here\\n // @todo\\n require(\\n Merkle.verifyInclusionKeccak(\\n // Merkle proof\\n zeroPolyProof,\\n // Merkle root hash\\n getZeroPolyMerkleRoot(dskzgMetadata.degree),\\n // leaf\\n keccak256(\\n abi.encodePacked(\\n zeroPoly.X[1],\\n zeroPoly.X[0],\\n zeroPoly.Y[1],\\n zeroPoly.Y[0]\\n )\\n ),\\n // index in the Merkle tree\\n getLeadingCosetIndexFromHighestRootOfUnity(\\n chunkNumber,\\n dskzgMetadata.numSys,\\n dskzgMetadata.numPar\\n )\\n ),\\n \\\"Incorrect zero poly merkle proof\\\"\\n );\\n }\\n\\n /**\\n Doing pairing verification e(Pi(s), Z_k(s)).e(C - I, -g2) == 1\\n */\\n //get the commitment to the zero polynomial of multireveal degree\\n\\n // calculate [C]_1 - [I]_1\\n BN254.G1Point memory cMinusI = BN254.plus(\\n dskzgMetadata.c,\\n BN254.negate(interpolationPoly)\\n );\\n\\n //check e(z, pi)e(C-[s]_1, -g2) = 1\\n return BN254.pairing(revealProof, zeroPoly, cMinusI, BN254.negGeneratorG2());\\n }\\n\\n function nonInteractivePolynomialProof(\\n bytes calldata header,\\n uint32 chunkNumber,\\n bytes calldata poly,\\n MultiRevealProof calldata multiRevealProof,\\n BN254.G2Point calldata polyEquivalenceProof\\n ) internal view returns (bool) {\\n DataStoreKZGMetadata\\n memory dskzgMetadata = getDataCommitmentAndMultirevealDegreeAndSymbolBreakdownFromHeader(\\n header\\n );\\n\\n //verify pairing for the commitment to interpolating polynomial\\n require(\\n validateDisclosureResponse(\\n dskzgMetadata,\\n chunkNumber,\\n multiRevealProof.interpolationPoly,\\n multiRevealProof.revealProof,\\n multiRevealProof.zeroPoly,\\n multiRevealProof.zeroPolyProof\\n ),\\n \\\"Reveal failed due to non 1 pairing\\\"\\n );\\n\\n // TODO: verify that this check is correct!\\n // check that degree of polynomial in the header matches the length of the submitted polynomial\\n // i.e. make sure submitted polynomial doesn't contain extra points\\n require(\\n (dskzgMetadata.degree + 1) * 32 == poly.length,\\n \\\"Polynomial must have a 256 bit coefficient for each term\\\"\\n );\\n\\n //Calculating r, the point at which to evaluate the interpolating polynomial\\n uint256 r = uint256(\\n keccak256(\\n abi.encodePacked(\\n keccak256(poly),\\n multiRevealProof.interpolationPoly.X,\\n multiRevealProof.interpolationPoly.Y\\n )\\n )\\n ) % MODULUS;\\n uint256 s = linearPolynomialEvaluation(poly, r);\\n return\\n openPolynomialAtPoint(\\n multiRevealProof.interpolationPoly,\\n polyEquivalenceProof,\\n r,\\n s\\n );\\n }\\n\\n function verifyPolyEquivalenceProof(\\n bytes calldata poly,\\n BN254.G1Point calldata interpolationPoly,\\n BN254.G2Point calldata polyEquivalenceProof\\n ) internal view returns (bool) {\\n //Calculating r, the point at which to evaluate the interpolating polynomial\\n uint256 r = uint256(\\n keccak256(\\n abi.encodePacked(\\n keccak256(poly),\\n interpolationPoly.X,\\n interpolationPoly.Y\\n )\\n )\\n ) % MODULUS;\\n uint256 s = linearPolynomialEvaluation(poly, r);\\n bool ok = openPolynomialAtPoint(\\n interpolationPoly,\\n polyEquivalenceProof,\\n r,\\n s\\n );\\n return ok;\\n }\\n\\n function verifyBatchPolyEquivalenceProof(\\n bytes[] calldata polys,\\n BN254.G1Point[] calldata interpolationPolys,\\n BN254.G2Point calldata polyEquivalenceProof\\n ) internal view returns (bool) {\\n bytes32[] memory rs = new bytes32[](polys.length);\\n //Calculating r, the point at which to evaluate the interpolating polynomial\\n for (uint i = 0; i < polys.length; i++) {\\n rs[i] = keccak256(\\n abi.encodePacked(\\n keccak256(polys[i]),\\n interpolationPolys[i].X,\\n interpolationPolys[i].Y\\n )\\n );\\n }\\n //this is the point to open each polynomial at\\n uint256 r = uint256(keccak256(abi.encodePacked(rs))) % MODULUS;\\n //this is the offset we add to each polynomial to prevent collision\\n //we use array to help with stack\\n uint256[2] memory gammaAndGammaPower;\\n gammaAndGammaPower[0] =\\n uint256(keccak256(abi.encodePacked(rs, uint256(0)))) %\\n MODULUS;\\n gammaAndGammaPower[1] = gammaAndGammaPower[0];\\n //store I1\\n BN254.G1Point memory gammaShiftedCommitmentSum = interpolationPolys[0];\\n //store I1(r)\\n uint256 gammaShiftedEvaluationSum = linearPolynomialEvaluation(\\n polys[0],\\n r\\n );\\n for (uint i = 1; i < interpolationPolys.length; i++) {\\n //gammaShiftedCommitmentSum += gamma^i * Ii\\n gammaShiftedCommitmentSum = BN254.plus(\\n gammaShiftedCommitmentSum,\\n BN254.scalar_mul(interpolationPolys[i], gammaAndGammaPower[1])\\n );\\n //gammaShiftedEvaluationSum += gamma^i * Ii(r)\\n uint256 eval = linearPolynomialEvaluation(polys[i], r);\\n gammaShiftedEvaluationSum = addmod(\\n gammaShiftedEvaluationSum,\\n mulmod(gammaAndGammaPower[1], eval, MODULUS),\\n MODULUS\\n );\\n // gammaPower = gamma^(i+1)\\n gammaAndGammaPower[1] = mulmod(\\n gammaAndGammaPower[0],\\n gammaAndGammaPower[1],\\n MODULUS\\n );\\n }\\n\\n return\\n openPolynomialAtPoint(\\n gammaShiftedCommitmentSum,\\n polyEquivalenceProof,\\n r,\\n gammaShiftedEvaluationSum\\n );\\n }\\n\\n function batchNonInteractivePolynomialProofs(\\n bytes calldata header,\\n uint32 firstChunkNumber,\\n bytes[] calldata polys,\\n MultiRevealProof[] calldata multiRevealProofs,\\n BN254.G2Point calldata polyEquivalenceProof\\n ) internal view returns (bool) {\\n //randomness from each polynomial\\n bytes32[] memory rs = new bytes32[](polys.length);\\n DataStoreKZGMetadata\\n memory dskzgMetadata = getDataCommitmentAndMultirevealDegreeAndSymbolBreakdownFromHeader(\\n header\\n );\\n uint256 numProofs = multiRevealProofs.length;\\n for (uint256 i = 0; i < numProofs; ) {\\n //verify pairing for the commitment to interpolating polynomial\\n require(\\n validateDisclosureResponse(\\n dskzgMetadata,\\n firstChunkNumber + uint32(i),\\n multiRevealProofs[i].interpolationPoly,\\n multiRevealProofs[i].revealProof,\\n multiRevealProofs[i].zeroPoly,\\n multiRevealProofs[i].zeroPolyProof\\n ),\\n \\\"Reveal failed due to non 1 pairing\\\"\\n );\\n\\n // TODO: verify that this check is correct!\\n // check that degree of polynomial in the header matches the length of the submitted polynomial\\n // i.e. make sure submitted polynomial doesn't contain extra points\\n require(\\n dskzgMetadata.degree * 32 == polys[i].length,\\n \\\"Polynomial must have a 256 bit coefficient for each term\\\"\\n );\\n\\n //Calculating r, the point at which to evaluate the interpolating polynomial\\n rs[i] = keccak256(\\n abi.encodePacked(\\n keccak256(polys[i]),\\n multiRevealProofs[i].interpolationPoly.X,\\n multiRevealProofs[i].interpolationPoly.Y\\n )\\n );\\n unchecked {\\n ++i;\\n }\\n }\\n //this is the point to open each polynomial at\\n uint256 r = uint256(keccak256(abi.encodePacked(rs))) % MODULUS;\\n //this is the offset we add to each polynomial to prevent collision\\n //we use array to help with stack\\n uint256[2] memory gammaAndGammaPower;\\n gammaAndGammaPower[0] =\\n uint256(keccak256(abi.encodePacked(rs, uint256(0)))) %\\n MODULUS;\\n gammaAndGammaPower[1] = gammaAndGammaPower[0];\\n //store I1\\n BN254.G1Point memory gammaShiftedCommitmentSum = multiRevealProofs[0]\\n .interpolationPoly;\\n //store I1(r)\\n uint256 gammaShiftedEvaluationSum = linearPolynomialEvaluation(\\n polys[0],\\n r\\n );\\n for (uint i = 1; i < multiRevealProofs.length; i++) {\\n //gammaShiftedCommitmentSum += gamma^i * Ii\\n gammaShiftedCommitmentSum = BN254.plus(\\n gammaShiftedCommitmentSum,\\n BN254.scalar_mul(\\n multiRevealProofs[i].interpolationPoly,\\n gammaAndGammaPower[1]\\n )\\n );\\n //gammaShiftedEvaluationSum += gamma^i * Ii(r)\\n uint256 eval = linearPolynomialEvaluation(polys[i], r);\\n gammaShiftedEvaluationSum = gammaShiftedEvaluationSum = addmod(\\n gammaShiftedEvaluationSum,\\n mulmod(gammaAndGammaPower[1], eval, MODULUS),\\n MODULUS\\n );\\n // gammaPower = gamma^(i+1)\\n gammaAndGammaPower[1] = mulmod(\\n gammaAndGammaPower[0],\\n gammaAndGammaPower[1],\\n MODULUS\\n );\\n }\\n\\n return\\n openPolynomialAtPoint(\\n gammaShiftedCommitmentSum,\\n polyEquivalenceProof,\\n r,\\n gammaShiftedEvaluationSum\\n );\\n }\\n\\n //evaluates the given polynomial \\\"poly\\\" at value \\\"r\\\" and returns the result\\n function linearPolynomialEvaluation(bytes calldata poly, uint256 r)\\n internal\\n pure\\n returns (uint256)\\n {\\n uint256 sum;\\n uint256 length = poly.length;\\n uint256 rPower = 1;\\n for (uint i = 0; i < length; ) {\\n uint256 coefficient = uint256(bytes32(poly[i:i + 32]));\\n sum = addmod(sum, mulmod(coefficient, rPower, MODULUS), MODULUS);\\n rPower = mulmod(rPower, r, MODULUS);\\n i += 32;\\n }\\n return sum;\\n }\\n}\\n\",\"keccak256\":\"0x8a6bc2fd7ee77d3dae36ac5dad0ba9f9bc126f317271e3ad13be61139a8b63f1\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/DataStoreUtils.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.8.9;\\n\\nimport \\\"./interfaces/IDataLayrServiceManager.sol\\\";\\n\\n/**\\n * @title Library of functions shared across DataLayr.\\n * @author Layr Labs, Inc.\\n */\\nlibrary DataStoreUtils {\\n uint16 public constant BIP_MULTIPLIER = 10000;\\n\\n uint256 public constant BYTES_PER_COEFFICIENT = 31;\\n uint256 public constant BIT_SHIFT_degree = 224;\\n uint256 public constant BIT_SHIFT_numSys = 224;\\n uint256 public constant HEADER_OFFSET_degree = 64;\\n uint256 public constant HEADER_OFFSET_numSys = 68;\\n\\n\\n function getTotalBytes(bytes calldata header, uint32 totalChunks) internal pure returns(uint256) {\\n uint256 numCoefficients;\\n assembly {\\n //numCoefficients = totalChunks * (degree + 1)\\n //NOTE: degree + 1 is the number of coefficients\\n numCoefficients := mul(totalChunks, add(shr(BIT_SHIFT_degree, calldataload(add(header.offset, HEADER_OFFSET_degree))), 1))\\n }\\n return numCoefficients * BYTES_PER_COEFFICIENT;\\n }\\n /// @param header of the datastore that the coding ratio is being retrieved for\\n /// @param totalChunks the total number of chunks expected in this datastore\\n /// @return codingRatio of the datastore in basis points\\n function getCodingRatio(bytes calldata header, uint32 totalChunks) internal pure returns(uint16) {\\n uint32 codingRatio;\\n assembly {\\n //codingRatio = numSys\\n codingRatio := shr(BIT_SHIFT_numSys, calldataload(add(header.offset, HEADER_OFFSET_numSys)))\\n //codingRatio = numSys * BIP_MULTIPLIER / totalChunks\\n codingRatio := div(mul(codingRatio, BIP_MULTIPLIER), totalChunks)\\n }\\n return uint16(codingRatio);\\n }\\n\\n function getDegree(bytes calldata header) internal pure returns (uint32) {\\n uint32 degree;\\n assembly {\\n degree := shr(BIT_SHIFT_degree, calldataload(add(header.offset, HEADER_OFFSET_degree)))\\n }\\n return degree;\\n }\\n\\n /// @notice Finds the `signatoryRecordHash`, used for fraudproofs.\\n function computeSignatoryRecordHash(\\n uint32 globalDataStoreId,\\n bytes32[] memory nonSignerPubkeyHashes,\\n uint256 signedStakeFirstQuorum,\\n uint256 signedStakeSecondQuorum\\n ) internal pure returns (bytes32) {\\n return keccak256(\\n abi.encodePacked(globalDataStoreId, nonSignerPubkeyHashes, signedStakeFirstQuorum, signedStakeSecondQuorum)\\n );\\n }\\n\\n /// @notice Computes the hash of a single DataStore's metadata.\\n function computeDataStoreHash(IDataLayrServiceManager.DataStoreMetadata memory metadata)\\n internal\\n pure\\n returns (bytes32)\\n {\\n bytes32 dsHash = keccak256(\\n abi.encodePacked(\\n metadata.headerHash,\\n metadata.durationDataStoreId,\\n metadata.globalDataStoreId,\\n metadata.referenceBlockNumber,\\n metadata.blockNumber,\\n metadata.fee,\\n metadata.confirmer,\\n metadata.signatoryRecordHash\\n )\\n );\\n return dsHash;\\n }\\n\\n /// @notice uses `abi.encodePacked` to encode a DataStore's metadata into a compressed format\\n function packDataStoreMetadata(IDataLayrServiceManager.DataStoreMetadata memory metadata)\\n internal\\n pure\\n returns (bytes memory)\\n {\\n return (\\n abi.encodePacked(\\n metadata.headerHash,\\n metadata.durationDataStoreId,\\n metadata.globalDataStoreId,\\n metadata.referenceBlockNumber,\\n metadata.blockNumber,\\n metadata.fee,\\n metadata.confirmer,\\n metadata.signatoryRecordHash\\n )\\n );\\n }\\n\\n /// @notice uses `abi.encodePacked` to encode a DataStore's searchData into a compressed format\\n function packDataStoreSearchData(IDataLayrServiceManager.DataStoreSearchData memory searchData)\\n internal\\n pure\\n returns (bytes memory)\\n {\\n return (\\n abi.encodePacked(\\n packDataStoreMetadata(searchData.metadata), searchData.duration, searchData.timestamp, searchData.index\\n )\\n );\\n }\\n\\n // CONSTANTS -- commented out lines are due to inline assembly supporting *only* 'direct number constants' (for now, at least)\\n // OBJECT BIT LENGTHS\\n uint256 internal constant BIT_LENGTH_headerHash = 256;\\n uint256 internal constant BIT_LENGTH_durationDataStoreId = 32;\\n uint256 internal constant BIT_LENGTH_globalDataStoreId = 32;\\n uint256 internal constant BIT_LENGTH_referenceBlockNumber = 32;\\n uint256 internal constant BIT_LENGTH_blockNumber = 32;\\n uint256 internal constant BIT_LENGTH_fee = 96;\\n uint256 internal constant BIT_LENGTH_confirmer = 160;\\n uint256 internal constant BIT_LENGTH_signatoryRecordHash = 256;\\n uint256 internal constant BIT_LENGTH_duration = 8;\\n uint256 internal constant BIT_LENGTH_timestamp = 256;\\n uint256 internal constant BIT_LENGTH_index = 32;\\n\\n // OBJECT BIT SHIFTS FOR READING FROM CALLDATA -- don't bother with using 'shr' if any of these is 0\\n // uint256 internal constant BIT_SHIFT_headerHash = 256 - BIT_LENGTH_headerHash;\\n // uint256 internal constant BIT_SHIFT_durationDataStoreId = 256 - BIT_LENGTH_durationDataStoreId;\\n // uint256 internal constant BIT_SHIFT_globalDataStoreId = 256 - BIT_LENGTH_globalDataStoreId;\\n // uint256 internal constant BIT_SHIFT_referenceBlockNumber = 256 - BIT_LENGTH_referenceBlockNumber;\\n // uint256 internal constant BIT_SHIFT_blockNumber = 256 - BIT_LENGTH_blockNumber;\\n // uint256 internal constant BIT_SHIFT_fee = 256 - BIT_LENGTH_fee;\\n // uint256 internal constant BIT_SHIFT_confirmer = 256 - BIT_LENGTH_confirmer;\\n // uint256 internal constant BIT_SHIFT_signatoryRecordHash = 256 - BIT_LENGTH_signatoryRecordHash;\\n // uint256 internal constant BIT_SHIFT_duration = 256 - BIT_LENGTH_duration;\\n // uint256 internal constant BIT_SHIFT_timestamp = 256 - BIT_LENGTH_timestamp;\\n // uint256 internal constant BIT_SHIFT_index = 256 - BIT_LENGTH_index;\\n uint256 internal constant BIT_SHIFT_headerHash = 0;\\n uint256 internal constant BIT_SHIFT_durationDataStoreId = 224;\\n uint256 internal constant BIT_SHIFT_globalDataStoreId = 224;\\n uint256 internal constant BIT_SHIFT_referenceBlockNumber = 224;\\n uint256 internal constant BIT_SHIFT_blockNumber = 224;\\n uint256 internal constant BIT_SHIFT_fee = 160;\\n uint256 internal constant BIT_SHIFT_confirmer = 96;\\n uint256 internal constant BIT_SHIFT_signatoryRecordHash = 0;\\n uint256 internal constant BIT_SHIFT_duration = 248;\\n uint256 internal constant BIT_SHIFT_timestamp = 0;\\n uint256 internal constant BIT_SHIFT_index = 224;\\n\\n // CALLDATA OFFSETS IN BYTES -- adding 7 and dividing by 8 here is for rounding *up* the bit amounts to bytes amounts\\n // uint256 internal constant CALLDATA_OFFSET_headerHash = 0;\\n // uint256 internal constant CALLDATA_OFFSET_durationDataStoreId = ((BIT_LENGTH_headerHash + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_globalDataStoreId = CALLDATA_OFFSET_durationDataStoreId + ((BIT_LENGTH_durationDataStoreId + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_referenceBlockNumber = CALLDATA_OFFSET_globalDataStoreId + ((BIT_LENGTH_globalDataStoreId + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_blockNumber = CALLDATA_OFFSET_referenceBlockNumber + ((BIT_LENGTH_referenceBlockNumber + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_fee = CALLDATA_OFFSET_blockNumber + ((BIT_LENGTH_blockNumber + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_confirmer = CALLDATA_OFFSET_fee + ((BIT_LENGTH_fee + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_signatoryRecordHash = CALLDATA_OFFSET_confirmer + ((BIT_LENGTH_confirmer + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_duration = CALLDATA_OFFSET_signatoryRecordHash + ((BIT_LENGTH_signatoryRecordHash + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_timestamp = CALLDATA_OFFSET_duration + ((BIT_LENGTH_duration + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_index = CALLDATA_OFFSET_timestamp + ((BIT_LENGTH_timestamp + 7) / 8);\\n uint256 internal constant CALLDATA_OFFSET_headerHash = 0;\\n uint256 internal constant CALLDATA_OFFSET_durationDataStoreId = 32;\\n uint256 internal constant CALLDATA_OFFSET_globalDataStoreId = 36;\\n uint256 internal constant CALLDATA_OFFSET_referenceBlockNumber = 40;\\n uint256 internal constant CALLDATA_OFFSET_blockNumber = 44;\\n uint256 internal constant CALLDATA_OFFSET_fee = 48;\\n uint256 internal constant CALLDATA_OFFSET_confirmer = 60;\\n uint256 internal constant CALLDATA_OFFSET_signatoryRecordHash = 80;\\n uint256 internal constant CALLDATA_OFFSET_duration = 112;\\n uint256 internal constant CALLDATA_OFFSET_timestamp = 113;\\n uint256 internal constant CALLDATA_OFFSET_index = 145;\\n\\n // MEMORY OFFSETS IN BYTES\\n uint256 internal constant MEMORY_OFFSET_headerHash = 0;\\n uint256 internal constant MEMORY_OFFSET_durationDataStoreId = 32;\\n uint256 internal constant MEMORY_OFFSET_globalDataStoreId = 64;\\n uint256 internal constant MEMORY_OFFSET_referenceBlockNumber = 96;\\n uint256 internal constant MEMORY_OFFSET_blockNumber = 128;\\n uint256 internal constant MEMORY_OFFSET_fee = 160;\\n uint256 internal constant MEMORY_OFFSET_confirmer = 192;\\n uint256 internal constant MEMORY_OFFSET_signatoryRecordHash = 224;\\n /**\\n * Here MEMORY_OFFSET_duration is only 32 despite metadata struct being much longer\\n * than 32 bytes. I'm unsure why the memory-offsets work this way, but they do. See usage below.\\n */\\n uint256 internal constant MEMORY_OFFSET_duration = 32;\\n uint256 internal constant MEMORY_OFFSET_timestamp = 64;\\n uint256 internal constant MEMORY_OFFSET_index = 96;\\n\\n /**\\n * @notice Unpacks the packed metadata of a DataStore into a metadata struct.\\n * @param packedMetadata should be in the same form as the output of `packDataStoreMetadata`\\n */\\n function unpackDataStoreMetadata(bytes calldata packedMetadata)\\n internal\\n pure\\n returns (IDataLayrServiceManager.DataStoreMetadata memory metadata)\\n {\\n uint256 pointer;\\n assembly {\\n // fetch offset of `packedMetadata` input in calldata\\n pointer := packedMetadata.offset\\n mstore(\\n // store in the headerHash memory location in `metadata`\\n metadata,\\n // read the headerHash from its calldata position in `packedMetadata`\\n calldataload(pointer)\\n )\\n mstore(\\n // store in the durationDataStoreId memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_durationDataStoreId),\\n // read the durationDataStoreId from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_durationDataStoreId, calldataload(add(pointer, CALLDATA_OFFSET_durationDataStoreId)))\\n )\\n mstore(\\n // store in the globalDataStoreId memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_globalDataStoreId),\\n // read the globalDataStoreId from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_globalDataStoreId, calldataload(add(pointer, CALLDATA_OFFSET_globalDataStoreId)))\\n )\\n mstore(\\n // store in the blockNumber memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_referenceBlockNumber),\\n // read the blockNumber from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_blockNumber, calldataload(add(pointer, CALLDATA_OFFSET_referenceBlockNumber)))\\n )\\n mstore(\\n // store in the blockNumber memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_blockNumber),\\n // read the blockNumber from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_blockNumber, calldataload(add(pointer, CALLDATA_OFFSET_blockNumber)))\\n )\\n mstore(\\n // store in the fee memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_fee),\\n // read the fee from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_fee, calldataload(add(pointer, CALLDATA_OFFSET_fee)))\\n )\\n mstore(\\n // store in the confirmer memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_confirmer),\\n // read the confirmer from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_confirmer, calldataload(add(pointer, CALLDATA_OFFSET_confirmer)))\\n )\\n mstore(\\n // store in the signatoryRecordHash memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_signatoryRecordHash),\\n // read the signatoryRecordHash from its calldata position in `packedMetadata`\\n calldataload(add(pointer, CALLDATA_OFFSET_signatoryRecordHash))\\n )\\n }\\n return metadata;\\n }\\n\\n /**\\n * @notice Unpacks the packed searchData of a DataStore into a searchData struct.\\n * @param packedSearchData should be in the same form as the output of `packDataStoreSearchData`\\n */\\n function unpackDataStoreSearchData(bytes calldata packedSearchData)\\n internal\\n pure\\n returns (IDataLayrServiceManager.DataStoreSearchData memory searchData)\\n {\\n searchData.metadata = (unpackDataStoreMetadata(packedSearchData));\\n uint256 pointer;\\n assembly {\\n // fetch offset of `packedSearchData` input in calldata\\n pointer := packedSearchData.offset\\n mstore(\\n // store in the duration memory location of `searchData`\\n add(searchData, MEMORY_OFFSET_duration),\\n // read the duration from its calldata position in `packedSearchData`\\n shr(BIT_SHIFT_duration, calldataload(add(pointer, CALLDATA_OFFSET_duration)))\\n )\\n mstore(\\n // store in the timestamp memory location of `searchData`\\n add(searchData, MEMORY_OFFSET_timestamp),\\n // read the timestamp from its calldata position in `packedSearchData`\\n calldataload(add(pointer, CALLDATA_OFFSET_timestamp))\\n )\\n mstore(\\n // store in the index memory location of `searchData`\\n add(searchData, MEMORY_OFFSET_index),\\n // read the index from its calldata position in `packedSearchData`\\n shr(BIT_SHIFT_index, calldataload(add(pointer, CALLDATA_OFFSET_index)))\\n )\\n }\\n return searchData;\\n }\\n}\\n\",\"keccak256\":\"0x27c01c42eea18861fa85d5402186eeb8c1c99b755d6754a1942c57ca0b440de1\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/Merkle.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENCED\\n// Adapted from OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Tree proofs.\\n *\\n * The tree and the proofs can be generated using our\\n * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].\\n * You will find a quickstart guide in the readme.\\n *\\n * WARNING: You should avoid using leaf values that are 64 bytes long prior to\\n * hashing, or use a hash function other than keccak256 for hashing leaves.\\n * This is because the concatenation of a sorted pair of internal nodes in\\n * the merkle tree could be reinterpreted as a leaf value.\\n * OpenZeppelin's JavaScript library generates merkle trees that are safe\\n * against this attack out of the box.\\n */\\nlibrary Merkle {\\n /**\\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\\n * hash matches the root of the tree. The tree is built assuming `leaf` is \\n * the 0 indexed `index`'th leaf from the bottom left of the tree.\\n * \\n * Note this is for a Merkle tree using the keccak/sha3 hash function\\n */\\n function verifyInclusionKeccak(\\n bytes memory proof,\\n bytes32 root,\\n bytes32 leaf,\\n uint256 index\\n ) internal pure returns (bool) {\\n return processInclusionProofKeccak(proof, leaf, index) == root;\\n }\\n\\n /**\\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\\n * hash matches the root of the tree. The tree is built assuming `leaf` is \\n * the 0 indexed `index`'th leaf from the bottom left of the tree.\\n * \\n * _Available since v4.4._\\n * \\n * Note this is for a Merkle tree using the keccak/sha3 hash function\\n */\\n function processInclusionProofKeccak(bytes memory proof, bytes32 leaf, uint256 index) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf;\\n for (uint256 i = 32; i <= proof.length; i+=32) {\\n if(index % 2 == 0) {\\n // if ith bit of index is 0, then computedHash is a left sibling\\n assembly {\\n mstore(0x00, computedHash)\\n mstore(0x20, mload(add(proof, i)))\\n computedHash := keccak256(0x00, 0x40)\\n index := div(index, 2)\\n }\\n } else {\\n // if ith bit of index is 1, then computedHash is a right sibling\\n assembly {\\n mstore(0x00, mload(add(proof, i)))\\n mstore(0x20, computedHash)\\n computedHash := keccak256(0x00, 0x40)\\n index := div(index, 2)\\n } \\n }\\n }\\n return computedHash;\\n }\\n\\n /**\\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\\n * hash matches the root of the tree. The tree is built assuming `leaf` is \\n * the 0 indexed `index`'th leaf from the bottom left of the tree.\\n * \\n * Note this is for a Merkle tree using the sha256 hash function\\n */\\n function verifyInclusionSha256(\\n bytes memory proof,\\n bytes32 root,\\n bytes32 leaf,\\n uint256 index\\n ) internal view returns (bool) {\\n return processInclusionProofSha256(proof, leaf, index) == root;\\n }\\n\\n /**\\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\\n * hash matches the root of the tree. The tree is built assuming `leaf` is \\n * the 0 indexed `index`'th leaf from the bottom left of the tree.\\n *\\n * _Available since v4.4._\\n * \\n * Note this is for a Merkle tree using the keccak/sha3 hash function\\n */\\n function processInclusionProofSha256(bytes memory proof, bytes32 leaf, uint256 index) internal view returns (bytes32) {\\n bytes32[1] memory computedHash = [leaf];\\n for (uint256 i = 32; i <= proof.length; i+=32) {\\n if(index % 2 == 0) {\\n // if ith bit of index is 0, then computedHash is a left sibling\\n assembly {\\n mstore(0x00, mload(computedHash))\\n mstore(0x20, mload(add(proof, i)))\\n if iszero(staticcall(sub(gas(), 2000), 2, 0x00, 0x40, computedHash, 0x20)) {revert(0, 0)}\\n index := div(index, 2)\\n }\\n } else {\\n // if ith bit of index is 1, then computedHash is a right sibling\\n assembly {\\n mstore(0x00, mload(add(proof, i)))\\n mstore(0x20, mload(computedHash))\\n if iszero(staticcall(sub(gas(), 2000), 2, 0x00, 0x40, computedHash, 0x20)) {revert(0, 0)}\\n index := div(index, 2)\\n } \\n }\\n }\\n return computedHash[0];\\n }\\n\\n /**\\n @notice this function returns the merkle root of a tree created from a set of leaves using sha256 as its hash function\\n @param leaves the leaves of the merkle tree\\n\\n @notice requires the leaves.length is a power of 2\\n */ \\n function merkleizeSha256(\\n bytes32[] memory leaves\\n ) internal pure returns (bytes32) {\\n //there are half as many nodes in the layer above the leaves\\n uint256 numNodesInLayer = leaves.length / 2;\\n //create a layer to store the internal nodes\\n bytes32[] memory layer = new bytes32[](numNodesInLayer);\\n //fill the layer with the pairwise hashes of the leaves\\n for (uint i = 0; i < numNodesInLayer; i++) {\\n layer[i] = sha256(abi.encodePacked(leaves[2*i], leaves[2*i+1]));\\n }\\n //the next layer above has half as many nodes\\n numNodesInLayer /= 2;\\n //while we haven't computed the root\\n while (numNodesInLayer != 0) {\\n //overwrite the first numNodesInLayer nodes in layer with the pairwise hashes of their children\\n for (uint i = 0; i < numNodesInLayer; i++) {\\n layer[i] = sha256(abi.encodePacked(layer[2*i], layer[2*i+1]));\\n }\\n //the next layer above has half as many nodes\\n numNodesInLayer /= 2;\\n }\\n //the first node in the layer is the root\\n return layer[0];\\n }\\n}\",\"keccak256\":\"0x12f01f5daf5a4c185b927ef195dadc2ed51ab5e22a713283cd6b261026ab5930\",\"license\":\"UNLICENCED\"},\"contracts/libraries/eigenda/Parse.sol\":{\"content\":\"pragma solidity ^0.8.9;\\n\\ncontract Parser {\\n /**\\n * @notice Parses data from non-interactive polynomial proofs.\\n * @param polys The non-interactive polynomial proofs themselves\\n * @param startIndex The byte index from which to begin reading data.\\n * @param length The length of data to parse, in bytes.\\n * @return provenString The parsed data.\\n */\\n function parse(bytes[] calldata polys, uint256 startIndex, uint256 length) public pure returns(bytes memory provenString) {\\n // each symbol encodes 31 bytes, and is padded to 32 bytes -- this verifies that we are beginning to parse the data from a non-padded byte\\n require(startIndex % 32 != 0, \\\"Cannot start reading from a padded byte\\\");\\n // index of the `polys` array from which we are currently reading\\n uint256 polyIndex = 0;\\n // keeps track of the index to read inside of the current polynomial\\n uint256 index = startIndex;\\n // continue reading until we reach the desired length\\n while(provenString.length < length) {\\n /**\\n * Read:\\n * 1) until the beginning of the next 32 byte segment OR\\n * 2) however many more bytes there are left in the fraud string\\n * -- whichever amount is the *smallest*\\n */\\n uint256 bytesToRead = min(\\n // the amount of bytes until the end of the current 32 byte segment\\n (32 * ((index / 32) + 1)) - index,\\n // the remaining total bytes to parse\\n length - provenString.length\\n );\\n /**\\n * Append the read bytes to the end of the proven string.\\n * Note that indexing of bytes is inclusive of the first index and exclusive of the second, meaning\\n * that, for example, polys[0][x:x+1] specifies the *single byte* at position x of `polys[0]`, and\\n * polys[0][x:x] will specify an empty byte string.\\n */\\n provenString = abi.encodePacked(provenString, polys[polyIndex][index:index+bytesToRead]);\\n // if we finished reading the current polynomial, then we move onto the next one\\n if (index + bytesToRead == polys[polyIndex].length) {\\n polyIndex++;\\n // skip the first byte of the polynomial since this is zero padding\\n index = 1;\\n // we have read `index + bytesToRead` bytes, and add 1 more to skip the zero-padding byte at the beginning of every 32 bytes\\n } else {\\n index += bytesToRead + 1;\\n }\\n }\\n return provenString;\\n }\\n\\n /// @notice Calculates the minimum of 2 numbers\\n function min(uint256 a, uint256 b) internal pure returns(uint256) {\\n return (a < b) ? a : b;\\n }\\n}\\n\",\"keccak256\":\"0x2eb0953b80b4af4b958ebe45cf58780016cfbce219b09464180490e3edbe71a5\"},\"contracts/libraries/eigenda/interfaces/IDataLayrPaymentManager.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"./IPaymentManager.sol\\\";\\nimport \\\"./IDataLayrServiceManager.sol\\\";\\n\\n/**\\n * @title Minimal interface extension to `IPaymentManager`.\\n * @author Layr Labs, Inc.\\n * @notice Adds a single DataLayr-specific function to the base interface.\\n */\\ninterface IDataLayrPaymentManager is IPaymentManager {\\n /**\\n * @notice Used to perform the final step in a payment challenge, in which the 'trueAmount' is determined and the winner of the challenge is decided.\\n * This function is called by a party after the other party has bisected the challenged payments to a difference of one, i.e., further bisection\\n * is not possible. Once the payments can no longer be bisected, the function resolves the challenge by determining who is wrong.\\n * @param stakeHistoryIndex is used as an input to `registry.checkOperatorInactiveAtBlockNumber` -- see that function's documentation\\n */\\n function respondToPaymentChallengeFinal(\\n address operator,\\n uint256 stakeIndex,\\n uint48 nonSignerIndex,\\n bytes32[] memory nonSignerPubkeyHashes,\\n TotalStakes calldata totalStakesSigned,\\n IDataLayrServiceManager.DataStoreSearchData calldata searchData,\\n uint256 stakeHistoryIndex\\n ) external;\\n}\\n\",\"keccak256\":\"0x477d65f2760f8c0d411c92adebe146380f6c4831676a2c4f56740317609d4e88\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IDataLayrServiceManager.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"./IServiceManager.sol\\\";\\nimport \\\"./IDelayedService.sol\\\";\\nimport \\\"./IEigenLayrDelegation.sol\\\";\\nimport \\\"./IDataLayrPaymentManager.sol\\\";\\n\\ninterface IDataLayrServiceManager is IServiceManager, IDelayedService {\\n //Relevant metadata for a given datastore\\n struct DataStoreMetadata {\\n bytes32 headerHash; // the hash of the header as defined in the contract\\n uint32 durationDataStoreId; // the id of the datastore relative to all other datastores of the same duration\\n uint32 globalDataStoreId; // the id of the datastore relative to all other datastores\\n uint32 referenceBlockNumber; // the block number from which the stakes were taken for the datastore\\n uint32 blockNumber; // the block number at the time of initialization\\n uint96 fee; // the amount of paymentToken paid for the datastore\\n address confirmer; // the address that is allowed to confirm the datastore\\n bytes32 signatoryRecordHash; // the hash of relavent signatory information for payments and fraud proofs\\n }\\n\\n //Stores the data required to index a given datastore's metadata\\n struct DataStoreSearchData {\\n DataStoreMetadata metadata;\\n uint8 duration;\\n uint256 timestamp;\\n uint32 index;\\n }\\n\\n struct SignatoryRecordMinusDataStoreId {\\n bytes32[] nonSignerPubkeyHashes;\\n uint256 signedStakeFirstQuorum;\\n uint256 signedStakeSecondQuorum;\\n }\\n\\n struct DataStoresForDuration {\\n uint32 one_duration;\\n uint32 two_duration;\\n uint32 three_duration;\\n uint32 four_duration;\\n uint32 five_duration;\\n uint32 six_duration;\\n uint32 seven_duration;\\n uint32 dataStoreId;\\n uint32 latestTime;\\n }\\n\\n struct DataStoreHashInputs {\\n bytes32 headerHash;\\n uint32 dataStoreId;\\n uint32 blockNumber;\\n uint256 fee;\\n }\\n\\n /**\\n * @notice This function is used for\\n * - notifying via Ethereum that the disperser has asserted the data blob\\n * into DataLayr and is waiting to obtain quorum of DataLayr operators to sign,\\n * - asserting the metadata corresponding to the data asserted into DataLayr\\n * - escrow the service fees that DataLayr operators will receive from the disperser\\n * on account of their service.\\n *\\n * This function returns the index of the data blob in dataStoreIdsForDuration[duration][block.timestamp]\\n */\\n /**\\n * @param feePayer is the address that will be paying the fees for this datastore. check DataLayrPaymentManager for further details\\n * @param confirmer is the address that must confirm the datastore\\n * @param header is the summary of the data that is being asserted into DataLayr,\\n * type DataStoreHeader struct {\\n * KzgCommit [64]byte\\n * Degree uint32\\n * NumSys uint32\\n * NumPar uint32\\n * OrigDataSize uint32\\n * Disperser [20]byte\\n * LowDegreeProof [64]byte\\n * }\\n * @param duration for which the data has to be stored by the DataLayr operators.\\n * This is a quantized parameter that describes how many factors of DURATION_SCALE\\n * does this data blob needs to be stored. The quantization process comes from ease of\\n * implementation in DataLayrBombVerifier.sol.\\n * @param blockNumber is the block number in Ethereum for which the confirmation will\\n * consult total + operator stake amounts.\\n * -- must not be more than 'BLOCK_STALE_MEASURE' (defined in DataLayr) blocks in past\\n * @return index The index in the array `dataStoreHashesForDurationAtTimestamp[duration][block.timestamp]` at which the DataStore's hash was stored.\\n */\\n function initDataStore(\\n address feePayer,\\n address confirmer,\\n uint8 duration,\\n uint32 blockNumber,\\n uint32 totalOperatorsIndex,\\n bytes calldata header\\n )\\n external\\n returns (uint32);\\n\\n /**\\n * @notice This function is used for\\n * - disperser to notify that signatures on the message, comprising of hash( headerHash ),\\n * from quorum of DataLayr nodes have been obtained,\\n * - check that the aggregate signature is valid,\\n * - and check whether quorum has been achieved or not.\\n */\\n /**\\n * @param data Input to the `checkSignatures` function, which is of the format:\\n * <\\n * bytes32 msgHash,\\n * uint48 index of the totalStake corresponding to the dataStoreId in the 'totalStakeHistory' array of the BLSRegistry\\n * uint32 numberOfNonSigners,\\n * uint256[numberOfSigners][4] pubkeys of nonsigners,\\n * uint32 apkIndex,\\n * uint256[4] apk,\\n * uint256[2] sigma\\n * >\\n */\\n function confirmDataStore(bytes calldata data, DataStoreSearchData memory searchData) external;\\n\\n /// @notice number of leaves in the root tree\\n function numPowersOfTau() external view returns (uint48);\\n\\n /// @notice number of layers in the root tree\\n function log2NumPowersOfTau() external view returns (uint48);\\n\\n /// @notice Unit of measure (in time) for the duration of DataStores\\n function DURATION_SCALE() external view returns (uint256);\\n\\n /// @notice The longest allowed duation of a DataStore, measured in `DURATION_SCALE`\\n function MAX_DATASTORE_DURATION() external view returns (uint8);\\n\\n /// @notice Returns the hash of the `index`th DataStore with the specified `duration` at the specified UTC `timestamp`.\\n function getDataStoreHashesForDurationAtTimestamp(uint8 duration, uint256 timestamp, uint32 index)\\n external\\n view\\n returns (bytes32);\\n\\n /**\\n * @notice returns the number of data stores for the @param duration\\n */\\n function getNumDataStoresForDuration(uint8 duration) external view returns (uint32);\\n\\n /// @notice Collateral token used for placing collateral on challenges & payment commits\\n function collateralToken() external view returns (IERC20);\\n\\n /**\\n * @notice contract used for handling payment challenges\\n */\\n function dataLayrPaymentManager() external view returns (IDataLayrPaymentManager);\\n\\n /**\\n * @notice Checks that the hash of the `index`th DataStore with the specified `duration` at the specified UTC `timestamp` matches the supplied `metadata`.\\n * Returns 'true' if the metadata matches the hash, and 'false' otherwise.\\n */\\n function verifyDataStoreMetadata(uint8 duration, uint256 timestamp, uint32 index, DataStoreMetadata memory metadata) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xf026ccb92b258ca5b6b778b22e96d328d043d3b8aa6709766f687258b392563b\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IDelayedService.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Interface for a middleware / service that may look at past stake amounts.\\n * @author Layr Labs, Inc.\\n * @notice Specifically, this interface is designed for services that consult stake amounts up to `BLOCK_STALE_MEASURE`\\n * blocks in the past. This may be necessary due to, e.g., network processing & communication delays, or to avoid race conditions\\n * that could be present with coordinating aggregate operator signatures while service operators are registering & de-registering.\\n * @dev To clarify edge cases, the middleware can look `BLOCK_STALE_MEASURE` blocks into the past, i.e. it may trust stakes from the interval\\n * [block.number - BLOCK_STALE_MEASURE, block.number] (specifically, *inclusive* of the block that is `BLOCK_STALE_MEASURE` before the current one)\\n */\\ninterface IDelayedService {\\n /// @notice The maximum amount of blocks in the past that the service will consider stake amounts to still be 'valid'.\\n function BLOCK_STALE_MEASURE() external view returns(uint32); \\n}\\n\",\"keccak256\":\"0x4c9c1d5de05ad392b45244c373d137c7f49436618492ba165b2e3a241dee25cc\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IDelegationTerms.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"./IInvestmentStrategy.sol\\\";\\n\\n/**\\n * @title Abstract interface for a contract that helps structure the delegation relationship.\\n * @author Layr Labs, Inc.\\n * @notice The gas budget provided to this contract in calls from EigenLayr contracts is limited.\\n */\\n//TODO: discuss if we can structure the inputs of these functions better\\ninterface IDelegationTerms {\\n function payForService(IERC20 token, uint256 amount) external payable;\\n\\n function onDelegationWithdrawn(\\n address delegator,\\n IInvestmentStrategy[] memory investorStrats,\\n uint256[] memory investorShares\\n ) external;\\n\\n // function onDelegationReceived(\\n // address delegator,\\n // uint256[] memory investorShares\\n // ) external;\\n\\n function onDelegationReceived(\\n address delegator,\\n IInvestmentStrategy[] memory investorStrats,\\n uint256[] memory investorShares\\n ) external;\\n}\\n\",\"keccak256\":\"0x5e7db2c8e3cb2cf7d7a19f8f7be16efacfd1b709dfcd2f5bd2b32174812acc37\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IEigenLayrDelegation.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"./IDelegationTerms.sol\\\";\\n\\n/**\\n * @title The interface for the primary delegation contract for EigenLayr.\\n * @author Layr Labs, Inc.\\n * @notice This is the contract for delegation in EigenLayr. The main functionalities of this contract are\\n * - enabling anyone to register as an operator in EigenLayr\\n * - allowing new operators to provide a DelegationTerms-type contract, which may mediate their interactions with stakers who delegate to them\\n * - enabling any staker to delegate its stake to the operator of its choice\\n * - enabling a staker to undelegate its assets from an operator (performed as part of the withdrawal process, initiated through the InvestmentManager)\\n */\\ninterface IEigenLayrDelegation {\\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(IDelegationTerms 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 delegateToBySignature(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 in EigenLayer.\\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 DelegationTerms of the `operator`, which may mediate their interactions with stakers who delegate to them.\\n function delegationTerms(address operator) external view returns (IDelegationTerms);\\n\\n /// @notice returns the total number of shares in `strategy` that are delegated to `operator`.\\n function operatorShares(address operator, IInvestmentStrategy strategy) external view returns (uint256);\\n\\n /**\\n * @notice Increases the `staker`'s delegated shares in `strategy` by `shares, typically called when the staker has further deposits into EigenLayr\\n * @dev Callable only by the InvestmentManager\\n */\\n function increaseDelegatedShares(address staker, IInvestmentStrategy strategy, uint256 shares) external;\\n\\n /**\\n * @notice Decreases the `staker`'s delegated shares in each entry of `strategies` by its respective `shares[i]`, typically called when the staker withdraws from EigenLayr\\n * @dev Callable only by the InvestmentManager\\n */\\n function decreaseDelegatedShares(\\n address staker,\\n IInvestmentStrategy[] calldata strategies,\\n uint256[] calldata shares\\n ) external;\\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\",\"keccak256\":\"0x963866de65476336650f81dca389e9fc21aa7cb801776fb47376bcebac79e0c7\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IInvestmentStrategy.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/**\\n * @title Minimal interface for an `InvestmentStrategy` contract.\\n * @author Layr Labs, Inc.\\n * @notice Custom `InvestmentStrategy` implementations may expand extensively on this interface.\\n */\\ninterface IInvestmentStrategy {\\n /**\\n * @notice Used to deposit tokens into this InvestmentStrategy\\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 investmentManager contract. It is invoked inside of the investmentManager's\\n * `depositIntoStrategy` function, and individual share balances are recorded in the investmentManager as well.\\n * @return newShares is the number of new shares issued at the current exchange ratio.\\n */\\n function deposit(IERC20 token, uint256 amount) external returns (uint256);\\n\\n /**\\n * @notice Used to withdraw tokens from this InvestmentStrategy, 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 investmentManager contract. It is invoked inside of the investmentManager's\\n * other functions, and individual share balances are recorded in the investmentManager 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 strategy.\\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 strategy shares\\n * @dev Implementation for these functions in particular may vary signifcantly for different strategies\\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 strategy. 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 strategy.\\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 strategies\\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 strategy.\\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 strategy shares\\n * @dev Implementation for these functions in particular may vary signifcantly for different strategies\\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 strategy. 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 InvestmentStrategy\\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\":\"0x69eb667cc856ee1fe783243b6db21a43a9dadd29bf6761727b334fca4366bceb\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IPaymentManager.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/**\\n * @title Interface for a `PaymentManager` contract.\\n * @author Layr Labs, Inc.\\n */\\ninterface IPaymentManager {\\n enum DissectionType {\\n INVALID,\\n FIRST_HALF,\\n SECOND_HALF\\n }\\n enum PaymentStatus {\\n REDEEMED,\\n COMMITTED,\\n CHALLENGED\\n }\\n enum ChallengeStatus {\\n RESOLVED,\\n OPERATOR_TURN,\\n CHALLENGER_TURN,\\n OPERATOR_TURN_ONE_STEP,\\n CHALLENGER_TURN_ONE_STEP\\n }\\n\\n /**\\n * @notice used for storing information on the most recent payment made to the operator\\n */\\n struct Payment {\\n // taskNumber starting from which payment is being claimed\\n uint32 fromTaskNumber;\\n // taskNumber until which payment is being claimed (exclusive)\\n uint32 toTaskNumber;\\n // recording when the payment will optimistically be confirmed; used for fraudproof period\\n uint32 confirmAt;\\n // payment for range [fromTaskNumber, toTaskNumber)\\n /// @dev max 1.3e36, keep in mind for token decimals\\n uint96 amount;\\n /**\\n * @notice The possible statuses are:\\n * - 0: REDEEMED,\\n * - 1: COMMITTED,\\n * - 2: CHALLENGED\\n */\\n PaymentStatus status;\\n uint256 collateral; //account for if collateral changed\\n }\\n\\n /**\\n * @notice used for storing information on the payment challenge as part of the interactive process\\n */\\n struct PaymentChallenge {\\n // operator whose payment claim is being challenged,\\n address operator;\\n // the entity challenging with the fraudproof\\n address challenger;\\n // address of the service manager contract\\n address serviceManager;\\n // the TaskNumber from which payment has been computed\\n uint32 fromTaskNumber;\\n // the TaskNumber until which payment has been computed to\\n uint32 toTaskNumber;\\n // reward amount the challenger claims is for the first half of tasks\\n uint96 amount1;\\n // reward amount the challenger claims is for the second half of tasks\\n uint96 amount2;\\n // used for recording the time when challenge was created\\n uint32 settleAt; // when committed, used for fraudproof period\\n // indicates the status of the challenge\\n /**\\n * @notice The possible statuses are:\\n * - 0: RESOLVED,\\n * - 1: operator turn (dissection),\\n * - 2: challenger turn (dissection),\\n * - 3: operator turn (one step),\\n * - 4: challenger turn (one step)\\n */\\n ChallengeStatus status;\\n }\\n\\n struct TotalStakes {\\n uint256 signedStakeFirstQuorum;\\n uint256 signedStakeSecondQuorum;\\n }\\n\\n /**\\n * @notice deposit one-time fees by the `msg.sender` with this contract to pay for future tasks of this middleware\\n * @param onBehalfOf could be the `msg.sender` themselves, or a different address for whom `msg.sender` is depositing these future fees\\n * @param amount is amount of futures fees being deposited\\n */\\n function depositFutureFees(address onBehalfOf, uint256 amount) external;\\n\\n /// @notice Allows the `allowed` address to spend up to `amount` of the `msg.sender`'s funds that have been deposited in this contract\\n function setAllowance(address allowed, uint256 amount) external;\\n\\n /// @notice Used for deducting the fees from the payer to the middleware\\n function payFee(address initiator, address payer, uint256 feeAmount) external;\\n\\n /**\\n * @notice Modifies the `paymentFraudproofCollateral` amount.\\n * @param _paymentFraudproofCollateral The new value for `paymentFraudproofCollateral` to take.\\n */\\n function setPaymentFraudproofCollateral(uint256 _paymentFraudproofCollateral) external;\\n\\n /**\\n * @notice This is used by an operator to make a claim on the amount that they deserve for their service from their last payment until `toTaskNumber`\\n * @dev Once this payment is recorded, a fraud proof period commences during which a challenger can dispute the proposed payment.\\n */\\n function commitPayment(uint32 toTaskNumber, uint96 amount) external;\\n\\n /**\\n * @notice Called by an operator to redeem a payment that they previously 'committed' to by calling `commitPayment`.\\n * @dev This function can only be called after the challenge window for the payment claim has completed.\\n */\\n function redeemPayment() external;\\n\\n /**\\n * @notice This function is called by a fraud prover to challenge a payment, initiating an interactive-type fraudproof.\\n * @param operator is the operator against whose payment claim the fraudproof is being made\\n * @param amount1 is the reward amount the challenger in that round claims is for the first half of tasks\\n * @param amount2 is the reward amount the challenger in that round claims is for the second half of tasks\\n *\\n */\\n function initPaymentChallenge(address operator, uint96 amount1, uint96 amount2) external;\\n\\n /**\\n * @notice Perform a single bisection step in an existing interactive payment challenge.\\n * @param operator The middleware operator who was challenged (used to look up challenge details)\\n * @param secondHalf If true, then the caller wishes to challenge the amount claimed as payment in the *second half* of the\\n * previous bisection step. If false then the *first half* is indicated instead.\\n * @param amount1 The amount that the caller asserts the operator is entitled to, for the first half *of the challenged half* of the previous bisection.\\n * @param amount2 The amount that the caller asserts the operator is entitled to, for the second half *of the challenged half* of the previous bisection.\\n */\\n function performChallengeBisectionStep(address operator, bool secondHalf, uint96 amount1, uint96 amount2)\\n external;\\n\\n /// @notice resolve an existing PaymentChallenge for an operator\\n function resolveChallenge(address operator) external;\\n\\n /**\\n * @notice Challenge window for submitting fraudproof in the case of an incorrect payment claim by a registered operator.\\n */\\n function paymentFraudproofInterval() external view returns (uint256);\\n\\n /**\\n * @notice Specifies the payment that has to be made as a collateral for fraudproof during payment challenges.\\n */\\n function paymentFraudproofCollateral() external view returns (uint256);\\n\\n /// @notice the ERC20 token that will be used by the disperser to pay the service fees to middleware nodes.\\n function paymentToken() external view returns (IERC20);\\n\\n /// @notice Collateral token used for placing collateral on challenges & payment commits\\n function collateralToken() external view returns (IERC20);\\n\\n /// @notice Returns the ChallengeStatus for the `operator`'s payment claim.\\n function getChallengeStatus(address operator) external view returns (ChallengeStatus);\\n\\n /// @notice Returns the 'amount1' for the `operator`'s payment claim.\\n function getAmount1(address operator) external view returns (uint96);\\n\\n /// @notice Returns the 'amount2' for the `operator`'s payment claim.\\n function getAmount2(address operator) external view returns (uint96);\\n\\n /// @notice Returns the 'toTaskNumber' for the `operator`'s payment claim.\\n function getToTaskNumber(address operator) external view returns (uint48);\\n\\n /// @notice Returns the 'fromTaskNumber' for the `operator`'s payment claim.\\n function getFromTaskNumber(address operator) external view returns (uint48);\\n\\n /// @notice Returns the task number difference for the `operator`'s payment claim.\\n function getDiff(address operator) external view returns (uint48);\\n\\n /// @notice Returns the active collateral of the `operator` placed on their payment claim.\\n function getPaymentCollateral(address) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xa8bd72043644c95c85bc7588cac18d6421cfd3c8b1dcb0df37d7adcdec209c99\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IServiceManager.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"./IEigenLayrDelegation.sol\\\";\\n\\n/**\\n * @title Interface for a `ServiceManager`-type contract.\\n * @author Layr Labs, Inc.\\n */\\n// TODO: provide more functions for this spec\\ninterface IServiceManager {\\n /// @notice Returns the current 'taskNumber' for the middleware\\n function taskNumber() external view returns (uint32);\\n\\n /// @notice Permissioned function that causes the ServiceManager to freeze the operator on EigenLayer, through a call to the Slasher contract\\n function freezeOperator(address operator) external;\\n\\n /// @notice Permissioned function to have the ServiceManager forward a call to the slasher, recording an initial stake update (on operator registration)\\n function recordFirstStakeUpdate(address operator, uint32 serveUntil) external;\\n\\n /// @notice Permissioned function to have the ServiceManager forward a call to the slasher, recording a stake update\\n function recordStakeUpdate(address operator, uint32 updateBlock, uint32 serveUntil, uint256 prevElement) external;\\n\\n /// @notice Permissioned function to have the ServiceManager forward a call to the slasher, recording a final stake update (on operator deregistration)\\n function recordLastStakeUpdateAndRevokeSlashingAbility(address operator, uint32 serveUntil) external;\\n\\n /// @notice Collateral token used for placing collateral on challenges & payment commits\\n function collateralToken() external view returns (IERC20);\\n\\n /// @notice The Delegation contract of EigenLayer.\\n function eigenLayrDelegation() external view returns (IEigenLayrDelegation);\\n\\n /// @notice Returns the `latestTime` until which operators must serve.\\n function latestTime() external view returns (uint32);\\n\\n function owner() external view returns (address);\\n}\",\"keccak256\":\"0x483b41fa37b67c958253e48c12372fac3ac09b63d47d5337392677fcb83ecf1f\",\"license\":\"UNLICENSED\"}},\"version\":1}", - "bytecode": "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", - "deployedBytecode": "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", + "solcInputHash": "2da34c9c3644bcbabfcf462a8ee6f86a", + "metadata": "{\"compiler\":{\"version\":\"0.8.9+commit.e5eed63a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldDataLayrManagerAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newDataLayrManagerAddress\",\"type\":\"address\"}],\"name\":\"DataLayrManagerAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldFraudProofPeriod\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newFraudProofPeriod\",\"type\":\"uint256\"}],\"name\":\"FraudProofPeriodUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldL2ConfirmedBlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newL2ConfirmedBlockNumber\",\"type\":\"uint256\"}],\"name\":\"L2ConfirmedBlockNumberUpdated\",\"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\":\"uint256\",\"name\":\"reRollupIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"rollupBatchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stratL2BlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"endL2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"ReRollupBatchData\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldReSubmitterAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newReSubmitterAddress\",\"type\":\"address\"}],\"name\":\"ReSubmitterAddressUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"oldRollupBatchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"newRollupBatchIndex\",\"type\":\"uint256\"}],\"name\":\"RollupBatchIndexUpdated\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"rollupBatchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stratL2BlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"endL2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"RollupStoreConfirmed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stratL2BlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"endL2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"RollupStoreInitialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"rollupBatchIndex\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"stratL2BlockNumber\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"endL2BlockNumber\",\"type\":\"uint256\"}],\"name\":\"RollupStoreReverted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"oldSequencerAddress\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newSequencerAddress\",\"type\":\"address\"}],\"name\":\"SequencerAddressUpdated\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"BLOCK_STALE_MEASURE\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"FRAUD_STRING\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"\",\"type\":\"bytes\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"},{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"headerHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"durationDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"globalDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"referenceBlockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"blockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint96\",\"name\":\"fee\",\"type\":\"uint96\"},{\"internalType\":\"address\",\"name\":\"confirmer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"signatoryRecordHash\",\"type\":\"bytes32\"}],\"internalType\":\"struct IDataLayrServiceManager.DataStoreMetadata\",\"name\":\"metadata\",\"type\":\"tuple\"},{\"internalType\":\"uint8\",\"name\":\"duration\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"internalType\":\"struct IDataLayrServiceManager.DataStoreSearchData\",\"name\":\"searchData\",\"type\":\"tuple\"},{\"internalType\":\"uint256\",\"name\":\"startL2Block\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endL2Block\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"originDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint256\",\"name\":\"reConfirmedBatchIndex\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isReRollup\",\"type\":\"bool\"}],\"name\":\"confirmData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"dataManageAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"name\":\"dataStoreIdToL2RollUpBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"startL2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endBL2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isReRollup\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"\",\"type\":\"uint32\"}],\"name\":\"dataStoreIdToRollupStoreNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"fraudProofPeriod\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getL2ConfirmedBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint32\",\"name\":\"_dataStoreId\",\"type\":\"uint32\"}],\"name\":\"getL2RollUpBlockByDataStoreId\",\"outputs\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"startL2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endBL2BlockNumber\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isReRollup\",\"type\":\"bool\"}],\"internalType\":\"struct BVM_EigenDataLayrChain.BatchRollupBlock\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"getL2StoredBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_rollupBatchIndex\",\"type\":\"uint256\"}],\"name\":\"getRollupStoreByRollupBatchIndex\",\"outputs\":[{\"components\":[{\"internalType\":\"uint32\",\"name\":\"originDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"confirmAt\",\"type\":\"uint32\"},{\"internalType\":\"enum BVM_EigenDataLayrChain.RollupStoreStatus\",\"name\":\"status\",\"type\":\"uint8\"}],\"internalType\":\"struct BVM_EigenDataLayrChain.RollupStore\",\"name\":\"\",\"type\":\"tuple\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_sequencer\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_dataManageAddress\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"_reSubmitterAddress\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_block_stale_measure\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_fraudProofPeriod\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"_l2SubmittedBlockNumber\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2ConfirmedBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"l2StoredBlockNumber\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes[]\",\"name\":\"polys\",\"type\":\"bytes[]\"},{\"internalType\":\"uint256\",\"name\":\"startIndex\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"length\",\"type\":\"uint256\"}],\"name\":\"parse\",\"outputs\":[{\"internalType\":\"bytes\",\"name\":\"provenString\",\"type\":\"bytes\"}],\"stateMutability\":\"pure\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"fraudulentStoreNumber\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"startIndex\",\"type\":\"uint256\"},{\"components\":[{\"components\":[{\"internalType\":\"bytes32\",\"name\":\"headerHash\",\"type\":\"bytes32\"},{\"internalType\":\"uint32\",\"name\":\"durationDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"globalDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"referenceBlockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"blockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint96\",\"name\":\"fee\",\"type\":\"uint96\"},{\"internalType\":\"address\",\"name\":\"confirmer\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"signatoryRecordHash\",\"type\":\"bytes32\"}],\"internalType\":\"struct IDataLayrServiceManager.DataStoreMetadata\",\"name\":\"metadata\",\"type\":\"tuple\"},{\"internalType\":\"uint8\",\"name\":\"duration\",\"type\":\"uint8\"},{\"internalType\":\"uint256\",\"name\":\"timestamp\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"index\",\"type\":\"uint32\"}],\"internalType\":\"struct IDataLayrServiceManager.DataStoreSearchData\",\"name\":\"searchData\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"bytes\",\"name\":\"header\",\"type\":\"bytes\"},{\"internalType\":\"uint32\",\"name\":\"firstChunkNumber\",\"type\":\"uint32\"},{\"internalType\":\"bytes[]\",\"name\":\"polys\",\"type\":\"bytes[]\"},{\"components\":[{\"components\":[{\"internalType\":\"uint256\",\"name\":\"X\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"Y\",\"type\":\"uint256\"}],\"internalType\":\"struct BN254.G1Point\",\"name\":\"interpolationPoly\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256\",\"name\":\"X\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"Y\",\"type\":\"uint256\"}],\"internalType\":\"struct BN254.G1Point\",\"name\":\"revealProof\",\"type\":\"tuple\"},{\"components\":[{\"internalType\":\"uint256[2]\",\"name\":\"X\",\"type\":\"uint256[2]\"},{\"internalType\":\"uint256[2]\",\"name\":\"Y\",\"type\":\"uint256[2]\"}],\"internalType\":\"struct BN254.G2Point\",\"name\":\"zeroPoly\",\"type\":\"tuple\"},{\"internalType\":\"bytes\",\"name\":\"zeroPolyProof\",\"type\":\"bytes\"}],\"internalType\":\"struct DataLayrDisclosureLogic.MultiRevealProof[]\",\"name\":\"multiRevealProofs\",\"type\":\"tuple[]\"},{\"components\":[{\"internalType\":\"uint256[2]\",\"name\":\"X\",\"type\":\"uint256[2]\"},{\"internalType\":\"uint256[2]\",\"name\":\"Y\",\"type\":\"uint256[2]\"}],\"internalType\":\"struct BN254.G2Point\",\"name\":\"polyEquivalenceProof\",\"type\":\"tuple\"}],\"internalType\":\"struct BVM_EigenDataLayrChain.DisclosureProofs\",\"name\":\"disclosureProofs\",\"type\":\"tuple\"}],\"name\":\"proveFraud\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"reRollupBatchIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"reRollupIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"reSubmitterAddress\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"removeFraudProofAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_rollupBatchIndex\",\"type\":\"uint256\"}],\"name\":\"resetRollupBatchData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"rollupBatchIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"rollupBatchIndexRollupStores\",\"outputs\":[{\"internalType\":\"uint32\",\"name\":\"originDataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"dataStoreId\",\"type\":\"uint32\"},{\"internalType\":\"uint32\",\"name\":\"confirmAt\",\"type\":\"uint32\"},{\"internalType\":\"enum BVM_EigenDataLayrChain.RollupStoreStatus\",\"name\":\"status\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"sequencer\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"setFraudProofAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"header\",\"type\":\"bytes\"},{\"internalType\":\"uint8\",\"name\":\"duration\",\"type\":\"uint8\"},{\"internalType\":\"uint32\",\"name\":\"blockNumber\",\"type\":\"uint32\"},{\"internalType\":\"uint256\",\"name\":\"startL2Block\",\"type\":\"uint256\"},{\"internalType\":\"uint256\",\"name\":\"endL2Block\",\"type\":\"uint256\"},{\"internalType\":\"uint32\",\"name\":\"totalOperatorsIndex\",\"type\":\"uint32\"},{\"internalType\":\"bool\",\"name\":\"isReRollup\",\"type\":\"bool\"}],\"name\":\"storeData\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"batchIndex\",\"type\":\"uint256\"}],\"name\":\"submitReRollUpInfo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_address\",\"type\":\"address\"}],\"name\":\"unavailableFraudProofAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_dataManageAddress\",\"type\":\"address\"}],\"name\":\"updateDataLayrManagerAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_fraudProofPeriod\",\"type\":\"uint256\"}],\"name\":\"updateFraudProofPeriod\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2ConfirmedBlockNumber\",\"type\":\"uint256\"}],\"name\":\"updateL2ConfirmedBlockNumber\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_l2StoredBlockNumber\",\"type\":\"uint256\"}],\"name\":\"updateL2StoredBlockNumber\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_reSubmitterAddress\",\"type\":\"address\"}],\"name\":\"updateReSubmitterAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"_rollupBatchIndex\",\"type\":\"uint256\"}],\"name\":\"updateRollupBatchIndex\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_sequencer\",\"type\":\"address\"}],\"name\":\"updateSequencerAddress\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"kind\":\"dev\",\"methods\":{\"confirmData(bytes,((bytes32,uint32,uint32,uint32,uint32,uint96,address,bytes32),uint8,uint256,uint32),uint256,uint256,uint32,uint256,bool)\":{\"details\":\"Only dataStores created through this contract can be confirmed by calling this function.\",\"params\":{\"data\":\"Input of the header information for a dataStore and signatures for confirming the dataStore -- used as input to the `confirmDataStore` function of the DataLayrServiceManager -- see the DataLayr docs for more info on this.\",\"searchData\":\"Data used to specify the dataStore being confirmed. Must be provided so other contracts can properly look up the dataStore.\"}},\"getL2ConfirmedBlockNumber()\":{\"returns\":{\"_0\":\"Latest stored L2 block number.\"}},\"getL2RollUpBlockByDataStoreId(uint32)\":{\"returns\":{\"_0\":\"BatchRollupBlock.\"}},\"getL2StoredBlockNumber()\":{\"returns\":{\"_0\":\"Latest stored L2 block number.\"}},\"getRollupStoreByRollupBatchIndex(uint256)\":{\"returns\":{\"_0\":\"RollupStore.\"}},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"parse(bytes[],uint256,uint256)\":{\"params\":{\"length\":\"The length of data to parse, in bytes.\",\"polys\":\"The non-interactive polynomial proofs themselves\",\"startIndex\":\"The byte index from which to begin reading data.\"},\"returns\":{\"provenString\":\"The parsed data.\"}},\"proveFraud(uint256,uint256,((bytes32,uint32,uint32,uint32,uint32,uint96,address,bytes32),uint8,uint256,uint32),(bytes,uint32,bytes[],((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2]),bytes)[],(uint256[2],uint256[2])))\":{\"details\":\"This function is only callable if: -the sequencer is staked, -the dataStore in question has been confirmed, and -the fraudproof period for the dataStore has not yet passed.\",\"params\":{\"disclosureProofs\":\"Non-interactive polynomial proofs that prove that the specific data of interest was part of the dataStore in question.\",\"fraudulentStoreNumber\":\"The rollup l2Block to prove fraud on\",\"searchData\":\"Data used to specify the dataStore being fraud-proven. Must be provided so other contracts can properly look up the dataStore.\",\"startIndex\":\"The index to begin reading the proven data from\"}},\"removeFraudProofAddress(address)\":{\"params\":{\"_address\":\"for fraud proof\"}},\"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.\"},\"resetRollupBatchData(uint256)\":{\"params\":{\"_rollupBatchIndex\":\"update rollup index\"}},\"setFraudProofAddress(address)\":{\"params\":{\"_address\":\"for fraud proof\"}},\"storeData(bytes,uint8,uint32,uint256,uint256,uint32,bool)\":{\"details\":\"The specified `blockNumber `must be less than `BLOCK_STALE_MEASURE` blocks in the past.\",\"params\":{\"blockNumber\":\"is the previous block number which was used to encode the data for storage\",\"duration\":\"is the duration to store the datastore for\",\"header\":\"of data to be stored\",\"totalOperatorsIndex\":\"is index in the totalOperators array of DataLayr referring to what the total number of operators was at `blockNumber`\"}},\"submitReRollUpInfo(uint256)\":{\"params\":{\"batchIndex\":\"need re-rollup batch index\"}},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"},\"unavailableFraudProofAddress(address)\":{\"params\":{\"_address\":\"for fraud proof\"}},\"updateDataLayrManagerAddress(address)\":{\"params\":{\"_dataManageAddress\":\"dlsm address\"}},\"updateFraudProofPeriod(uint256)\":{\"params\":{\"_fraudProofPeriod\":\"fraud proof period\"}},\"updateL2ConfirmedBlockNumber(uint256)\":{\"params\":{\"_l2ConfirmedBlockNumber\":\"l2 latest block number\"}},\"updateL2StoredBlockNumber(uint256)\":{\"params\":{\"_l2StoredBlockNumber\":\"l2 latest block number\"}},\"updateRollupBatchIndex(uint256)\":{\"params\":{\"_rollupBatchIndex\":\"update rollup batch index\"}},\"updateSequencerAddress(address)\":{\"params\":{\"_sequencer\":\"update sequencer address\"}}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"confirmData(bytes,((bytes32,uint32,uint32,uint32,uint32,uint96,address,bytes32),uint8,uint256,uint32),uint256,uint256,uint32,uint256,bool)\":{\"notice\":\"After the `storeData `transaction is included in a block and doesn\\u2019t revert, the sequencer will disperse the data to the DataLayr nodes off chain and get their signatures that they have stored the data. Now, the sequencer has to post the signature on chain and get it verified.\"},\"getL2ConfirmedBlockNumber()\":{\"notice\":\"Returns the block number of the latest stored L2.\"},\"getL2RollUpBlockByDataStoreId(uint32)\":{\"notice\":\"Returns the l2 block number by store id\"},\"getL2StoredBlockNumber()\":{\"notice\":\"Returns the block number of the latest stored L2.\"},\"getRollupStoreByRollupBatchIndex(uint256)\":{\"notice\":\"Returns the rollup store by l2 block number\"},\"parse(bytes[],uint256,uint256)\":{\"notice\":\"Parses data from non-interactive polynomial proofs.\"},\"proveFraud(uint256,uint256,((bytes32,uint32,uint32,uint32,uint32,uint96,address,bytes32),uint8,uint256,uint32),(bytes,uint32,bytes[],((uint256,uint256),(uint256,uint256),(uint256[2],uint256[2]),bytes)[],(uint256[2],uint256[2])))\":{\"notice\":\"Called by a challenger (this could be anyone -- \\\"challenger\\\" is not a permissioned role) to prove that fraud has occurred. First, a subset of data included in a dataStore that was initiated by the sequencer is proven, and then the presence of fraud in the data is checked. For the sake of this example, \\\"fraud occurring\\\" means that the sequencer included the forbidden `FRAUD_STRING` in a dataStore that they initiated. In pratical use, \\\"fraud occurring\\\" might mean including data that specifies an invalid transaction or invalid state transition.\"},\"removeFraudProofAddress(address)\":{\"notice\":\"remove fraud proof address\"},\"resetRollupBatchData(uint256)\":{\"notice\":\"reset batch rollup batch data\"},\"setFraudProofAddress(address)\":{\"notice\":\"set fraud proof address\"},\"storeData(bytes,uint8,uint32,uint256,uint256,uint32,bool)\":{\"notice\":\"Called by the (staked) sequencer to pay for a datastore and post some metadata (in the `header` parameter) about it on chain. Since the sequencer must encode the data before they post the header on chain, they must use a *snapshot* of the number and stakes of DataLayr operators from a previous block number, specified by the `blockNumber` input.\"},\"submitReRollUpInfo(uint256)\":{\"notice\":\"submit re-rollup batch index\"},\"unavailableFraudProofAddress(address)\":{\"notice\":\"unavailable fraud proof address\"},\"updateDataLayrManagerAddress(address)\":{\"notice\":\"update dlsm address\"},\"updateFraudProofPeriod(uint256)\":{\"notice\":\"update fraud proof period\"},\"updateL2ConfirmedBlockNumber(uint256)\":{\"notice\":\"update l2 latest confirm block number\"},\"updateL2StoredBlockNumber(uint256)\":{\"notice\":\"update l2 latest store block number\"},\"updateRollupBatchIndex(uint256)\":{\"notice\":\"update rollup batch index\"},\"updateSequencerAddress(address)\":{\"notice\":\"update sequencer address\"}},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/da/BVM_EigenDataLayrChain.sol\":\"BVM_EigenDataLayrChain\"},\"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/ReentrancyGuardUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)\\n\\npragma solidity ^0.8.0;\\nimport \\\"../proxy/utils/Initializable.sol\\\";\\n\\n/**\\n * @dev Contract module that helps prevent reentrant calls to a function.\\n *\\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\\n * available, which can be applied to functions to make sure there are no nested\\n * (reentrant) calls to them.\\n *\\n * Note that because there is a single `nonReentrant` guard, functions marked as\\n * `nonReentrant` may not call one another. This can be worked around by making\\n * those functions `private`, and then adding `external` `nonReentrant` entry\\n * points to them.\\n *\\n * TIP: If you would like to learn more about reentrancy and alternative ways\\n * to protect against it, check out our blog post\\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\\n */\\nabstract contract ReentrancyGuardUpgradeable is Initializable {\\n // Booleans are more expensive than uint256 or any type that takes up a full\\n // word because each write operation emits an extra SLOAD to first read the\\n // slot's contents, replace the bits taken up by the boolean, and then write\\n // back. This is the compiler's defense against contract upgrades and\\n // pointer aliasing, and it cannot be disabled.\\n\\n // The values being non-zero value makes deployment a bit more expensive,\\n // but in exchange the refund on every call to nonReentrant will be lower in\\n // amount. Since refunds are capped to a percentage of the total\\n // transaction's gas, it is best to keep them low in cases like this one, to\\n // increase the likelihood of the full refund coming into effect.\\n uint256 private constant _NOT_ENTERED = 1;\\n uint256 private constant _ENTERED = 2;\\n\\n uint256 private _status;\\n\\n function __ReentrancyGuard_init() internal onlyInitializing {\\n __ReentrancyGuard_init_unchained();\\n }\\n\\n function __ReentrancyGuard_init_unchained() internal onlyInitializing {\\n _status = _NOT_ENTERED;\\n }\\n\\n /**\\n * @dev Prevents a contract from calling itself, directly or indirectly.\\n * Calling a `nonReentrant` function from another `nonReentrant`\\n * function is not supported. It is possible to prevent this from happening\\n * by making the `nonReentrant` function external, and making it call a\\n * `private` function that does the actual work.\\n */\\n modifier nonReentrant() {\\n // On the first call to nonReentrant, _notEntered will be true\\n require(_status != _ENTERED, \\\"ReentrancyGuard: reentrant call\\\");\\n\\n // Any calls to nonReentrant after this point will fail\\n _status = _ENTERED;\\n\\n _;\\n\\n // By storing the original value once again, a refund is triggered (see\\n // https://eips.ethereum.org/EIPS/eip-2200)\\n _status = _NOT_ENTERED;\\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\":\"0x8cc03c5ac17e8a7396e487cda41fc1f1dfdb91db7d528e6da84bee3b6dd7e167\",\"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-upgradeable/utils/math/SafeMathUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n// OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol)\\n\\npragma solidity ^0.8.0;\\n\\n// CAUTION\\n// This version of SafeMath should only be used with Solidity 0.8 or later,\\n// because it relies on the compiler's built in overflow checks.\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations.\\n *\\n * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler\\n * now has built in overflow checking.\\n */\\nlibrary SafeMathUpgradeable {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n unchecked {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a + b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a * b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator.\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n unchecked {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(\\n uint256 a,\\n uint256 b,\\n string memory errorMessage\\n ) internal pure returns (uint256) {\\n unchecked {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcaa8b7861115ea691c77ddbeac140a444e0edcd1d9812a43942c0f6b42b36a49\",\"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\"},\"contracts/da/BVM_EigenDataLayrChain.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/utils/math/SafeMathUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\\\";\\nimport { DataLayrDisclosureLogic } from \\\"../libraries/eigenda/DataLayrDisclosureLogic.sol\\\";\\nimport { IDataLayrServiceManager } from \\\"../libraries/eigenda/interfaces/IDataLayrServiceManager.sol\\\";\\nimport { BN254 } from \\\"../libraries/eigenda/BN254.sol\\\";\\nimport { DataStoreUtils } from \\\"../libraries/eigenda/DataStoreUtils.sol\\\";\\nimport { Parser } from \\\"../libraries/eigenda/Parse.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\\\";\\n\\n\\ncontract BVM_EigenDataLayrChain is Initializable, OwnableUpgradeable, ReentrancyGuardUpgradeable, Parser {\\n using SafeMathUpgradeable for uint256;\\n using AddressUpgradeable for address;\\n\\n enum RollupStoreStatus {\\n UNCOMMITTED,\\n COMMITTED,\\n REVERTED\\n }\\n\\n struct DisclosureProofs {\\n bytes header;\\n uint32 firstChunkNumber;\\n bytes[] polys;\\n DataLayrDisclosureLogic.MultiRevealProof[] multiRevealProofs;\\n BN254.G2Point polyEquivalenceProof;\\n }\\n\\n address public sequencer;\\n address public dataManageAddress;\\n uint256 public BLOCK_STALE_MEASURE;\\n uint256 public l2StoredBlockNumber;\\n uint256 public l2ConfirmedBlockNumber;\\n uint256 public fraudProofPeriod;\\n uint256 public rollupBatchIndex;\\n\\n bytes public constant FRAUD_STRING = '--This is a bad string. Nobody says this string.--';\\n uint256 internal constant DATA_STORE_INITIALIZED_BUT_NOT_CONFIRMED = type(uint256).max;\\n\\n struct RollupStore {\\n uint32 originDataStoreId;\\n uint32 dataStoreId;\\n uint32 confirmAt;\\n RollupStoreStatus status;\\n }\\n\\n struct BatchRollupBlock {\\n uint256 startL2BlockNumber;\\n uint256 endBL2BlockNumber;\\n bool isReRollup;\\n }\\n\\n mapping(uint256 => RollupStore) public rollupBatchIndexRollupStores;\\n mapping(uint32 => BatchRollupBlock) public dataStoreIdToL2RollUpBlock;\\n mapping(uint32 => uint256) public dataStoreIdToRollupStoreNumber;\\n mapping(address => bool) private fraudProofWhitelist;\\n\\n address public reSubmitterAddress;\\n uint256 public reRollupIndex;\\n mapping(uint256 => uint256) public reRollupBatchIndex;\\n\\n event RollupStoreInitialized(uint32 dataStoreId, uint256 stratL2BlockNumber, uint256 endL2BlockNumber);\\n event RollupStoreConfirmed(uint256 rollupBatchIndex, uint32 dataStoreId, uint256 stratL2BlockNumber, uint256 endL2BlockNumber);\\n event RollupStoreReverted(uint256 rollupBatchIndex, uint32 dataStoreId, uint256 stratL2BlockNumber, uint256 endL2BlockNumber);\\n event ReRollupBatchData(uint256 reRollupIndex, uint256 rollupBatchIndex, uint256 stratL2BlockNumber, uint256 endL2BlockNumber);\\n event SequencerAddressUpdated(address oldSequencerAddress, address newSequencerAddress);\\n event FraudProofPeriodUpdated(uint256 oldFraudProofPeriod, uint256 newFraudProofPeriod);\\n event ReSubmitterAddressUpdated(address oldReSubmitterAddress, address newReSubmitterAddress);\\n event RollupBatchIndexUpdated(uint256 oldRollupBatchIndex, uint256 newRollupBatchIndex);\\n event L2ConfirmedBlockNumberUpdated(uint256 oldL2ConfirmedBlockNumber, uint256 newL2ConfirmedBlockNumber);\\n event DataLayrManagerAddressUpdated(address oldDataLayrManagerAddress, address newDataLayrManagerAddress);\\n\\n constructor() {\\n _disableInitializers();\\n }\\n\\n function initialize(address _sequencer, address _dataManageAddress, address _reSubmitterAddress, uint256 _block_stale_measure, uint256 _fraudProofPeriod, uint256 _l2SubmittedBlockNumber) public initializer {\\n __Ownable_init();\\n sequencer = _sequencer;\\n dataManageAddress = _dataManageAddress;\\n reSubmitterAddress = _reSubmitterAddress;\\n BLOCK_STALE_MEASURE = _block_stale_measure;\\n fraudProofPeriod = _fraudProofPeriod;\\n l2StoredBlockNumber = _l2SubmittedBlockNumber;\\n l2ConfirmedBlockNumber = _l2SubmittedBlockNumber;\\n }\\n\\n modifier onlySequencer() {\\n require(msg.sender == sequencer, \\\"Only the sequencer can do this action\\\");\\n _;\\n }\\n\\n /**\\n * @notice Returns the block number of the latest stored L2.\\n * @return Latest stored L2 block number.\\n */\\n function getL2StoredBlockNumber() public view returns (uint256) {\\n return l2StoredBlockNumber;\\n }\\n\\n /**\\n * @notice Returns the block number of the latest stored L2.\\n * @return Latest stored L2 block number.\\n */\\n function getL2ConfirmedBlockNumber() public view returns (uint256) {\\n return l2ConfirmedBlockNumber;\\n }\\n\\n /**\\n * @notice Returns the rollup store by l2 block number\\n * @return RollupStore.\\n */\\n function getRollupStoreByRollupBatchIndex(uint256 _rollupBatchIndex) public view returns (RollupStore memory) {\\n return rollupBatchIndexRollupStores[_rollupBatchIndex];\\n }\\n\\n /**\\n * @notice Returns the l2 block number by store id\\n * @return BatchRollupBlock.\\n */\\n function getL2RollUpBlockByDataStoreId(uint32 _dataStoreId) public view returns (BatchRollupBlock memory) {\\n return dataStoreIdToL2RollUpBlock[_dataStoreId];\\n }\\n\\n /**\\n * @notice set fraud proof address\\n * @param _address for fraud proof\\n */\\n function setFraudProofAddress(address _address) external onlySequencer {\\n require(_address != address(0), \\\"setFraudProofAddress: address is the zero address\\\");\\n fraudProofWhitelist[_address] = true;\\n }\\n\\n /**\\n * @notice unavailable fraud proof address\\n * @param _address for fraud proof\\n */\\n function unavailableFraudProofAddress(address _address) external onlySequencer {\\n require(_address != address(0), \\\"unavailableFraudProofAddress: unavailableFraudProofAddress: address is the zero address\\\");\\n fraudProofWhitelist[_address] = false;\\n }\\n\\n /**\\n * @notice remove fraud proof address\\n * @param _address for fraud proof\\n */\\n function removeFraudProofAddress(address _address) external onlySequencer {\\n require(_address != address(0), \\\"removeFraudProofAddress: removeFraudProofAddress: address is the zero address\\\");\\n delete fraudProofWhitelist[_address];\\n }\\n\\n /**\\n * @notice update fraud proof period\\n * @param _fraudProofPeriod fraud proof period\\n */\\n function updateFraudProofPeriod(uint256 _fraudProofPeriod) external onlySequencer {\\n uint256 oldFraudProofPeriod = fraudProofPeriod;\\n fraudProofPeriod = _fraudProofPeriod;\\n emit FraudProofPeriodUpdated(oldFraudProofPeriod, fraudProofPeriod);\\n }\\n\\n /**\\n * @notice update dlsm address\\n * @param _dataManageAddress dlsm address\\n */\\n function updateDataLayrManagerAddress(address _dataManageAddress) external onlySequencer {\\n require(_dataManageAddress != address(0), \\\"updateDataLayrManagerAddress: _dataManageAddress is the zero address\\\");\\n address oldDataManageAddress = dataManageAddress;\\n dataManageAddress = _dataManageAddress;\\n emit DataLayrManagerAddressUpdated(oldDataManageAddress, dataManageAddress);\\n }\\n\\n /**\\n * @notice update l2 latest store block number\\n * @param _l2StoredBlockNumber l2 latest block number\\n */\\n function updateL2StoredBlockNumber(uint256 _l2StoredBlockNumber) external onlySequencer {\\n uint256 oldL2StoredBlockNumber = l2StoredBlockNumber;\\n l2StoredBlockNumber = _l2StoredBlockNumber;\\n emit L2ConfirmedBlockNumberUpdated(oldL2StoredBlockNumber, l2StoredBlockNumber);\\n }\\n\\n /**\\n * @notice update l2 latest confirm block number\\n * @param _l2ConfirmedBlockNumber l2 latest block number\\n */\\n function updateL2ConfirmedBlockNumber(uint256 _l2ConfirmedBlockNumber) external onlySequencer {\\n l2ConfirmedBlockNumber = _l2ConfirmedBlockNumber;\\n }\\n\\n /**\\n * @notice update sequencer address\\n * @param _sequencer update sequencer address\\n */\\n function updateSequencerAddress(address _sequencer) external onlyOwner {\\n require(_sequencer != address(0), \\\"updateSequencerAddress: _sequencer is the zero address\\\");\\n address oldSequencer = sequencer;\\n sequencer = _sequencer;\\n emit SequencerAddressUpdated(oldSequencer, sequencer);\\n }\\n\\n function updateReSubmitterAddress(address _reSubmitterAddress) external onlySequencer {\\n require(_reSubmitterAddress != address(0), \\\"updateReSubmitterAddress: _reSubmitterAddress is the zero address\\\");\\n address oldReSubmitterAddress = reSubmitterAddress;\\n reSubmitterAddress = _reSubmitterAddress;\\n emit ReSubmitterAddressUpdated(oldReSubmitterAddress, reSubmitterAddress);\\n }\\n\\n /**\\n * @notice update rollup batch index\\n * @param _rollupBatchIndex update rollup batch index\\n */\\n function updateRollupBatchIndex(uint256 _rollupBatchIndex) external onlySequencer {\\n uint256 oldRollupBatchIndex = rollupBatchIndex;\\n rollupBatchIndex = _rollupBatchIndex;\\n emit RollupBatchIndexUpdated(oldRollupBatchIndex, rollupBatchIndex);\\n }\\n\\n /**\\n * @notice reset batch rollup batch data\\n * @param _rollupBatchIndex update rollup index\\n */\\n function resetRollupBatchData(uint256 _rollupBatchIndex) external onlySequencer {\\n for (uint256 i = _rollupBatchIndex; i < rollupBatchIndex; i++) {\\n delete rollupBatchIndexRollupStores[i];\\n }\\n rollupBatchIndex = _rollupBatchIndex;\\n l2StoredBlockNumber = 1;\\n l2ConfirmedBlockNumber = 1;\\n }\\n\\n /**\\n * @notice submit re-rollup batch index\\n * @param batchIndex need re-rollup batch index\\n */\\n function submitReRollUpInfo(\\n uint256 batchIndex\\n ) external {\\n require(msg.sender == reSubmitterAddress, \\\"submitReRollUpInfo: Only the re submitter can submit re rollup data\\\");\\n RollupStore memory rStore = rollupBatchIndexRollupStores[batchIndex];\\n if (rStore.dataStoreId > 0) {\\n reRollupBatchIndex[reRollupIndex] = batchIndex;\\n emit ReRollupBatchData(\\n reRollupIndex++,\\n batchIndex,\\n dataStoreIdToL2RollUpBlock[rStore.dataStoreId].startL2BlockNumber,\\n dataStoreIdToL2RollUpBlock[rStore.dataStoreId].endBL2BlockNumber\\n );\\n }\\n }\\n\\n /**\\n * @notice Called by the (staked) sequencer to pay for a datastore and post some metadata (in the `header` parameter) about it on chain.\\n * Since the sequencer must encode the data before they post the header on chain, they must use a *snapshot* of the number and stakes of DataLayr operators\\n * from a previous block number, specified by the `blockNumber` input.\\n * @param header of data to be stored\\n * @param duration is the duration to store the datastore for\\n * @param blockNumber is the previous block number which was used to encode the data for storage\\n * @param totalOperatorsIndex is index in the totalOperators array of DataLayr referring to what the total number of operators was at `blockNumber`\\n * @dev The specified `blockNumber `must be less than `BLOCK_STALE_MEASURE` blocks in the past.\\n */\\n function storeData(\\n bytes calldata header,\\n uint8 duration,\\n uint32 blockNumber,\\n uint256 startL2Block,\\n uint256 endL2Block,\\n uint32 totalOperatorsIndex,\\n bool isReRollup\\n ) external onlySequencer {\\n require(endL2Block > startL2Block, \\\"storeData: endL2Block must more than startL2Block\\\");\\n require(block.number - blockNumber < BLOCK_STALE_MEASURE, \\\"storeData: stakes taken from too long ago\\\");\\n uint32 dataStoreId = IDataLayrServiceManager(dataManageAddress).taskNumber();\\n IDataLayrServiceManager(dataManageAddress).initDataStore(\\n msg.sender,\\n address(this),\\n duration,\\n blockNumber,\\n totalOperatorsIndex,\\n header\\n );\\n dataStoreIdToL2RollUpBlock[dataStoreId] = BatchRollupBlock({\\n startL2BlockNumber: startL2Block,\\n endBL2BlockNumber: endL2Block,\\n isReRollup: isReRollup\\n });\\n dataStoreIdToRollupStoreNumber[dataStoreId] = DATA_STORE_INITIALIZED_BUT_NOT_CONFIRMED;\\n if (!isReRollup) {\\n l2StoredBlockNumber = endL2Block;\\n }\\n emit RollupStoreInitialized(dataStoreId, startL2Block, endL2Block);\\n }\\n\\n /**\\n * @notice After the `storeData `transaction is included in a block and doesn\\u2019t revert, the sequencer will disperse the data to the DataLayr nodes off chain\\n * and get their signatures that they have stored the data. Now, the sequencer has to post the signature on chain and get it verified.\\n * @param data Input of the header information for a dataStore and signatures for confirming the dataStore -- used as input to the `confirmDataStore` function\\n * of the DataLayrServiceManager -- see the DataLayr docs for more info on this.\\n * @param searchData Data used to specify the dataStore being confirmed. Must be provided so other contracts can properly look up the dataStore.\\n * @dev Only dataStores created through this contract can be confirmed by calling this function.\\n */\\n function confirmData(\\n bytes calldata data,\\n IDataLayrServiceManager.DataStoreSearchData memory searchData,\\n uint256 startL2Block,\\n uint256 endL2Block,\\n uint32 originDataStoreId,\\n uint256 reConfirmedBatchIndex,\\n bool isReRollup\\n ) external onlySequencer {\\n require(endL2Block > startL2Block, \\\"confirmData: endL2Block must more than startL2Block\\\");\\n BatchRollupBlock memory batchRollupBlock = dataStoreIdToL2RollUpBlock[searchData.metadata.globalDataStoreId];\\n require(batchRollupBlock.startL2BlockNumber == startL2Block &&\\n batchRollupBlock.endBL2BlockNumber == endL2Block &&\\n batchRollupBlock.isReRollup == isReRollup,\\n \\\"confirmData: Data store either was not initialized by the rollup contract, or is already confirmed\\\"\\n );\\n require(\\n dataStoreIdToRollupStoreNumber[searchData.metadata.globalDataStoreId] == DATA_STORE_INITIALIZED_BUT_NOT_CONFIRMED,\\n \\\"confirmData: Data store either was not initialized by the rollup contract, or is already confirmed\\\"\\n );\\n IDataLayrServiceManager(dataManageAddress).confirmDataStore(data, searchData);\\n if (!isReRollup) {\\n rollupBatchIndexRollupStores[rollupBatchIndex] = RollupStore({\\n originDataStoreId: searchData.metadata.globalDataStoreId,\\n dataStoreId: searchData.metadata.globalDataStoreId,\\n confirmAt: uint32(block.timestamp + fraudProofPeriod),\\n status: RollupStoreStatus.COMMITTED\\n });\\n l2ConfirmedBlockNumber = endL2Block;\\n dataStoreIdToRollupStoreNumber[searchData.metadata.globalDataStoreId] = rollupBatchIndex;\\n emit RollupStoreConfirmed(uint32(rollupBatchIndex++), searchData.metadata.globalDataStoreId, startL2Block, endL2Block);\\n } else {\\n rollupBatchIndexRollupStores[reConfirmedBatchIndex] = RollupStore({\\n originDataStoreId: originDataStoreId,\\n dataStoreId: searchData.metadata.globalDataStoreId,\\n confirmAt: uint32(block.timestamp + fraudProofPeriod),\\n status: RollupStoreStatus.COMMITTED\\n });\\n dataStoreIdToRollupStoreNumber[searchData.metadata.globalDataStoreId] = reConfirmedBatchIndex;\\n emit RollupStoreConfirmed(reConfirmedBatchIndex, searchData.metadata.globalDataStoreId, startL2Block, endL2Block);\\n }\\n }\\n\\n /**\\n * @notice Called by a challenger (this could be anyone -- \\\"challenger\\\" is not a permissioned role) to prove that fraud has occurred.\\n * First, a subset of data included in a dataStore that was initiated by the sequencer is proven, and then the presence of fraud in the data is checked.\\n * For the sake of this example, \\\"fraud occurring\\\" means that the sequencer included the forbidden `FRAUD_STRING` in a dataStore that they initiated.\\n * In pratical use, \\\"fraud occurring\\\" might mean including data that specifies an invalid transaction or invalid state transition.\\n * @param fraudulentStoreNumber The rollup l2Block to prove fraud on\\n * @param startIndex The index to begin reading the proven data from\\n * @param searchData Data used to specify the dataStore being fraud-proven. Must be provided so other contracts can properly look up the dataStore.\\n * @param disclosureProofs Non-interactive polynomial proofs that prove that the specific data of interest was part of the dataStore in question.\\n * @dev This function is only callable if:\\n * -the sequencer is staked,\\n * -the dataStore in question has been confirmed, and\\n * -the fraudproof period for the dataStore has not yet passed.\\n */\\n function proveFraud(\\n uint256 fraudulentStoreNumber,\\n uint256 startIndex,\\n IDataLayrServiceManager.DataStoreSearchData memory searchData,\\n DisclosureProofs calldata disclosureProofs\\n ) external {\\n require(fraudProofWhitelist[msg.sender], \\\"proveFraud: Only fraud proof white list can challenge data\\\");\\n RollupStore memory rollupStore = rollupBatchIndexRollupStores[fraudulentStoreNumber];\\n require(rollupStore.status == RollupStoreStatus.COMMITTED && rollupStore.confirmAt > block.timestamp, \\\"RollupStore must be committed and unconfirmed\\\");\\n require(\\n IDataLayrServiceManager(dataManageAddress).getDataStoreHashesForDurationAtTimestamp(\\n searchData.duration,\\n searchData.timestamp,\\n searchData.index\\n ) == DataStoreUtils.computeDataStoreHash(searchData.metadata),\\n \\\"proveFraud: metadata preimage is incorrect\\\"\\n );\\n require(searchData.metadata.globalDataStoreId == rollupStore.dataStoreId, \\\"seachData's datastore id is not consistent with given rollup store\\\");\\n require(searchData.metadata.headerHash == keccak256(disclosureProofs.header), \\\"disclosure proofs headerhash preimage is incorrect\\\");\\n require(DataLayrDisclosureLogic.batchNonInteractivePolynomialProofs(\\n disclosureProofs.header,\\n disclosureProofs.firstChunkNumber,\\n disclosureProofs.polys,\\n disclosureProofs.multiRevealProofs,\\n disclosureProofs.polyEquivalenceProof\\n ), \\\"disclosure proofs are invalid\\\");\\n uint32 numSys = DataLayrDisclosureLogic.getNumSysFromHeader(disclosureProofs.header);\\n require(disclosureProofs.firstChunkNumber + disclosureProofs.polys.length <= numSys, \\\"Can only prove data from the systematic chunks\\\");\\n bytes memory provenString = parse(disclosureProofs.polys, startIndex, FRAUD_STRING.length);\\n require(provenString.length == FRAUD_STRING.length, \\\"Parsing error, proven string is different length than fraud string\\\");\\n require(keccak256(provenString) == keccak256(FRAUD_STRING), \\\"proven string != fraud string\\\");\\n rollupBatchIndexRollupStores[fraudulentStoreNumber].status = RollupStoreStatus.REVERTED;\\n emit RollupStoreReverted(\\n fraudulentStoreNumber,\\n searchData.metadata.globalDataStoreId,\\n dataStoreIdToL2RollUpBlock[searchData.metadata.globalDataStoreId].startL2BlockNumber,\\n dataStoreIdToL2RollUpBlock[searchData.metadata.globalDataStoreId].endBL2BlockNumber\\n );\\n }\\n}\\n\",\"keccak256\":\"0x3f005ec2020e53f29818bb60d18914ed4e43330183408257e094b5bf875857a6\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/BN254.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED AND MIT\\n// several functions are taken or adapted from https://github.com/HarryR/solcrypto/blob/master/contracts/altbn128.sol (MIT license):\\n// Copyright 2017 Christian Reitwiessner\\n// Permission is hereby granted, free of charge, to any person obtaining a copy\\n// of this software and associated documentation files (the \\\"Software\\\"), to\\n// deal in the Software without restriction, including without limitation the\\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\\n// sell copies of the Software, and to permit persons to whom the Software is\\n// furnished to do so, subject to the following conditions:\\n// The above copyright notice and this permission notice shall be included in\\n// all copies or substantial portions of the Software.\\n// THE SOFTWARE IS PROVIDED \\\"AS IS\\\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\\n// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\\n// IN THE SOFTWARE.\\n\\n// The remainder of the code is written by LayrLabs Inc. and UNLICENSED\\n\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Library for operations on the BN254 elliptic curve.\\n * @author Layr Labs, Inc.\\n * @notice Contains BN254 parameters, common operations (addition, scalar mul, pairing), and BLS signature functionality.\\n */\\nlibrary BN254 {\\n // modulus for the underlying field F_p of the elliptic curve\\n uint256 internal constant FP_MODULUS =\\n 21888242871839275222246405745257275088696311157297823662689037894645226208583;\\n // modulus for the underlying field F_r of the elliptic curve\\n uint256 internal constant FR_MODULUS =\\n 21888242871839275222246405745257275088548364400416034343698204186575808495617;\\n\\n // primitive root of unity\\n uint256 internal constant OMEGA = 10359452186428527605436343203440067497552205259388878191021578220384701716497;\\n\\n\\n struct G1Point {\\n uint256 X;\\n uint256 Y;\\n }\\n\\n // Encoding of field elements is: X[1] * i + X[0]\\n struct G2Point {\\n uint256[2] X;\\n uint256[2] Y;\\n }\\n\\n // generator of group G2\\n /// @dev Generator point in F_q2 is of the form: (x0 + ix1, y0 + iy1).\\n uint256 internal constant G2x1 =\\n 11559732032986387107991004021392285783925812861821192530917403151452391805634;\\n uint256 internal constant G2x0 =\\n 10857046999023057135944570762232829481370756359578518086990519993285655852781;\\n uint256 internal constant G2y1 =\\n 4082367875863433681332203403145435568316851327593401208105741076214120093531;\\n uint256 internal constant G2y0 =\\n 8495653923123431417604973247489272438418190587263600148770280649306958101930;\\n /// @notice returns the G2 generator\\n /// @dev mind the ordering of the 1s and 0s!\\n /// this is because of the (unknown to us) convention used in the bn254 pairing precompile contract\\n /// \\\"Elements a * i + b of F_p^2 are encoded as two elements of F_p, (a, b).\\\"\\n /// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-197.md#encoding\\n function generatorG2() internal pure returns (G2Point memory) {\\n return G2Point(\\n [G2x1, G2x0], [G2y1, G2y0]\\n );\\n }\\n\\n // negation of the generator of group G2\\n /// @dev Generator point in F_q2 is of the form: (x0 + ix1, y0 + iy1).\\n uint256 internal constant nG2x1 =\\n 11559732032986387107991004021392285783925812861821192530917403151452391805634;\\n uint256 internal constant nG2x0 =\\n 10857046999023057135944570762232829481370756359578518086990519993285655852781;\\n uint256 internal constant nG2y1 =\\n 17805874995975841540914202342111839520379459829704422454583296818431106115052;\\n uint256 internal constant nG2y0 =\\n 13392588948715843804641432497768002650278120570034223513918757245338268106653;\\n function negGeneratorG2() internal pure returns (G2Point memory) {\\n return G2Point(\\n [nG2x1, nG2x0], [nG2y1, nG2y0]\\n );\\n }\\n\\n // first power of srs in G2\\n // TODO: change in production\\n uint256 internal constant G2SRSx1 = 7912312892787135728292535536655271843828059318189722219035249994421084560563;\\n uint256 internal constant G2SRSx0 = 21039730876973405969844107393779063362038454413254731404052240341412356318284;\\n uint256 internal constant G2SRSy1 = 18697407556011630376420900106252341752488547575648825575049647403852275261247;\\n uint256 internal constant G2SRSy0 = 7586489485579523767759120334904353546627445333297951253230866312564920951171;\\n function G2SRSFirstPower() internal pure returns (G2Point memory) {\\n return G2Point(\\n [G2SRSx0, G2SRSx1], [G2SRSy0, G2SRSy1]\\n );\\n }\\n\\n bytes32 internal constant powersOfTauMerkleRoot =\\n 0x22c998e49752bbb1918ba87d6d59dd0e83620a311ba91dd4b2cc84990b31b56f;\\n\\n\\n /**\\n * @param p Some point in G1.\\n * @return The negation of `p`, i.e. p.plus(p.negate()) should be zero.\\n */\\n function negate(G1Point memory p) internal pure returns (G1Point memory) {\\n // The prime q in the base field F_q for G1\\n if (p.X == 0 && p.Y == 0) {\\n return G1Point(0, 0);\\n } else {\\n return G1Point(p.X, FP_MODULUS - (p.Y % FP_MODULUS));\\n }\\n }\\n\\n /**\\n * @return r the sum of two points of G1\\n */\\n function plus(\\n G1Point memory p1,\\n G1Point memory p2\\n ) internal view returns (G1Point memory r) {\\n uint256[4] memory input;\\n input[0] = p1.X;\\n input[1] = p1.Y;\\n input[2] = p2.X;\\n input[3] = p2.Y;\\n bool success;\\n\\n // solium-disable-next-line security/no-inline-assembly\\n assembly {\\n success := staticcall(sub(gas(), 2000), 6, input, 0x80, r, 0x40)\\n // Use \\\"invalid\\\" to make gas estimation work\\n switch success\\n case 0 {\\n invalid()\\n }\\n }\\n\\n require(success, \\\"ec-add-failed\\\");\\n }\\n\\n /**\\n * @return r the product of a point on G1 and a scalar, i.e.\\n * p == p.scalar_mul(1) and p.plus(p) == p.scalar_mul(2) for all\\n * points p.\\n */\\n function scalar_mul(\\n G1Point memory p,\\n uint256 s\\n ) internal view returns (G1Point memory r) {\\n uint256[3] memory input;\\n input[0] = p.X;\\n input[1] = p.Y;\\n input[2] = s;\\n bool success;\\n // solium-disable-next-line security/no-inline-assembly\\n assembly {\\n success := staticcall(sub(gas(), 2000), 7, input, 0x60, r, 0x40)\\n // Use \\\"invalid\\\" to make gas estimation work\\n switch success\\n case 0 {\\n invalid()\\n }\\n }\\n require(success, \\\"ec-mul-failed\\\");\\n }\\n\\n /**\\n * @return The result of computing the pairing check\\n * e(p1[0], p2[0]) * .... * e(p1[n], p2[n]) == 1\\n * For example,\\n * pairing([P1(), P1().negate()], [P2(), P2()]) should return true.\\n */\\n function pairing(\\n G1Point memory a1,\\n G2Point memory a2,\\n G1Point memory b1,\\n G2Point memory b2\\n ) internal view returns (bool) {\\n G1Point[2] memory p1 = [a1, b1];\\n G2Point[2] memory p2 = [a2, b2];\\n\\n uint256[12] memory input;\\n\\n for (uint256 i = 0; i < 2; i++) {\\n uint256 j = i * 6;\\n input[j + 0] = p1[i].X;\\n input[j + 1] = p1[i].Y;\\n input[j + 2] = p2[i].X[0];\\n input[j + 3] = p2[i].X[1];\\n input[j + 4] = p2[i].Y[0];\\n input[j + 5] = p2[i].Y[1];\\n }\\n\\n uint256[1] memory out;\\n bool success;\\n\\n // solium-disable-next-line security/no-inline-assembly\\n assembly {\\n success := staticcall(\\n sub(gas(), 2000),\\n 8,\\n input,\\n mul(12, 0x20),\\n out,\\n 0x20\\n )\\n // Use \\\"invalid\\\" to make gas estimation work\\n switch success\\n case 0 {\\n invalid()\\n }\\n }\\n\\n require(success, \\\"pairing-opcode-failed\\\");\\n\\n return out[0] != 0;\\n }\\n\\n /**\\n * @notice This function is functionally the same as pairing(), however it specifies a gas limit\\n * the user can set, as a precompile may use the entire gas budget if it reverts.\\n */\\n function safePairing(\\n G1Point memory a1,\\n G2Point memory a2,\\n G1Point memory b1,\\n G2Point memory b2,\\n uint256 pairingGas\\n ) internal view returns (bool, bool) {\\n G1Point[2] memory p1 = [a1, b1];\\n G2Point[2] memory p2 = [a2, b2];\\n\\n uint256[12] memory input;\\n\\n for (uint256 i = 0; i < 2; i++) {\\n uint256 j = i * 6;\\n input[j + 0] = p1[i].X;\\n input[j + 1] = p1[i].Y;\\n input[j + 2] = p2[i].X[0];\\n input[j + 3] = p2[i].X[1];\\n input[j + 4] = p2[i].Y[0];\\n input[j + 5] = p2[i].Y[1];\\n }\\n\\n uint256[1] memory out;\\n bool success;\\n\\n // solium-disable-next-line security/no-inline-assembly\\n assembly {\\n success := staticcall(\\n pairingGas,\\n 8,\\n input,\\n mul(12, 0x20),\\n out,\\n 0x20\\n )\\n }\\n\\n //Out is the output of the pairing precompile, either 0 or 1 based on whether the two pairings are equal.\\n //Success is true if the precompile actually goes through (aka all inputs are valid)\\n\\n return (success, out[0] != 0);\\n }\\n\\n /// @return the keccak256 hash of the G1 Point\\n /// @dev used for BLS signatures\\n function hashG1Point(\\n BN254.G1Point memory pk\\n ) internal pure returns (bytes32) {\\n return keccak256(abi.encodePacked(pk.X, pk.Y));\\n }\\n\\n\\n /**\\n * @notice adapted from https://github.com/HarryR/solcrypto/blob/master/contracts/altbn128.sol\\n */\\n function hashToG1(bytes32 _x) internal view returns (uint256, uint256) {\\n uint256 beta = 0;\\n uint256 y = 0;\\n\\n // XXX: Gen Order (n) or Field Order (p) ?\\n uint256 x = uint256(_x) % FP_MODULUS;\\n\\n while( true ) {\\n (beta, y) = findYFromX(x);\\n\\n // y^2 == beta\\n if( beta == mulmod(y, y, FP_MODULUS) ) {\\n return (x, y);\\n }\\n\\n x = addmod(x, 1, FP_MODULUS);\\n }\\n return (0, 0);\\n }\\n\\n /**\\n * Given X, find Y\\n *\\n * where y = sqrt(x^3 + b)\\n *\\n * Returns: (x^3 + b), y\\n */\\n function findYFromX(uint256 x)\\n internal view returns(uint256, uint256)\\n {\\n // beta = (x^3 + b) % p\\n uint256 beta = addmod(mulmod(mulmod(x, x, FP_MODULUS), x, FP_MODULUS), 3, FP_MODULUS);\\n\\n // y^2 = x^3 + b\\n // this acts like: y = sqrt(beta) = beta^((p+1) / 4)\\n uint256 y = expMod(beta, 0xc19139cb84c680a6e14116da060561765e05aa45a1c72a34f082305b61f3f52, FP_MODULUS);\\n\\n return (beta, y);\\n }\\n\\n function expMod(uint256 _base, uint256 _exponent, uint256 _modulus) internal view returns (uint256 retval) {\\n bool success;\\n uint256[1] memory output;\\n uint[6] memory input;\\n input[0] = 0x20; // baseLen = new(big.Int).SetBytes(getData(input, 0, 32))\\n input[1] = 0x20; // expLen = new(big.Int).SetBytes(getData(input, 32, 32))\\n input[2] = 0x20; // modLen = new(big.Int).SetBytes(getData(input, 64, 32))\\n input[3] = _base;\\n input[4] = _exponent;\\n input[5] = _modulus;\\n assembly {\\n success := staticcall(sub(gas(), 2000), 5, input, 0xc0, output, 0x20)\\n // Use \\\"invalid\\\" to make gas estimation work\\n switch success case 0 { invalid() }\\n }\\n require(success);\\n return output[0];\\n }\\n}\\n\",\"keccak256\":\"0xfa39af1ea6c1dd15972030b6ce7cbe29f6a32b020977633cd4f31caa4bc08d07\",\"license\":\"UNLICENSED AND MIT\"},\"contracts/libraries/eigenda/DataLayrDisclosureLogic.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"./Merkle.sol\\\";\\nimport \\\"./BN254.sol\\\";\\nimport \\\"./interfaces/IDataLayrServiceManager.sol\\\";\\n\\nlibrary DataLayrDisclosureLogic {\\n uint256 constant MODULUS =\\n 21888242871839275222246405745257275088548364400416034343698204186575808495617;\\n\\n struct MultiRevealProof {\\n BN254.G1Point interpolationPoly;\\n BN254.G1Point revealProof;\\n BN254.G2Point zeroPoly;\\n bytes zeroPolyProof;\\n }\\n\\n struct DataStoreKZGMetadata {\\n BN254.G1Point c;\\n uint48 degree;\\n uint32 numSys;\\n uint32 numPar;\\n }\\n\\n function getDataCommitmentAndMultirevealDegreeAndSymbolBreakdownFromHeader(\\n // bytes calldata header\\n bytes calldata header\\n ) internal pure returns (DataStoreKZGMetadata memory) {\\n // return x, y coordinate of overall data poly commitment\\n // then return degree of multireveal polynomial\\n BN254.G1Point memory point;\\n uint48 degree;\\n uint32 numSys;\\n uint32 numPar;\\n uint256 pointer;\\n\\n assembly {\\n pointer := header.offset\\n mstore(point, calldataload(pointer))\\n mstore(add(point, 0x20), calldataload(add(pointer, 32)))\\n //TODO: PUT THE LOW DEGREENESS PROOF HERE\\n degree := shr(224, calldataload(add(pointer, 64)))\\n\\n numSys := shr(224, calldataload(add(pointer, 68)))\\n numPar := shr(224, calldataload(add(pointer, 72)))\\n }\\n\\n return\\n DataStoreKZGMetadata({\\n c: point,\\n degree: degree,\\n numSys: numSys,\\n numPar: numPar\\n });\\n }\\n\\n function getNumSysFromHeader(\\n // bytes calldata header\\n bytes calldata header\\n ) internal pure returns (uint32) {\\n uint32 numSys;\\n\\n assembly {\\n numSys := shr(224, calldataload(add(header.offset, 68)))\\n }\\n\\n return numSys;\\n }\\n\\n function getLeadingCosetIndexFromHighestRootOfUnity(\\n uint32 i,\\n uint32 numSys,\\n uint32 numPar\\n ) internal pure returns (uint32) {\\n uint32 numNode = numSys + numPar;\\n uint32 numSysE = uint32(nextPowerOf2(numSys));\\n uint32 ratio = numNode / numSys + (numNode % numSys == 0 ? 0 : 1);\\n uint32 numNodeE = uint32(nextPowerOf2(numSysE * ratio));\\n\\n if (i < numSys) {\\n return\\n (reverseBitsLimited(uint32(numNodeE), uint32(i)) * 256) /\\n numNodeE;\\n } else if (i < numNodeE - (numSysE - numSys)) {\\n return\\n (reverseBitsLimited(\\n uint32(numNodeE),\\n uint32((i - numSys) + numSysE)\\n ) * 256) / numNodeE;\\n } else {\\n revert(\\\"Cannot create number of frame higher than possible\\\");\\n }\\n }\\n\\n function reverseBitsLimited(uint32 length, uint32 value)\\n internal\\n pure\\n returns (uint32)\\n {\\n uint32 unusedBitLen = 32 - uint32(log2(length));\\n return reverseBits(value) >> unusedBitLen;\\n }\\n\\n function reverseBits(uint32 value) internal pure returns (uint32) {\\n uint256 reversed = 0;\\n for (uint i = 0; i < 32; i++) {\\n uint256 mask = 1 << i;\\n if (value & mask != 0) {\\n reversed |= (1 << (31 - i));\\n }\\n }\\n return uint32(reversed);\\n }\\n\\n //takes the log base 2 of n and returns it\\n function log2(uint256 n) internal pure returns (uint256) {\\n require(n > 0, \\\"Log must be defined\\\");\\n uint256 log = 0;\\n while (n >> log != 1) {\\n log++;\\n }\\n return log;\\n }\\n\\n //finds the next power of 2 greater than n and returns it\\n function nextPowerOf2(uint256 n) internal pure returns (uint256) {\\n uint256 res = 1;\\n while (1 << res < n) {\\n res++;\\n }\\n res = 1 << res;\\n return res;\\n }\\n\\n // gets the merkle root of a tree where all the leaves are the hashes of the zero/vanishing polynomials of the given multireveal\\n // degree at different roots of unity. We are assuming a max of 512 datalayr nodes right now, so, for merkle root for \\\"degree\\\"\\n // will be of the tree where the leaves are the hashes of the G2 kzg commitments to the following polynomials:\\n // l = degree (for brevity)\\n // w^(512*l) = 1\\n // (s^l - 1), (s^l - w^l), (s^l - w^2l), (s^l - w^3l), (s^l - w^4l), ...\\n // we have precomputed these values and return them directly because it's cheap. currently we\\n // tolerate up to degree 2^10, which means up to (31 bytes/point)(1024 points/dln)(256 dln) = 8 MB in a datastore\\n function getZeroPolyMerkleRoot(uint256 degree)\\n internal\\n pure\\n returns (bytes32)\\n {\\n uint256 log = log2(degree);\\n\\n if (log == 0) {\\n return\\n 0xe82cea94884b1b895ea0742840a3b19249a723810fd1b04d8564d675b0a416f1;\\n } else if (log == 1) {\\n return\\n 0x4843774a80fc8385b31024f5bd18b42e62de439206ab9468d42d826796d41f67;\\n } else if (log == 2) {\\n return\\n 0x092d3e5f87f5293e7ab0cc2ca6b0b5e4adb5e0011656544915f7cea34e69e5ab;\\n } else if (log == 3) {\\n return\\n 0x494b208540ec8624fbbb3f2c64ffccdaf6253f8f4e50c0d93922d88195b07755;\\n } else if (log == 4) {\\n return\\n 0xfdb44b84a82893cfa0e37a97f09ffc4298ad5e62be1bea1d03320ae836213d22;\\n } else if (log == 5) {\\n return\\n 0x3f50cb08231d2a76853ba9dbb20dad45a1b75c57cdaff6223bfe069752cff3d4;\\n } else if (log == 6) {\\n return\\n 0xbb39eebd8138eefd5802a49d571e65b3e0d4e32277c28fbf5fbca66e7fb04310;\\n } else if (log == 7) {\\n return\\n 0xf0a39b513e11fa80cbecbf352f69310eddd5cd03148768e0e9542bd600b133ec;\\n } else if (log == 8) {\\n return\\n 0x038cca2238865414efb752cc004fffec9e6069b709f495249cdf36efbd5952f6;\\n } else if (log == 9) {\\n return\\n 0x2a26b054ed559dd255d8ac9060ebf6b95b768d87de767f8174ad2f9a4e48dd01;\\n } else if (log == 10) {\\n return\\n 0x1fe180d0bc4ff7c69fefa595b3b5f3c284535a280f6fdcf69b20770d1e20e1fc;\\n } else if (log == 11) {\\n return\\n 0x60e34ad57c61cd6fdd8177437c30e4a30334e63d7683989570cf27020efc8201;\\n } else if (log == 12) {\\n return\\n 0xeda2417e770ddbe88f083acf06b6794dfb76301314a32bd0697440d76f6cd9cc;\\n } else if (log == 13) {\\n return\\n 0x8cbe9b8cf92ce70e3bec8e1e72a0f85569017a7e43c3db50e4a5badb8dea7ce8;\\n } else {\\n revert(\\\"Log not in valid range\\\");\\n }\\n }\\n\\n // opens up kzg commitment c(x) at r and makes sure c(r) = s. proof (pi) is in G2 to allow for calculation of Z in G1\\n function openPolynomialAtPoint(\\n BN254.G1Point memory c,\\n BN254.G2Point calldata pi,\\n uint256 r,\\n uint256 s\\n ) internal view returns (bool) {\\n //we use and overwrite z as temporary storage\\n //g1 = (1, 2)\\n BN254.G1Point memory g1Gen = BN254.G1Point({X: 1, Y: 2});\\n //calculate -g1*r = -[r]_1\\n BN254.G1Point memory z = BN254.scalar_mul(BN254.negate(g1Gen), r);\\n\\n //add [x]_1 - [r]_1 = Z and store in first 2 slots of input\\n //CRITIC TODO: SWITCH THESE TO [x]_1 of Powers of Tau!\\n BN254.G1Point memory firstPowerOfTau = BN254.G1Point({\\n X: 15397661830938158195220872607788450164522003659458108417904919983213308643927,\\n Y: 4051901473739185471504766068400292374549287637553596337727654132125147894034\\n });\\n z = BN254.plus(firstPowerOfTau, z);\\n //calculate -g1*s = -[s]_1\\n BN254.G1Point memory negativeS = BN254.scalar_mul(\\n BN254.negate(g1Gen),\\n s\\n );\\n //calculate C-[s]_1\\n BN254.G1Point memory cMinusS = BN254.plus(c, negativeS);\\n\\n //check e(z, pi)e(C-[s]_1, -g2) = 1\\n return BN254.pairing(z, pi, cMinusS, BN254.negGeneratorG2());\\n }\\n\\n function validateDisclosureResponse(\\n DataStoreKZGMetadata memory dskzgMetadata,\\n uint32 chunkNumber,\\n BN254.G1Point calldata interpolationPoly,\\n BN254.G1Point calldata revealProof,\\n BN254.G2Point memory zeroPoly,\\n bytes calldata zeroPolyProof\\n ) internal view returns (bool) {\\n // check that [zeroPoly.x0, zeroPoly.x1, zeroPoly.y0, zeroPoly.y1] is actually the \\\"chunkNumber\\\" leaf\\n // of the zero polynomial Merkle tree\\n\\n {\\n //deterministic assignment of \\\"y\\\" here\\n // @todo\\n require(\\n Merkle.verifyInclusionKeccak(\\n // Merkle proof\\n zeroPolyProof,\\n // Merkle root hash\\n getZeroPolyMerkleRoot(dskzgMetadata.degree),\\n // leaf\\n keccak256(\\n abi.encodePacked(\\n zeroPoly.X[1],\\n zeroPoly.X[0],\\n zeroPoly.Y[1],\\n zeroPoly.Y[0]\\n )\\n ),\\n // index in the Merkle tree\\n getLeadingCosetIndexFromHighestRootOfUnity(\\n chunkNumber,\\n dskzgMetadata.numSys,\\n dskzgMetadata.numPar\\n )\\n ),\\n \\\"Incorrect zero poly merkle proof\\\"\\n );\\n }\\n\\n /**\\n Doing pairing verification e(Pi(s), Z_k(s)).e(C - I, -g2) == 1\\n */\\n //get the commitment to the zero polynomial of multireveal degree\\n\\n // calculate [C]_1 - [I]_1\\n BN254.G1Point memory cMinusI = BN254.plus(\\n dskzgMetadata.c,\\n BN254.negate(interpolationPoly)\\n );\\n\\n //check e(z, pi)e(C-[s]_1, -g2) = 1\\n return BN254.pairing(revealProof, zeroPoly, cMinusI, BN254.negGeneratorG2());\\n }\\n\\n function nonInteractivePolynomialProof(\\n bytes calldata header,\\n uint32 chunkNumber,\\n bytes calldata poly,\\n MultiRevealProof calldata multiRevealProof,\\n BN254.G2Point calldata polyEquivalenceProof\\n ) internal view returns (bool) {\\n DataStoreKZGMetadata\\n memory dskzgMetadata = getDataCommitmentAndMultirevealDegreeAndSymbolBreakdownFromHeader(\\n header\\n );\\n\\n //verify pairing for the commitment to interpolating polynomial\\n require(\\n validateDisclosureResponse(\\n dskzgMetadata,\\n chunkNumber,\\n multiRevealProof.interpolationPoly,\\n multiRevealProof.revealProof,\\n multiRevealProof.zeroPoly,\\n multiRevealProof.zeroPolyProof\\n ),\\n \\\"Reveal failed due to non 1 pairing\\\"\\n );\\n\\n // TODO: verify that this check is correct!\\n // check that degree of polynomial in the header matches the length of the submitted polynomial\\n // i.e. make sure submitted polynomial doesn't contain extra points\\n require(\\n (dskzgMetadata.degree + 1) * 32 == poly.length,\\n \\\"Polynomial must have a 256 bit coefficient for each term\\\"\\n );\\n\\n //Calculating r, the point at which to evaluate the interpolating polynomial\\n uint256 r = uint256(\\n keccak256(\\n abi.encodePacked(\\n keccak256(poly),\\n multiRevealProof.interpolationPoly.X,\\n multiRevealProof.interpolationPoly.Y\\n )\\n )\\n ) % MODULUS;\\n uint256 s = linearPolynomialEvaluation(poly, r);\\n return\\n openPolynomialAtPoint(\\n multiRevealProof.interpolationPoly,\\n polyEquivalenceProof,\\n r,\\n s\\n );\\n }\\n\\n function verifyPolyEquivalenceProof(\\n bytes calldata poly,\\n BN254.G1Point calldata interpolationPoly,\\n BN254.G2Point calldata polyEquivalenceProof\\n ) internal view returns (bool) {\\n //Calculating r, the point at which to evaluate the interpolating polynomial\\n uint256 r = uint256(\\n keccak256(\\n abi.encodePacked(\\n keccak256(poly),\\n interpolationPoly.X,\\n interpolationPoly.Y\\n )\\n )\\n ) % MODULUS;\\n uint256 s = linearPolynomialEvaluation(poly, r);\\n bool ok = openPolynomialAtPoint(\\n interpolationPoly,\\n polyEquivalenceProof,\\n r,\\n s\\n );\\n return ok;\\n }\\n\\n function verifyBatchPolyEquivalenceProof(\\n bytes[] calldata polys,\\n BN254.G1Point[] calldata interpolationPolys,\\n BN254.G2Point calldata polyEquivalenceProof\\n ) internal view returns (bool) {\\n bytes32[] memory rs = new bytes32[](polys.length);\\n //Calculating r, the point at which to evaluate the interpolating polynomial\\n for (uint i = 0; i < polys.length; i++) {\\n rs[i] = keccak256(\\n abi.encodePacked(\\n keccak256(polys[i]),\\n interpolationPolys[i].X,\\n interpolationPolys[i].Y\\n )\\n );\\n }\\n //this is the point to open each polynomial at\\n uint256 r = uint256(keccak256(abi.encodePacked(rs))) % MODULUS;\\n //this is the offset we add to each polynomial to prevent collision\\n //we use array to help with stack\\n uint256[2] memory gammaAndGammaPower;\\n gammaAndGammaPower[0] =\\n uint256(keccak256(abi.encodePacked(rs, uint256(0)))) %\\n MODULUS;\\n gammaAndGammaPower[1] = gammaAndGammaPower[0];\\n //store I1\\n BN254.G1Point memory gammaShiftedCommitmentSum = interpolationPolys[0];\\n //store I1(r)\\n uint256 gammaShiftedEvaluationSum = linearPolynomialEvaluation(\\n polys[0],\\n r\\n );\\n for (uint i = 1; i < interpolationPolys.length; i++) {\\n //gammaShiftedCommitmentSum += gamma^i * Ii\\n gammaShiftedCommitmentSum = BN254.plus(\\n gammaShiftedCommitmentSum,\\n BN254.scalar_mul(interpolationPolys[i], gammaAndGammaPower[1])\\n );\\n //gammaShiftedEvaluationSum += gamma^i * Ii(r)\\n uint256 eval = linearPolynomialEvaluation(polys[i], r);\\n gammaShiftedEvaluationSum = addmod(\\n gammaShiftedEvaluationSum,\\n mulmod(gammaAndGammaPower[1], eval, MODULUS),\\n MODULUS\\n );\\n // gammaPower = gamma^(i+1)\\n gammaAndGammaPower[1] = mulmod(\\n gammaAndGammaPower[0],\\n gammaAndGammaPower[1],\\n MODULUS\\n );\\n }\\n\\n return\\n openPolynomialAtPoint(\\n gammaShiftedCommitmentSum,\\n polyEquivalenceProof,\\n r,\\n gammaShiftedEvaluationSum\\n );\\n }\\n\\n function batchNonInteractivePolynomialProofs(\\n bytes calldata header,\\n uint32 firstChunkNumber,\\n bytes[] calldata polys,\\n MultiRevealProof[] calldata multiRevealProofs,\\n BN254.G2Point calldata polyEquivalenceProof\\n ) internal view returns (bool) {\\n //randomness from each polynomial\\n bytes32[] memory rs = new bytes32[](polys.length);\\n DataStoreKZGMetadata\\n memory dskzgMetadata = getDataCommitmentAndMultirevealDegreeAndSymbolBreakdownFromHeader(\\n header\\n );\\n uint256 numProofs = multiRevealProofs.length;\\n for (uint256 i = 0; i < numProofs; ) {\\n //verify pairing for the commitment to interpolating polynomial\\n require(\\n validateDisclosureResponse(\\n dskzgMetadata,\\n firstChunkNumber + uint32(i),\\n multiRevealProofs[i].interpolationPoly,\\n multiRevealProofs[i].revealProof,\\n multiRevealProofs[i].zeroPoly,\\n multiRevealProofs[i].zeroPolyProof\\n ),\\n \\\"Reveal failed due to non 1 pairing\\\"\\n );\\n\\n // TODO: verify that this check is correct!\\n // check that degree of polynomial in the header matches the length of the submitted polynomial\\n // i.e. make sure submitted polynomial doesn't contain extra points\\n require(\\n dskzgMetadata.degree * 32 == polys[i].length,\\n \\\"Polynomial must have a 256 bit coefficient for each term\\\"\\n );\\n\\n //Calculating r, the point at which to evaluate the interpolating polynomial\\n rs[i] = keccak256(\\n abi.encodePacked(\\n keccak256(polys[i]),\\n multiRevealProofs[i].interpolationPoly.X,\\n multiRevealProofs[i].interpolationPoly.Y\\n )\\n );\\n unchecked {\\n ++i;\\n }\\n }\\n //this is the point to open each polynomial at\\n uint256 r = uint256(keccak256(abi.encodePacked(rs))) % MODULUS;\\n //this is the offset we add to each polynomial to prevent collision\\n //we use array to help with stack\\n uint256[2] memory gammaAndGammaPower;\\n gammaAndGammaPower[0] =\\n uint256(keccak256(abi.encodePacked(rs, uint256(0)))) %\\n MODULUS;\\n gammaAndGammaPower[1] = gammaAndGammaPower[0];\\n //store I1\\n BN254.G1Point memory gammaShiftedCommitmentSum = multiRevealProofs[0]\\n .interpolationPoly;\\n //store I1(r)\\n uint256 gammaShiftedEvaluationSum = linearPolynomialEvaluation(\\n polys[0],\\n r\\n );\\n for (uint i = 1; i < multiRevealProofs.length; i++) {\\n //gammaShiftedCommitmentSum += gamma^i * Ii\\n gammaShiftedCommitmentSum = BN254.plus(\\n gammaShiftedCommitmentSum,\\n BN254.scalar_mul(\\n multiRevealProofs[i].interpolationPoly,\\n gammaAndGammaPower[1]\\n )\\n );\\n //gammaShiftedEvaluationSum += gamma^i * Ii(r)\\n uint256 eval = linearPolynomialEvaluation(polys[i], r);\\n gammaShiftedEvaluationSum = gammaShiftedEvaluationSum = addmod(\\n gammaShiftedEvaluationSum,\\n mulmod(gammaAndGammaPower[1], eval, MODULUS),\\n MODULUS\\n );\\n // gammaPower = gamma^(i+1)\\n gammaAndGammaPower[1] = mulmod(\\n gammaAndGammaPower[0],\\n gammaAndGammaPower[1],\\n MODULUS\\n );\\n }\\n\\n return\\n openPolynomialAtPoint(\\n gammaShiftedCommitmentSum,\\n polyEquivalenceProof,\\n r,\\n gammaShiftedEvaluationSum\\n );\\n }\\n\\n //evaluates the given polynomial \\\"poly\\\" at value \\\"r\\\" and returns the result\\n function linearPolynomialEvaluation(bytes calldata poly, uint256 r)\\n internal\\n pure\\n returns (uint256)\\n {\\n uint256 sum;\\n uint256 length = poly.length;\\n uint256 rPower = 1;\\n for (uint i = 0; i < length; ) {\\n uint256 coefficient = uint256(bytes32(poly[i:i + 32]));\\n sum = addmod(sum, mulmod(coefficient, rPower, MODULUS), MODULUS);\\n rPower = mulmod(rPower, r, MODULUS);\\n i += 32;\\n }\\n return sum;\\n }\\n}\\n\",\"keccak256\":\"0x8a6bc2fd7ee77d3dae36ac5dad0ba9f9bc126f317271e3ad13be61139a8b63f1\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/DataStoreUtils.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\n\\npragma solidity ^0.8.9;\\n\\nimport \\\"./interfaces/IDataLayrServiceManager.sol\\\";\\n\\n/**\\n * @title Library of functions shared across DataLayr.\\n * @author Layr Labs, Inc.\\n */\\nlibrary DataStoreUtils {\\n uint16 public constant BIP_MULTIPLIER = 10000;\\n\\n uint256 public constant BYTES_PER_COEFFICIENT = 31;\\n uint256 public constant BIT_SHIFT_degree = 224;\\n uint256 public constant BIT_SHIFT_numSys = 224;\\n uint256 public constant HEADER_OFFSET_degree = 64;\\n uint256 public constant HEADER_OFFSET_numSys = 68;\\n\\n\\n function getTotalBytes(bytes calldata header, uint32 totalChunks) internal pure returns(uint256) {\\n uint256 numCoefficients;\\n assembly {\\n //numCoefficients = totalChunks * (degree + 1)\\n //NOTE: degree + 1 is the number of coefficients\\n numCoefficients := mul(totalChunks, add(shr(BIT_SHIFT_degree, calldataload(add(header.offset, HEADER_OFFSET_degree))), 1))\\n }\\n return numCoefficients * BYTES_PER_COEFFICIENT;\\n }\\n /// @param header of the datastore that the coding ratio is being retrieved for\\n /// @param totalChunks the total number of chunks expected in this datastore\\n /// @return codingRatio of the datastore in basis points\\n function getCodingRatio(bytes calldata header, uint32 totalChunks) internal pure returns(uint16) {\\n uint32 codingRatio;\\n assembly {\\n //codingRatio = numSys\\n codingRatio := shr(BIT_SHIFT_numSys, calldataload(add(header.offset, HEADER_OFFSET_numSys)))\\n //codingRatio = numSys * BIP_MULTIPLIER / totalChunks\\n codingRatio := div(mul(codingRatio, BIP_MULTIPLIER), totalChunks)\\n }\\n return uint16(codingRatio);\\n }\\n\\n function getDegree(bytes calldata header) internal pure returns (uint32) {\\n uint32 degree;\\n assembly {\\n degree := shr(BIT_SHIFT_degree, calldataload(add(header.offset, HEADER_OFFSET_degree)))\\n }\\n return degree;\\n }\\n\\n /// @notice Finds the `signatoryRecordHash`, used for fraudproofs.\\n function computeSignatoryRecordHash(\\n uint32 globalDataStoreId,\\n bytes32[] memory nonSignerPubkeyHashes,\\n uint256 signedStakeFirstQuorum,\\n uint256 signedStakeSecondQuorum\\n ) internal pure returns (bytes32) {\\n return keccak256(\\n abi.encodePacked(globalDataStoreId, nonSignerPubkeyHashes, signedStakeFirstQuorum, signedStakeSecondQuorum)\\n );\\n }\\n\\n /// @notice Computes the hash of a single DataStore's metadata.\\n function computeDataStoreHash(IDataLayrServiceManager.DataStoreMetadata memory metadata)\\n internal\\n pure\\n returns (bytes32)\\n {\\n bytes32 dsHash = keccak256(\\n abi.encodePacked(\\n metadata.headerHash,\\n metadata.durationDataStoreId,\\n metadata.globalDataStoreId,\\n metadata.referenceBlockNumber,\\n metadata.blockNumber,\\n metadata.fee,\\n metadata.confirmer,\\n metadata.signatoryRecordHash\\n )\\n );\\n return dsHash;\\n }\\n\\n /// @notice uses `abi.encodePacked` to encode a DataStore's metadata into a compressed format\\n function packDataStoreMetadata(IDataLayrServiceManager.DataStoreMetadata memory metadata)\\n internal\\n pure\\n returns (bytes memory)\\n {\\n return (\\n abi.encodePacked(\\n metadata.headerHash,\\n metadata.durationDataStoreId,\\n metadata.globalDataStoreId,\\n metadata.referenceBlockNumber,\\n metadata.blockNumber,\\n metadata.fee,\\n metadata.confirmer,\\n metadata.signatoryRecordHash\\n )\\n );\\n }\\n\\n /// @notice uses `abi.encodePacked` to encode a DataStore's searchData into a compressed format\\n function packDataStoreSearchData(IDataLayrServiceManager.DataStoreSearchData memory searchData)\\n internal\\n pure\\n returns (bytes memory)\\n {\\n return (\\n abi.encodePacked(\\n packDataStoreMetadata(searchData.metadata), searchData.duration, searchData.timestamp, searchData.index\\n )\\n );\\n }\\n\\n // CONSTANTS -- commented out lines are due to inline assembly supporting *only* 'direct number constants' (for now, at least)\\n // OBJECT BIT LENGTHS\\n uint256 internal constant BIT_LENGTH_headerHash = 256;\\n uint256 internal constant BIT_LENGTH_durationDataStoreId = 32;\\n uint256 internal constant BIT_LENGTH_globalDataStoreId = 32;\\n uint256 internal constant BIT_LENGTH_referenceBlockNumber = 32;\\n uint256 internal constant BIT_LENGTH_blockNumber = 32;\\n uint256 internal constant BIT_LENGTH_fee = 96;\\n uint256 internal constant BIT_LENGTH_confirmer = 160;\\n uint256 internal constant BIT_LENGTH_signatoryRecordHash = 256;\\n uint256 internal constant BIT_LENGTH_duration = 8;\\n uint256 internal constant BIT_LENGTH_timestamp = 256;\\n uint256 internal constant BIT_LENGTH_index = 32;\\n\\n // OBJECT BIT SHIFTS FOR READING FROM CALLDATA -- don't bother with using 'shr' if any of these is 0\\n // uint256 internal constant BIT_SHIFT_headerHash = 256 - BIT_LENGTH_headerHash;\\n // uint256 internal constant BIT_SHIFT_durationDataStoreId = 256 - BIT_LENGTH_durationDataStoreId;\\n // uint256 internal constant BIT_SHIFT_globalDataStoreId = 256 - BIT_LENGTH_globalDataStoreId;\\n // uint256 internal constant BIT_SHIFT_referenceBlockNumber = 256 - BIT_LENGTH_referenceBlockNumber;\\n // uint256 internal constant BIT_SHIFT_blockNumber = 256 - BIT_LENGTH_blockNumber;\\n // uint256 internal constant BIT_SHIFT_fee = 256 - BIT_LENGTH_fee;\\n // uint256 internal constant BIT_SHIFT_confirmer = 256 - BIT_LENGTH_confirmer;\\n // uint256 internal constant BIT_SHIFT_signatoryRecordHash = 256 - BIT_LENGTH_signatoryRecordHash;\\n // uint256 internal constant BIT_SHIFT_duration = 256 - BIT_LENGTH_duration;\\n // uint256 internal constant BIT_SHIFT_timestamp = 256 - BIT_LENGTH_timestamp;\\n // uint256 internal constant BIT_SHIFT_index = 256 - BIT_LENGTH_index;\\n uint256 internal constant BIT_SHIFT_headerHash = 0;\\n uint256 internal constant BIT_SHIFT_durationDataStoreId = 224;\\n uint256 internal constant BIT_SHIFT_globalDataStoreId = 224;\\n uint256 internal constant BIT_SHIFT_referenceBlockNumber = 224;\\n uint256 internal constant BIT_SHIFT_blockNumber = 224;\\n uint256 internal constant BIT_SHIFT_fee = 160;\\n uint256 internal constant BIT_SHIFT_confirmer = 96;\\n uint256 internal constant BIT_SHIFT_signatoryRecordHash = 0;\\n uint256 internal constant BIT_SHIFT_duration = 248;\\n uint256 internal constant BIT_SHIFT_timestamp = 0;\\n uint256 internal constant BIT_SHIFT_index = 224;\\n\\n // CALLDATA OFFSETS IN BYTES -- adding 7 and dividing by 8 here is for rounding *up* the bit amounts to bytes amounts\\n // uint256 internal constant CALLDATA_OFFSET_headerHash = 0;\\n // uint256 internal constant CALLDATA_OFFSET_durationDataStoreId = ((BIT_LENGTH_headerHash + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_globalDataStoreId = CALLDATA_OFFSET_durationDataStoreId + ((BIT_LENGTH_durationDataStoreId + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_referenceBlockNumber = CALLDATA_OFFSET_globalDataStoreId + ((BIT_LENGTH_globalDataStoreId + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_blockNumber = CALLDATA_OFFSET_referenceBlockNumber + ((BIT_LENGTH_referenceBlockNumber + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_fee = CALLDATA_OFFSET_blockNumber + ((BIT_LENGTH_blockNumber + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_confirmer = CALLDATA_OFFSET_fee + ((BIT_LENGTH_fee + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_signatoryRecordHash = CALLDATA_OFFSET_confirmer + ((BIT_LENGTH_confirmer + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_duration = CALLDATA_OFFSET_signatoryRecordHash + ((BIT_LENGTH_signatoryRecordHash + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_timestamp = CALLDATA_OFFSET_duration + ((BIT_LENGTH_duration + 7) / 8);\\n // uint256 internal constant CALLDATA_OFFSET_index = CALLDATA_OFFSET_timestamp + ((BIT_LENGTH_timestamp + 7) / 8);\\n uint256 internal constant CALLDATA_OFFSET_headerHash = 0;\\n uint256 internal constant CALLDATA_OFFSET_durationDataStoreId = 32;\\n uint256 internal constant CALLDATA_OFFSET_globalDataStoreId = 36;\\n uint256 internal constant CALLDATA_OFFSET_referenceBlockNumber = 40;\\n uint256 internal constant CALLDATA_OFFSET_blockNumber = 44;\\n uint256 internal constant CALLDATA_OFFSET_fee = 48;\\n uint256 internal constant CALLDATA_OFFSET_confirmer = 60;\\n uint256 internal constant CALLDATA_OFFSET_signatoryRecordHash = 80;\\n uint256 internal constant CALLDATA_OFFSET_duration = 112;\\n uint256 internal constant CALLDATA_OFFSET_timestamp = 113;\\n uint256 internal constant CALLDATA_OFFSET_index = 145;\\n\\n // MEMORY OFFSETS IN BYTES\\n uint256 internal constant MEMORY_OFFSET_headerHash = 0;\\n uint256 internal constant MEMORY_OFFSET_durationDataStoreId = 32;\\n uint256 internal constant MEMORY_OFFSET_globalDataStoreId = 64;\\n uint256 internal constant MEMORY_OFFSET_referenceBlockNumber = 96;\\n uint256 internal constant MEMORY_OFFSET_blockNumber = 128;\\n uint256 internal constant MEMORY_OFFSET_fee = 160;\\n uint256 internal constant MEMORY_OFFSET_confirmer = 192;\\n uint256 internal constant MEMORY_OFFSET_signatoryRecordHash = 224;\\n /**\\n * Here MEMORY_OFFSET_duration is only 32 despite metadata struct being much longer\\n * than 32 bytes. I'm unsure why the memory-offsets work this way, but they do. See usage below.\\n */\\n uint256 internal constant MEMORY_OFFSET_duration = 32;\\n uint256 internal constant MEMORY_OFFSET_timestamp = 64;\\n uint256 internal constant MEMORY_OFFSET_index = 96;\\n\\n /**\\n * @notice Unpacks the packed metadata of a DataStore into a metadata struct.\\n * @param packedMetadata should be in the same form as the output of `packDataStoreMetadata`\\n */\\n function unpackDataStoreMetadata(bytes calldata packedMetadata)\\n internal\\n pure\\n returns (IDataLayrServiceManager.DataStoreMetadata memory metadata)\\n {\\n uint256 pointer;\\n assembly {\\n // fetch offset of `packedMetadata` input in calldata\\n pointer := packedMetadata.offset\\n mstore(\\n // store in the headerHash memory location in `metadata`\\n metadata,\\n // read the headerHash from its calldata position in `packedMetadata`\\n calldataload(pointer)\\n )\\n mstore(\\n // store in the durationDataStoreId memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_durationDataStoreId),\\n // read the durationDataStoreId from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_durationDataStoreId, calldataload(add(pointer, CALLDATA_OFFSET_durationDataStoreId)))\\n )\\n mstore(\\n // store in the globalDataStoreId memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_globalDataStoreId),\\n // read the globalDataStoreId from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_globalDataStoreId, calldataload(add(pointer, CALLDATA_OFFSET_globalDataStoreId)))\\n )\\n mstore(\\n // store in the blockNumber memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_referenceBlockNumber),\\n // read the blockNumber from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_blockNumber, calldataload(add(pointer, CALLDATA_OFFSET_referenceBlockNumber)))\\n )\\n mstore(\\n // store in the blockNumber memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_blockNumber),\\n // read the blockNumber from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_blockNumber, calldataload(add(pointer, CALLDATA_OFFSET_blockNumber)))\\n )\\n mstore(\\n // store in the fee memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_fee),\\n // read the fee from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_fee, calldataload(add(pointer, CALLDATA_OFFSET_fee)))\\n )\\n mstore(\\n // store in the confirmer memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_confirmer),\\n // read the confirmer from its calldata position in `packedMetadata`\\n shr(BIT_SHIFT_confirmer, calldataload(add(pointer, CALLDATA_OFFSET_confirmer)))\\n )\\n mstore(\\n // store in the signatoryRecordHash memory location in `metadata`\\n add(metadata, MEMORY_OFFSET_signatoryRecordHash),\\n // read the signatoryRecordHash from its calldata position in `packedMetadata`\\n calldataload(add(pointer, CALLDATA_OFFSET_signatoryRecordHash))\\n )\\n }\\n return metadata;\\n }\\n\\n /**\\n * @notice Unpacks the packed searchData of a DataStore into a searchData struct.\\n * @param packedSearchData should be in the same form as the output of `packDataStoreSearchData`\\n */\\n function unpackDataStoreSearchData(bytes calldata packedSearchData)\\n internal\\n pure\\n returns (IDataLayrServiceManager.DataStoreSearchData memory searchData)\\n {\\n searchData.metadata = (unpackDataStoreMetadata(packedSearchData));\\n uint256 pointer;\\n assembly {\\n // fetch offset of `packedSearchData` input in calldata\\n pointer := packedSearchData.offset\\n mstore(\\n // store in the duration memory location of `searchData`\\n add(searchData, MEMORY_OFFSET_duration),\\n // read the duration from its calldata position in `packedSearchData`\\n shr(BIT_SHIFT_duration, calldataload(add(pointer, CALLDATA_OFFSET_duration)))\\n )\\n mstore(\\n // store in the timestamp memory location of `searchData`\\n add(searchData, MEMORY_OFFSET_timestamp),\\n // read the timestamp from its calldata position in `packedSearchData`\\n calldataload(add(pointer, CALLDATA_OFFSET_timestamp))\\n )\\n mstore(\\n // store in the index memory location of `searchData`\\n add(searchData, MEMORY_OFFSET_index),\\n // read the index from its calldata position in `packedSearchData`\\n shr(BIT_SHIFT_index, calldataload(add(pointer, CALLDATA_OFFSET_index)))\\n )\\n }\\n return searchData;\\n }\\n}\\n\",\"keccak256\":\"0x27c01c42eea18861fa85d5402186eeb8c1c99b755d6754a1942c57ca0b440de1\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/Merkle.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENCED\\n// Adapted from OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/MerkleProof.sol)\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev These functions deal with verification of Merkle Tree proofs.\\n *\\n * The tree and the proofs can be generated using our\\n * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].\\n * You will find a quickstart guide in the readme.\\n *\\n * WARNING: You should avoid using leaf values that are 64 bytes long prior to\\n * hashing, or use a hash function other than keccak256 for hashing leaves.\\n * This is because the concatenation of a sorted pair of internal nodes in\\n * the merkle tree could be reinterpreted as a leaf value.\\n * OpenZeppelin's JavaScript library generates merkle trees that are safe\\n * against this attack out of the box.\\n */\\nlibrary Merkle {\\n /**\\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\\n * hash matches the root of the tree. The tree is built assuming `leaf` is \\n * the 0 indexed `index`'th leaf from the bottom left of the tree.\\n * \\n * Note this is for a Merkle tree using the keccak/sha3 hash function\\n */\\n function verifyInclusionKeccak(\\n bytes memory proof,\\n bytes32 root,\\n bytes32 leaf,\\n uint256 index\\n ) internal pure returns (bool) {\\n return processInclusionProofKeccak(proof, leaf, index) == root;\\n }\\n\\n /**\\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\\n * hash matches the root of the tree. The tree is built assuming `leaf` is \\n * the 0 indexed `index`'th leaf from the bottom left of the tree.\\n * \\n * _Available since v4.4._\\n * \\n * Note this is for a Merkle tree using the keccak/sha3 hash function\\n */\\n function processInclusionProofKeccak(bytes memory proof, bytes32 leaf, uint256 index) internal pure returns (bytes32) {\\n bytes32 computedHash = leaf;\\n for (uint256 i = 32; i <= proof.length; i+=32) {\\n if(index % 2 == 0) {\\n // if ith bit of index is 0, then computedHash is a left sibling\\n assembly {\\n mstore(0x00, computedHash)\\n mstore(0x20, mload(add(proof, i)))\\n computedHash := keccak256(0x00, 0x40)\\n index := div(index, 2)\\n }\\n } else {\\n // if ith bit of index is 1, then computedHash is a right sibling\\n assembly {\\n mstore(0x00, mload(add(proof, i)))\\n mstore(0x20, computedHash)\\n computedHash := keccak256(0x00, 0x40)\\n index := div(index, 2)\\n } \\n }\\n }\\n return computedHash;\\n }\\n\\n /**\\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\\n * hash matches the root of the tree. The tree is built assuming `leaf` is \\n * the 0 indexed `index`'th leaf from the bottom left of the tree.\\n * \\n * Note this is for a Merkle tree using the sha256 hash function\\n */\\n function verifyInclusionSha256(\\n bytes memory proof,\\n bytes32 root,\\n bytes32 leaf,\\n uint256 index\\n ) internal view returns (bool) {\\n return processInclusionProofSha256(proof, leaf, index) == root;\\n }\\n\\n /**\\n * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\\n * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\\n * hash matches the root of the tree. The tree is built assuming `leaf` is \\n * the 0 indexed `index`'th leaf from the bottom left of the tree.\\n *\\n * _Available since v4.4._\\n * \\n * Note this is for a Merkle tree using the keccak/sha3 hash function\\n */\\n function processInclusionProofSha256(bytes memory proof, bytes32 leaf, uint256 index) internal view returns (bytes32) {\\n bytes32[1] memory computedHash = [leaf];\\n for (uint256 i = 32; i <= proof.length; i+=32) {\\n if(index % 2 == 0) {\\n // if ith bit of index is 0, then computedHash is a left sibling\\n assembly {\\n mstore(0x00, mload(computedHash))\\n mstore(0x20, mload(add(proof, i)))\\n if iszero(staticcall(sub(gas(), 2000), 2, 0x00, 0x40, computedHash, 0x20)) {revert(0, 0)}\\n index := div(index, 2)\\n }\\n } else {\\n // if ith bit of index is 1, then computedHash is a right sibling\\n assembly {\\n mstore(0x00, mload(add(proof, i)))\\n mstore(0x20, mload(computedHash))\\n if iszero(staticcall(sub(gas(), 2000), 2, 0x00, 0x40, computedHash, 0x20)) {revert(0, 0)}\\n index := div(index, 2)\\n } \\n }\\n }\\n return computedHash[0];\\n }\\n\\n /**\\n @notice this function returns the merkle root of a tree created from a set of leaves using sha256 as its hash function\\n @param leaves the leaves of the merkle tree\\n\\n @notice requires the leaves.length is a power of 2\\n */ \\n function merkleizeSha256(\\n bytes32[] memory leaves\\n ) internal pure returns (bytes32) {\\n //there are half as many nodes in the layer above the leaves\\n uint256 numNodesInLayer = leaves.length / 2;\\n //create a layer to store the internal nodes\\n bytes32[] memory layer = new bytes32[](numNodesInLayer);\\n //fill the layer with the pairwise hashes of the leaves\\n for (uint i = 0; i < numNodesInLayer; i++) {\\n layer[i] = sha256(abi.encodePacked(leaves[2*i], leaves[2*i+1]));\\n }\\n //the next layer above has half as many nodes\\n numNodesInLayer /= 2;\\n //while we haven't computed the root\\n while (numNodesInLayer != 0) {\\n //overwrite the first numNodesInLayer nodes in layer with the pairwise hashes of their children\\n for (uint i = 0; i < numNodesInLayer; i++) {\\n layer[i] = sha256(abi.encodePacked(layer[2*i], layer[2*i+1]));\\n }\\n //the next layer above has half as many nodes\\n numNodesInLayer /= 2;\\n }\\n //the first node in the layer is the root\\n return layer[0];\\n }\\n}\",\"keccak256\":\"0x12f01f5daf5a4c185b927ef195dadc2ed51ab5e22a713283cd6b261026ab5930\",\"license\":\"UNLICENCED\"},\"contracts/libraries/eigenda/Parse.sol\":{\"content\":\"pragma solidity ^0.8.9;\\n\\ncontract Parser {\\n /**\\n * @notice Parses data from non-interactive polynomial proofs.\\n * @param polys The non-interactive polynomial proofs themselves\\n * @param startIndex The byte index from which to begin reading data.\\n * @param length The length of data to parse, in bytes.\\n * @return provenString The parsed data.\\n */\\n function parse(bytes[] calldata polys, uint256 startIndex, uint256 length) public pure returns(bytes memory provenString) {\\n // each symbol encodes 31 bytes, and is padded to 32 bytes -- this verifies that we are beginning to parse the data from a non-padded byte\\n require(startIndex % 32 != 0, \\\"Cannot start reading from a padded byte\\\");\\n // index of the `polys` array from which we are currently reading\\n uint256 polyIndex = 0;\\n // keeps track of the index to read inside of the current polynomial\\n uint256 index = startIndex;\\n // continue reading until we reach the desired length\\n while(provenString.length < length) {\\n /**\\n * Read:\\n * 1) until the beginning of the next 32 byte segment OR\\n * 2) however many more bytes there are left in the fraud string\\n * -- whichever amount is the *smallest*\\n */\\n uint256 bytesToRead = min(\\n // the amount of bytes until the end of the current 32 byte segment\\n (32 * ((index / 32) + 1)) - index,\\n // the remaining total bytes to parse\\n length - provenString.length\\n );\\n /**\\n * Append the read bytes to the end of the proven string.\\n * Note that indexing of bytes is inclusive of the first index and exclusive of the second, meaning\\n * that, for example, polys[0][x:x+1] specifies the *single byte* at position x of `polys[0]`, and\\n * polys[0][x:x] will specify an empty byte string.\\n */\\n provenString = abi.encodePacked(provenString, polys[polyIndex][index:index+bytesToRead]);\\n // if we finished reading the current polynomial, then we move onto the next one\\n if (index + bytesToRead == polys[polyIndex].length) {\\n polyIndex++;\\n // skip the first byte of the polynomial since this is zero padding\\n index = 1;\\n // we have read `index + bytesToRead` bytes, and add 1 more to skip the zero-padding byte at the beginning of every 32 bytes\\n } else {\\n index += bytesToRead + 1;\\n }\\n }\\n return provenString;\\n }\\n\\n /// @notice Calculates the minimum of 2 numbers\\n function min(uint256 a, uint256 b) internal pure returns(uint256) {\\n return (a < b) ? a : b;\\n }\\n}\\n\",\"keccak256\":\"0x2eb0953b80b4af4b958ebe45cf58780016cfbce219b09464180490e3edbe71a5\"},\"contracts/libraries/eigenda/interfaces/IDataLayrPaymentManager.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"./IPaymentManager.sol\\\";\\nimport \\\"./IDataLayrServiceManager.sol\\\";\\n\\n/**\\n * @title Minimal interface extension to `IPaymentManager`.\\n * @author Layr Labs, Inc.\\n * @notice Adds a single DataLayr-specific function to the base interface.\\n */\\ninterface IDataLayrPaymentManager is IPaymentManager {\\n /**\\n * @notice Used to perform the final step in a payment challenge, in which the 'trueAmount' is determined and the winner of the challenge is decided.\\n * This function is called by a party after the other party has bisected the challenged payments to a difference of one, i.e., further bisection\\n * is not possible. Once the payments can no longer be bisected, the function resolves the challenge by determining who is wrong.\\n * @param stakeHistoryIndex is used as an input to `registry.checkOperatorInactiveAtBlockNumber` -- see that function's documentation\\n */\\n function respondToPaymentChallengeFinal(\\n address operator,\\n uint256 stakeIndex,\\n uint48 nonSignerIndex,\\n bytes32[] memory nonSignerPubkeyHashes,\\n TotalStakes calldata totalStakesSigned,\\n IDataLayrServiceManager.DataStoreSearchData calldata searchData,\\n uint256 stakeHistoryIndex\\n ) external;\\n}\\n\",\"keccak256\":\"0x477d65f2760f8c0d411c92adebe146380f6c4831676a2c4f56740317609d4e88\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IDataLayrServiceManager.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"./IServiceManager.sol\\\";\\nimport \\\"./IDelayedService.sol\\\";\\nimport \\\"./IEigenLayrDelegation.sol\\\";\\nimport \\\"./IDataLayrPaymentManager.sol\\\";\\n\\ninterface IDataLayrServiceManager is IServiceManager, IDelayedService {\\n //Relevant metadata for a given datastore\\n struct DataStoreMetadata {\\n bytes32 headerHash; // the hash of the header as defined in the contract\\n uint32 durationDataStoreId; // the id of the datastore relative to all other datastores of the same duration\\n uint32 globalDataStoreId; // the id of the datastore relative to all other datastores\\n uint32 referenceBlockNumber; // the block number from which the stakes were taken for the datastore\\n uint32 blockNumber; // the block number at the time of initialization\\n uint96 fee; // the amount of paymentToken paid for the datastore\\n address confirmer; // the address that is allowed to confirm the datastore\\n bytes32 signatoryRecordHash; // the hash of relavent signatory information for payments and fraud proofs\\n }\\n\\n //Stores the data required to index a given datastore's metadata\\n struct DataStoreSearchData {\\n DataStoreMetadata metadata;\\n uint8 duration;\\n uint256 timestamp;\\n uint32 index;\\n }\\n\\n struct SignatoryRecordMinusDataStoreId {\\n bytes32[] nonSignerPubkeyHashes;\\n uint256 signedStakeFirstQuorum;\\n uint256 signedStakeSecondQuorum;\\n }\\n\\n struct DataStoresForDuration {\\n uint32 one_duration;\\n uint32 two_duration;\\n uint32 three_duration;\\n uint32 four_duration;\\n uint32 five_duration;\\n uint32 six_duration;\\n uint32 seven_duration;\\n uint32 dataStoreId;\\n uint32 latestTime;\\n }\\n\\n struct DataStoreHashInputs {\\n bytes32 headerHash;\\n uint32 dataStoreId;\\n uint32 blockNumber;\\n uint256 fee;\\n }\\n\\n /**\\n * @notice This function is used for\\n * - notifying via Ethereum that the disperser has asserted the data blob\\n * into DataLayr and is waiting to obtain quorum of DataLayr operators to sign,\\n * - asserting the metadata corresponding to the data asserted into DataLayr\\n * - escrow the service fees that DataLayr operators will receive from the disperser\\n * on account of their service.\\n *\\n * This function returns the index of the data blob in dataStoreIdsForDuration[duration][block.timestamp]\\n */\\n /**\\n * @param feePayer is the address that will be paying the fees for this datastore. check DataLayrPaymentManager for further details\\n * @param confirmer is the address that must confirm the datastore\\n * @param header is the summary of the data that is being asserted into DataLayr,\\n * type DataStoreHeader struct {\\n * KzgCommit [64]byte\\n * Degree uint32\\n * NumSys uint32\\n * NumPar uint32\\n * OrigDataSize uint32\\n * Disperser [20]byte\\n * LowDegreeProof [64]byte\\n * }\\n * @param duration for which the data has to be stored by the DataLayr operators.\\n * This is a quantized parameter that describes how many factors of DURATION_SCALE\\n * does this data blob needs to be stored. The quantization process comes from ease of\\n * implementation in DataLayrBombVerifier.sol.\\n * @param blockNumber is the block number in Ethereum for which the confirmation will\\n * consult total + operator stake amounts.\\n * -- must not be more than 'BLOCK_STALE_MEASURE' (defined in DataLayr) blocks in past\\n * @return index The index in the array `dataStoreHashesForDurationAtTimestamp[duration][block.timestamp]` at which the DataStore's hash was stored.\\n */\\n function initDataStore(\\n address feePayer,\\n address confirmer,\\n uint8 duration,\\n uint32 blockNumber,\\n uint32 totalOperatorsIndex,\\n bytes calldata header\\n )\\n external\\n returns (uint32);\\n\\n /**\\n * @notice This function is used for\\n * - disperser to notify that signatures on the message, comprising of hash( headerHash ),\\n * from quorum of DataLayr nodes have been obtained,\\n * - check that the aggregate signature is valid,\\n * - and check whether quorum has been achieved or not.\\n */\\n /**\\n * @param data Input to the `checkSignatures` function, which is of the format:\\n * <\\n * bytes32 msgHash,\\n * uint48 index of the totalStake corresponding to the dataStoreId in the 'totalStakeHistory' array of the BLSRegistry\\n * uint32 numberOfNonSigners,\\n * uint256[numberOfSigners][4] pubkeys of nonsigners,\\n * uint32 apkIndex,\\n * uint256[4] apk,\\n * uint256[2] sigma\\n * >\\n */\\n function confirmDataStore(bytes calldata data, DataStoreSearchData memory searchData) external;\\n\\n /// @notice number of leaves in the root tree\\n function numPowersOfTau() external view returns (uint48);\\n\\n /// @notice number of layers in the root tree\\n function log2NumPowersOfTau() external view returns (uint48);\\n\\n /// @notice Unit of measure (in time) for the duration of DataStores\\n function DURATION_SCALE() external view returns (uint256);\\n\\n /// @notice The longest allowed duation of a DataStore, measured in `DURATION_SCALE`\\n function MAX_DATASTORE_DURATION() external view returns (uint8);\\n\\n /// @notice Returns the hash of the `index`th DataStore with the specified `duration` at the specified UTC `timestamp`.\\n function getDataStoreHashesForDurationAtTimestamp(uint8 duration, uint256 timestamp, uint32 index)\\n external\\n view\\n returns (bytes32);\\n\\n /**\\n * @notice returns the number of data stores for the @param duration\\n */\\n function getNumDataStoresForDuration(uint8 duration) external view returns (uint32);\\n\\n /// @notice Collateral token used for placing collateral on challenges & payment commits\\n function collateralToken() external view returns (IERC20);\\n\\n /**\\n * @notice contract used for handling payment challenges\\n */\\n function dataLayrPaymentManager() external view returns (IDataLayrPaymentManager);\\n\\n /**\\n * @notice Checks that the hash of the `index`th DataStore with the specified `duration` at the specified UTC `timestamp` matches the supplied `metadata`.\\n * Returns 'true' if the metadata matches the hash, and 'false' otherwise.\\n */\\n function verifyDataStoreMetadata(uint8 duration, uint256 timestamp, uint32 index, DataStoreMetadata memory metadata) external view returns (bool);\\n}\\n\",\"keccak256\":\"0xf026ccb92b258ca5b6b778b22e96d328d043d3b8aa6709766f687258b392563b\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IDelayedService.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\n/**\\n * @title Interface for a middleware / service that may look at past stake amounts.\\n * @author Layr Labs, Inc.\\n * @notice Specifically, this interface is designed for services that consult stake amounts up to `BLOCK_STALE_MEASURE`\\n * blocks in the past. This may be necessary due to, e.g., network processing & communication delays, or to avoid race conditions\\n * that could be present with coordinating aggregate operator signatures while service operators are registering & de-registering.\\n * @dev To clarify edge cases, the middleware can look `BLOCK_STALE_MEASURE` blocks into the past, i.e. it may trust stakes from the interval\\n * [block.number - BLOCK_STALE_MEASURE, block.number] (specifically, *inclusive* of the block that is `BLOCK_STALE_MEASURE` before the current one)\\n */\\ninterface IDelayedService {\\n /// @notice The maximum amount of blocks in the past that the service will consider stake amounts to still be 'valid'.\\n function BLOCK_STALE_MEASURE() external view returns(uint32); \\n}\\n\",\"keccak256\":\"0x4c9c1d5de05ad392b45244c373d137c7f49436618492ba165b2e3a241dee25cc\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IDelegationTerms.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"./IInvestmentStrategy.sol\\\";\\n\\n/**\\n * @title Abstract interface for a contract that helps structure the delegation relationship.\\n * @author Layr Labs, Inc.\\n * @notice The gas budget provided to this contract in calls from EigenLayr contracts is limited.\\n */\\n//TODO: discuss if we can structure the inputs of these functions better\\ninterface IDelegationTerms {\\n function payForService(IERC20 token, uint256 amount) external payable;\\n\\n function onDelegationWithdrawn(\\n address delegator,\\n IInvestmentStrategy[] memory investorStrats,\\n uint256[] memory investorShares\\n ) external;\\n\\n // function onDelegationReceived(\\n // address delegator,\\n // uint256[] memory investorShares\\n // ) external;\\n\\n function onDelegationReceived(\\n address delegator,\\n IInvestmentStrategy[] memory investorStrats,\\n uint256[] memory investorShares\\n ) external;\\n}\\n\",\"keccak256\":\"0x5e7db2c8e3cb2cf7d7a19f8f7be16efacfd1b709dfcd2f5bd2b32174812acc37\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IEigenLayrDelegation.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"./IDelegationTerms.sol\\\";\\n\\n/**\\n * @title The interface for the primary delegation contract for EigenLayr.\\n * @author Layr Labs, Inc.\\n * @notice This is the contract for delegation in EigenLayr. The main functionalities of this contract are\\n * - enabling anyone to register as an operator in EigenLayr\\n * - allowing new operators to provide a DelegationTerms-type contract, which may mediate their interactions with stakers who delegate to them\\n * - enabling any staker to delegate its stake to the operator of its choice\\n * - enabling a staker to undelegate its assets from an operator (performed as part of the withdrawal process, initiated through the InvestmentManager)\\n */\\ninterface IEigenLayrDelegation {\\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(IDelegationTerms 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 delegateToBySignature(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 in EigenLayer.\\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 DelegationTerms of the `operator`, which may mediate their interactions with stakers who delegate to them.\\n function delegationTerms(address operator) external view returns (IDelegationTerms);\\n\\n /// @notice returns the total number of shares in `strategy` that are delegated to `operator`.\\n function operatorShares(address operator, IInvestmentStrategy strategy) external view returns (uint256);\\n\\n /**\\n * @notice Increases the `staker`'s delegated shares in `strategy` by `shares, typically called when the staker has further deposits into EigenLayr\\n * @dev Callable only by the InvestmentManager\\n */\\n function increaseDelegatedShares(address staker, IInvestmentStrategy strategy, uint256 shares) external;\\n\\n /**\\n * @notice Decreases the `staker`'s delegated shares in each entry of `strategies` by its respective `shares[i]`, typically called when the staker withdraws from EigenLayr\\n * @dev Callable only by the InvestmentManager\\n */\\n function decreaseDelegatedShares(\\n address staker,\\n IInvestmentStrategy[] calldata strategies,\\n uint256[] calldata shares\\n ) external;\\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\",\"keccak256\":\"0x963866de65476336650f81dca389e9fc21aa7cb801776fb47376bcebac79e0c7\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IInvestmentStrategy.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/**\\n * @title Minimal interface for an `InvestmentStrategy` contract.\\n * @author Layr Labs, Inc.\\n * @notice Custom `InvestmentStrategy` implementations may expand extensively on this interface.\\n */\\ninterface IInvestmentStrategy {\\n /**\\n * @notice Used to deposit tokens into this InvestmentStrategy\\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 investmentManager contract. It is invoked inside of the investmentManager's\\n * `depositIntoStrategy` function, and individual share balances are recorded in the investmentManager as well.\\n * @return newShares is the number of new shares issued at the current exchange ratio.\\n */\\n function deposit(IERC20 token, uint256 amount) external returns (uint256);\\n\\n /**\\n * @notice Used to withdraw tokens from this InvestmentStrategy, 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 investmentManager contract. It is invoked inside of the investmentManager's\\n * other functions, and individual share balances are recorded in the investmentManager 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 strategy.\\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 strategy shares\\n * @dev Implementation for these functions in particular may vary signifcantly for different strategies\\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 strategy. 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 strategy.\\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 strategies\\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 strategy.\\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 strategy shares\\n * @dev Implementation for these functions in particular may vary signifcantly for different strategies\\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 strategy. 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 InvestmentStrategy\\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\":\"0x69eb667cc856ee1fe783243b6db21a43a9dadd29bf6761727b334fca4366bceb\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IPaymentManager.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\n\\n/**\\n * @title Interface for a `PaymentManager` contract.\\n * @author Layr Labs, Inc.\\n */\\ninterface IPaymentManager {\\n enum DissectionType {\\n INVALID,\\n FIRST_HALF,\\n SECOND_HALF\\n }\\n enum PaymentStatus {\\n REDEEMED,\\n COMMITTED,\\n CHALLENGED\\n }\\n enum ChallengeStatus {\\n RESOLVED,\\n OPERATOR_TURN,\\n CHALLENGER_TURN,\\n OPERATOR_TURN_ONE_STEP,\\n CHALLENGER_TURN_ONE_STEP\\n }\\n\\n /**\\n * @notice used for storing information on the most recent payment made to the operator\\n */\\n struct Payment {\\n // taskNumber starting from which payment is being claimed\\n uint32 fromTaskNumber;\\n // taskNumber until which payment is being claimed (exclusive)\\n uint32 toTaskNumber;\\n // recording when the payment will optimistically be confirmed; used for fraudproof period\\n uint32 confirmAt;\\n // payment for range [fromTaskNumber, toTaskNumber)\\n /// @dev max 1.3e36, keep in mind for token decimals\\n uint96 amount;\\n /**\\n * @notice The possible statuses are:\\n * - 0: REDEEMED,\\n * - 1: COMMITTED,\\n * - 2: CHALLENGED\\n */\\n PaymentStatus status;\\n uint256 collateral; //account for if collateral changed\\n }\\n\\n /**\\n * @notice used for storing information on the payment challenge as part of the interactive process\\n */\\n struct PaymentChallenge {\\n // operator whose payment claim is being challenged,\\n address operator;\\n // the entity challenging with the fraudproof\\n address challenger;\\n // address of the service manager contract\\n address serviceManager;\\n // the TaskNumber from which payment has been computed\\n uint32 fromTaskNumber;\\n // the TaskNumber until which payment has been computed to\\n uint32 toTaskNumber;\\n // reward amount the challenger claims is for the first half of tasks\\n uint96 amount1;\\n // reward amount the challenger claims is for the second half of tasks\\n uint96 amount2;\\n // used for recording the time when challenge was created\\n uint32 settleAt; // when committed, used for fraudproof period\\n // indicates the status of the challenge\\n /**\\n * @notice The possible statuses are:\\n * - 0: RESOLVED,\\n * - 1: operator turn (dissection),\\n * - 2: challenger turn (dissection),\\n * - 3: operator turn (one step),\\n * - 4: challenger turn (one step)\\n */\\n ChallengeStatus status;\\n }\\n\\n struct TotalStakes {\\n uint256 signedStakeFirstQuorum;\\n uint256 signedStakeSecondQuorum;\\n }\\n\\n /**\\n * @notice deposit one-time fees by the `msg.sender` with this contract to pay for future tasks of this middleware\\n * @param onBehalfOf could be the `msg.sender` themselves, or a different address for whom `msg.sender` is depositing these future fees\\n * @param amount is amount of futures fees being deposited\\n */\\n function depositFutureFees(address onBehalfOf, uint256 amount) external;\\n\\n /// @notice Allows the `allowed` address to spend up to `amount` of the `msg.sender`'s funds that have been deposited in this contract\\n function setAllowance(address allowed, uint256 amount) external;\\n\\n /// @notice Used for deducting the fees from the payer to the middleware\\n function payFee(address initiator, address payer, uint256 feeAmount) external;\\n\\n /**\\n * @notice Modifies the `paymentFraudproofCollateral` amount.\\n * @param _paymentFraudproofCollateral The new value for `paymentFraudproofCollateral` to take.\\n */\\n function setPaymentFraudproofCollateral(uint256 _paymentFraudproofCollateral) external;\\n\\n /**\\n * @notice This is used by an operator to make a claim on the amount that they deserve for their service from their last payment until `toTaskNumber`\\n * @dev Once this payment is recorded, a fraud proof period commences during which a challenger can dispute the proposed payment.\\n */\\n function commitPayment(uint32 toTaskNumber, uint96 amount) external;\\n\\n /**\\n * @notice Called by an operator to redeem a payment that they previously 'committed' to by calling `commitPayment`.\\n * @dev This function can only be called after the challenge window for the payment claim has completed.\\n */\\n function redeemPayment() external;\\n\\n /**\\n * @notice This function is called by a fraud prover to challenge a payment, initiating an interactive-type fraudproof.\\n * @param operator is the operator against whose payment claim the fraudproof is being made\\n * @param amount1 is the reward amount the challenger in that round claims is for the first half of tasks\\n * @param amount2 is the reward amount the challenger in that round claims is for the second half of tasks\\n *\\n */\\n function initPaymentChallenge(address operator, uint96 amount1, uint96 amount2) external;\\n\\n /**\\n * @notice Perform a single bisection step in an existing interactive payment challenge.\\n * @param operator The middleware operator who was challenged (used to look up challenge details)\\n * @param secondHalf If true, then the caller wishes to challenge the amount claimed as payment in the *second half* of the\\n * previous bisection step. If false then the *first half* is indicated instead.\\n * @param amount1 The amount that the caller asserts the operator is entitled to, for the first half *of the challenged half* of the previous bisection.\\n * @param amount2 The amount that the caller asserts the operator is entitled to, for the second half *of the challenged half* of the previous bisection.\\n */\\n function performChallengeBisectionStep(address operator, bool secondHalf, uint96 amount1, uint96 amount2)\\n external;\\n\\n /// @notice resolve an existing PaymentChallenge for an operator\\n function resolveChallenge(address operator) external;\\n\\n /**\\n * @notice Challenge window for submitting fraudproof in the case of an incorrect payment claim by a registered operator.\\n */\\n function paymentFraudproofInterval() external view returns (uint256);\\n\\n /**\\n * @notice Specifies the payment that has to be made as a collateral for fraudproof during payment challenges.\\n */\\n function paymentFraudproofCollateral() external view returns (uint256);\\n\\n /// @notice the ERC20 token that will be used by the disperser to pay the service fees to middleware nodes.\\n function paymentToken() external view returns (IERC20);\\n\\n /// @notice Collateral token used for placing collateral on challenges & payment commits\\n function collateralToken() external view returns (IERC20);\\n\\n /// @notice Returns the ChallengeStatus for the `operator`'s payment claim.\\n function getChallengeStatus(address operator) external view returns (ChallengeStatus);\\n\\n /// @notice Returns the 'amount1' for the `operator`'s payment claim.\\n function getAmount1(address operator) external view returns (uint96);\\n\\n /// @notice Returns the 'amount2' for the `operator`'s payment claim.\\n function getAmount2(address operator) external view returns (uint96);\\n\\n /// @notice Returns the 'toTaskNumber' for the `operator`'s payment claim.\\n function getToTaskNumber(address operator) external view returns (uint48);\\n\\n /// @notice Returns the 'fromTaskNumber' for the `operator`'s payment claim.\\n function getFromTaskNumber(address operator) external view returns (uint48);\\n\\n /// @notice Returns the task number difference for the `operator`'s payment claim.\\n function getDiff(address operator) external view returns (uint48);\\n\\n /// @notice Returns the active collateral of the `operator` placed on their payment claim.\\n function getPaymentCollateral(address) external view returns (uint256);\\n}\\n\",\"keccak256\":\"0xa8bd72043644c95c85bc7588cac18d6421cfd3c8b1dcb0df37d7adcdec209c99\",\"license\":\"UNLICENSED\"},\"contracts/libraries/eigenda/interfaces/IServiceManager.sol\":{\"content\":\"// SPDX-License-Identifier: UNLICENSED\\npragma solidity ^0.8.9;\\n\\nimport \\\"@openzeppelin/contracts/token/ERC20/IERC20.sol\\\";\\nimport \\\"./IEigenLayrDelegation.sol\\\";\\n\\n/**\\n * @title Interface for a `ServiceManager`-type contract.\\n * @author Layr Labs, Inc.\\n */\\n// TODO: provide more functions for this spec\\ninterface IServiceManager {\\n /// @notice Returns the current 'taskNumber' for the middleware\\n function taskNumber() external view returns (uint32);\\n\\n /// @notice Permissioned function that causes the ServiceManager to freeze the operator on EigenLayer, through a call to the Slasher contract\\n function freezeOperator(address operator) external;\\n\\n /// @notice Permissioned function to have the ServiceManager forward a call to the slasher, recording an initial stake update (on operator registration)\\n function recordFirstStakeUpdate(address operator, uint32 serveUntil) external;\\n\\n /// @notice Permissioned function to have the ServiceManager forward a call to the slasher, recording a stake update\\n function recordStakeUpdate(address operator, uint32 updateBlock, uint32 serveUntil, uint256 prevElement) external;\\n\\n /// @notice Permissioned function to have the ServiceManager forward a call to the slasher, recording a final stake update (on operator deregistration)\\n function recordLastStakeUpdateAndRevokeSlashingAbility(address operator, uint32 serveUntil) external;\\n\\n /// @notice Collateral token used for placing collateral on challenges & payment commits\\n function collateralToken() external view returns (IERC20);\\n\\n /// @notice The Delegation contract of EigenLayer.\\n function eigenLayrDelegation() external view returns (IEigenLayrDelegation);\\n\\n /// @notice Returns the `latestTime` until which operators must serve.\\n function latestTime() external view returns (uint32);\\n\\n function owner() external view returns (address);\\n}\",\"keccak256\":\"0x483b41fa37b67c958253e48c12372fac3ac09b63d47d5337392677fcb83ecf1f\",\"license\":\"UNLICENSED\"}},\"version\":1}", + "bytecode": "0x60806040523480156200001157600080fd5b506200001c62000022565b620000e4565b600054610100900460ff16156200008f5760405162461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b606482015260840160405180910390fd5b60005460ff9081161015620000e2576000805460ff191660ff9081179091556040519081527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b565b6144dd80620000f46000396000f3fe608060405234801561001057600080fd5b50600436106102325760003560e01c8063728cdbca11610130578063afab4ac5116100b8578063f24950291161007c578063f249502914610542578063f2a8f12414610555578063f2fde38b1461055e578063f7db979514610571578063ff2e07491461058457600080fd5b8063afab4ac5146104b2578063b537c4c7146104c5578063c8fff01b146104e5578063c96c0d38146104f8578063d7fbc2e21461052f57600080fd5b8063927f2032116100ff578063927f20321461042b57806392f30a45146104345780639495de4014610483578063990fca66146104965780639a71e29c1461049f57600080fd5b8063728cdbca146103ec578063758b8147146103ff5780638bea6cae146104125780638da5cb5b1461041a57600080fd5b80633c762984116101be5780635c1bba38116101825780635c1bba38146103945780635d42ffb7146103bf5780635e4a3056146103c85780635e8b3f2d146103db578063715018a6146103e457600080fd5b80633c762984146103065780634618ed871461030f57806346b2eb9b146103225780634a4232de1461032a57806359cb63911461033d57600080fd5b80631f944c8f116102055780631f944c8f146102855780632e64b4c0146102ae5780632e72866b146102c1578063301b39ab146102e157806332c58f7a146102f357600080fd5b806302d777de14610237578063060ee9a41461024c5780630a33202e1461025f57806315fda73714610272575b600080fd5b61024a6102453660046137be565b6105a4565b005b61024a61025a3660046137be565b6106c3565b61024a61026d3660046137be565b6107a0565b61024a61028036600461398f565b61086c565b6102986102933660046139f9565b610f48565b6040516102a59190613aab565b60405180910390f35b61024a6102bc366004613ade565b6110d7565b6102d46102cf366004613ade565b611106565b6040516102a59190613b2f565b609a545b6040519081526020016102a5565b61024a6103013660046137be565b611191565b6102e5609d5481565b61024a61031d366004613bc6565b61124f565b6102986116e2565b61024a610338366004613ade565b6116fe565b61038461034b366004613ade565b609e6020526000908152604090205463ffffffff808216916401000000008104821691600160401b82041690600160601b900460ff1684565b6040516102a59493929190613c61565b6097546103a7906001600160a01b031681565b6040516001600160a01b0390911681526020016102a5565b6102e5609b5481565b61024a6103d6366004613c94565b611766565b6102e560995481565b61024a611a35565b61024a6103fa366004613d22565b611a49565b60a2546103a7906001600160a01b031681565b609b546102e5565b6033546001600160a01b03166103a7565b6102e560a35481565b610466610442366004613d81565b609f6020526000908152604090208054600182015460029092015490919060ff1683565b6040805193845260208401929092521515908201526060016102a5565b61024a610491366004613ade565b611bad565b6102e5609a5481565b61024a6104ad366004613ade565b611c15565b61024a6104c03660046137be565b611dc4565b6102e56104d3366004613d81565b60a06020526000908152604090205481565b61024a6104f33660046137be565b611ece565b61050b610506366004613d81565b611fa5565b604080518251815260208084015190820152918101511515908201526060016102a5565b61024a61053d366004613ade565b61200f565b6098546103a7906001600160a01b031681565b6102e5609c5481565b61024a61056c3660046137be565b612077565b61024a61057f366004613ade565b6120f0565b6102e5610592366004613ade565b60a46020526000908152604090205481565b6097546001600160a01b031633146105d75760405162461bcd60e51b81526004016105ce90613d9e565b60405180910390fd5b6001600160a01b0381166106615760405162461bcd60e51b8152602060048201526044602482018190527f757064617465446174614c6179724d616e61676572416464726573733a205f64908201527f6174614d616e6167654164647265737320697320746865207a65726f206164646064820152637265737360e01b608482015260a4016105ce565b609880546001600160a01b038381166001600160a01b031983168117909355604080519190921680825260208201939093527f7dc2cdf7b45e41e53cedea7a30250d948690332e87d86f5eff45acd42ab259a291015b60405180910390a15050565b6097546001600160a01b031633146106ed5760405162461bcd60e51b81526004016105ce90613d9e565b6001600160a01b03811661077f5760405162461bcd60e51b815260206004820152604d60248201527f72656d6f7665467261756450726f6f66416464726573733a2072656d6f76654660448201527f7261756450726f6f66416464726573733a20616464726573732069732074686560648201526c207a65726f206164647265737360981b608482015260a4016105ce565b6001600160a01b0316600090815260a160205260409020805460ff19169055565b6097546001600160a01b031633146107ca5760405162461bcd60e51b81526004016105ce90613d9e565b6001600160a01b03811661077f5760405162461bcd60e51b815260206004820152605760248201527f756e617661696c61626c65467261756450726f6f66416464726573733a20756e60448201527f617661696c61626c65467261756450726f6f66416464726573733a206164647260648201527f65737320697320746865207a65726f2061646472657373000000000000000000608482015260a4016105ce565b33600090815260a1602052604090205460ff166108f15760405162461bcd60e51b815260206004820152603a60248201527f70726f766546726175643a204f6e6c792066726175642070726f6f662077686960448201527f7465206c6973742063616e206368616c6c656e6765206461746100000000000060648201526084016105ce565b6000848152609e602090815260408083208151608081018352815463ffffffff80821683526401000000008204811695830195909552600160401b81049094169281019290925290916060830190600160601b900460ff16600281111561095a5761095a613af7565b600281111561096b5761096b613af7565b905250905060018160600151600281111561098857610988613af7565b14801561099e575042816040015163ffffffff16115b610a005760405162461bcd60e51b815260206004820152602d60248201527f526f6c6c757053746f7265206d75737420626520636f6d6d697474656420616e60448201526c19081d5b98dbdb999a5c9b5959609a1b60648201526084016105ce565b8251610a0b9061216a565b6098546020850151604080870151606088015191516376c1607760e11b815260ff9093166004840152602483015263ffffffff1660448201526001600160a01b039091169063ed82c0ee9060640160206040518083038186803b158015610a7157600080fd5b505afa158015610a85573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610aa99190613de3565b14610b095760405162461bcd60e51b815260206004820152602a60248201527f70726f766546726175643a206d6574616461746120707265696d616765206973604482015269081a5b98dbdc9c9958dd60b21b60648201526084016105ce565b806020015163ffffffff1683600001516040015163ffffffff1614610ba15760405162461bcd60e51b815260206004820152604260248201527f7365616368446174612773206461746173746f7265206964206973206e6f742060448201527f636f6e73697374656e74207769746820676976656e20726f6c6c75702073746f606482015261726560f01b608482015260a4016105ce565b610bab8280613dfc565b604051610bb9929190613e43565b60405190819003902083515114610c2d5760405162461bcd60e51b815260206004820152603260248201527f646973636c6f737572652070726f6f66732068656164657268617368207072656044820152711a5b5859d9481a5cc81a5b98dbdc9c9958dd60721b60648201526084016105ce565b610c6d610c3a8380613dfc565b610c4a6040860160208701613d81565b610c576040870187613e53565b610c646060890189613e53565b89608001612236565b610cb95760405162461bcd60e51b815260206004820152601d60248201527f646973636c6f737572652070726f6f66732061726520696e76616c696400000060448201526064016105ce565b6000610ccd610cc88480613dfc565b6127cb565b905063ffffffff8116610ce36040850185613e53565b9050610cf56040860160208701613d81565b63ffffffff16610d059190613eb3565b1115610d6a5760405162461bcd60e51b815260206004820152602e60248201527f43616e206f6e6c792070726f766520646174612066726f6d207468652073797360448201526d74656d61746963206368756e6b7360901b60648201526084016105ce565b6000610d9c610d7c6040860186613e53565b886040518060600160405280603281526020016144566032913951610f48565b90506040518060600160405280603281526020016144566032913951815114610e385760405162461bcd60e51b815260206004820152604260248201527f50617273696e67206572726f722c2070726f76656e20737472696e672069732060448201527f646966666572656e74206c656e677468207468616e20667261756420737472696064820152616e6760f01b608482015260a4016105ce565b6040518060600160405280603281526020016144566032913980519060200120818051906020012014610ead5760405162461bcd60e51b815260206004820152601d60248201527f70726f76656e20737472696e6720213d20667261756420737472696e6700000060448201526064016105ce565b6000878152609e60209081526040808320805460ff60601b1916600160611b179055875181015163ffffffff908116808552609f8452828520548a518401519092168552938290206001015482518c8152938401949094529082015260608101919091527fca227c67a02028763083580d42e8bdef4bb49c393068d05983421cd7a4a2a5be906080015b60405180910390a150505050505050565b6060610f55602084613ee1565b610fb15760405162461bcd60e51b815260206004820152602760248201527f43616e6e6f742073746172742072656164696e672066726f6d206120706164646044820152666564206279746560c81b60648201526084016105ce565b6000835b83835110156110cd57600061100082610fcf602082613ef5565b610fda906001613eb3565b610fe5906020613f09565b610fef9190613f28565b8551610ffb9088613f28565b6127da565b90508388888581811061101557611015613f3f565b90506020028101906110279190613dfc565b84906110338583613eb3565b9261104093929190613f55565b60405160200161105293929190613f7f565b604051602081830303815290604052935087878481811061107557611075613f3f565b90506020028101906110879190613dfc565b90506110938284613eb3565b14156110af57826110a381613fa7565b935050600191506110c7565b6110ba816001613eb3565b6110c49083613eb3565b91505b50610fb5565b5050949350505050565b6097546001600160a01b031633146111015760405162461bcd60e51b81526004016105ce90613d9e565b609b55565b61110e6136c8565b6000828152609e60209081526040918290208251608081018452815463ffffffff80821683526401000000008204811694830194909452600160401b810490931693810193909352906060830190600160601b900460ff16600281111561117757611177613af7565b600281111561118857611188613af7565b90525092915050565b6097546001600160a01b031633146111bb5760405162461bcd60e51b81526004016105ce90613d9e565b6001600160a01b03811661122b5760405162461bcd60e51b815260206004820152603160248201527f736574467261756450726f6f66416464726573733a206164647265737320697360448201527020746865207a65726f206164647265737360781b60648201526084016105ce565b6001600160a01b0316600090815260a160205260409020805460ff19166001179055565b6097546001600160a01b031633146112795760405162461bcd60e51b81526004016105ce90613d9e565b8484116112e45760405162461bcd60e51b815260206004820152603360248201527f636f6e6669726d446174613a20656e644c32426c6f636b206d757374206d6f7260448201527265207468616e2073746172744c32426c6f636b60681b60648201526084016105ce565b855160409081015163ffffffff166000908152609f6020908152908290208251606081018452815480825260018301549382019390935260029091015460ff161515928101929092528614801561133e5750848160200151145b8015611351575081151581604001511515145b61136d5760405162461bcd60e51b81526004016105ce90613fc2565b865160409081015163ffffffff16600090815260a06020522054600019146113a75760405162461bcd60e51b81526004016105ce90613fc2565b6098546040516358942e7360e01b81526001600160a01b03909116906358942e73906113db908c908c908c90600401614079565b600060405180830381600087803b1580156113f557600080fd5b505af1158015611409573d6000803e3d6000fd5b50505050816115845760408051608081018252885182015163ffffffff90811682528951830151166020820152609c5490918201906114489042613eb3565b63ffffffff16815260200160019052609d546000908152609e602090815260409182902083518154928501519385015163ffffffff908116600160401b0263ffffffff60401b199582166401000000000267ffffffffffffffff1990951691909216179290921792831682178155606084015190929091839160ff60601b1990911664ffffffffff60401b1990911617600160601b8360028111156114ef576114ef613af7565b02179055505050609b859055609d8054885160409081015163ffffffff16600090815260a06020529081208290557fc7c0900be05d2a0ad0f77852eb975d9e862d1db0a2238617dd0f77854782f672929061154983613fa7565b909155508851604090810151815163ffffffff93841681529216602083015281018890526060810187905260800160405180910390a16116d7565b60405180608001604052808563ffffffff16815260200188600001516040015163ffffffff168152602001609c54426115bd9190613eb3565b63ffffffff168152602001600190526000848152609e602090815260409182902083518154928501519385015163ffffffff908116600160401b0263ffffffff60401b199582166401000000000267ffffffffffffffff1990951691909216179290921792831682178155606084015190929091839160ff60601b1990911664ffffffffff60401b1990911617600160601b83600281111561166157611661613af7565b021790555050875160409081015163ffffffff908116600090815260a06020908152908390208790558a518301518351888152921690820152908101889052606081018790527fc7c0900be05d2a0ad0f77852eb975d9e862d1db0a2238617dd0f77854782f67291506080015b60405180910390a15b505050505050505050565b6040518060600160405280603281526020016144566032913981565b6097546001600160a01b031633146117285760405162461bcd60e51b81526004016105ce90613d9e565b609d80549082905560408051828152602081018490527f84d29a10fee283002b5c77232e8d38a21f0a3f16190de1693f837ac60bfbe2bb91016106b7565b6097546001600160a01b031633146117905760405162461bcd60e51b81526004016105ce90613d9e565b8383116117f95760405162461bcd60e51b815260206004820152603160248201527f73746f7265446174613a20656e644c32426c6f636b206d757374206d6f7265206044820152707468616e2073746172744c32426c6f636b60781b60648201526084016105ce565b60995461180c63ffffffff871643613f28565b1061186b5760405162461bcd60e51b815260206004820152602960248201527f73746f7265446174613a207374616b65732074616b656e2066726f6d20746f6f604482015268206c6f6e672061676f60b81b60648201526084016105ce565b609854604080516372d18e8d60e01b815290516000926001600160a01b0316916372d18e8d916004808301926020929190829003018186803b1580156118b057600080fd5b505afa1580156118c4573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906118e89190614149565b9050609860009054906101000a90046001600160a01b03166001600160a01b031663dcf49ea733308a8a888f8f6040518863ffffffff1660e01b81526004016119379796959493929190614166565b602060405180830381600087803b15801561195157600080fd5b505af1158015611965573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906119899190614149565b5060408051606081018252868152602080820187815285151583850190815263ffffffff86166000908152609f84528581209451855591516001850155516002909301805460ff19169315159390931790925560a09052206000199055816119f157609a8490555b6040805163ffffffff83168152602081018790529081018590527fa99ca06ac3461399088feac88ec48dc5a47d61c3b6839eab20146f2c4ee53584906060016116ce565b611a3d6127f2565b611a47600061284c565b565b600054610100900460ff1615808015611a695750600054600160ff909116105b80611a835750303b158015611a83575060005460ff166001145b611ae65760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084016105ce565b6000805460ff191660011790558015611b09576000805461ff0019166101001790555b611b1161289e565b609780546001600160a01b03808a166001600160a01b0319928316179092556098805489841690831617905560a28054928816929091169190911790556099849055609c839055609a829055609b8290558015611ba4576000805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb384740249890602001610f37565b50505050505050565b6097546001600160a01b03163314611bd75760405162461bcd60e51b81526004016105ce90613d9e565b609a80549082905560408051828152602081018490527fd81cc97cc11cd748d88c14364de569a7d07c4aeaea3b5a0525ca4d504ec548a991016106b7565b60a2546001600160a01b03163314611ca15760405162461bcd60e51b815260206004820152604360248201527f7375626d69745265526f6c6c5570496e666f3a204f6e6c79207468652072652060448201527f7375626d69747465722063616e207375626d697420726520726f6c6c7570206460648201526261746160e81b608482015260a4016105ce565b6000818152609e602090815260408083208151608081018352815463ffffffff80821683526401000000008204811695830195909552600160401b81049094169281019290925290916060830190600160601b900460ff166002811115611d0a57611d0a613af7565b6002811115611d1b57611d1b613af7565b905250602081015190915063ffffffff1615611dc05760a38054600090815260a46020526040812084905581547fee84ab0752d66e31e484f6855689d7067ecd900a6c5a198a2908f74e583e7d57929091611d7583613fa7565b909155506020838101805163ffffffff9081166000908152609f84526040808220549351909216815281902060010154815194855292840187905283015260608201526080016106b7565b5050565b6097546001600160a01b03163314611dee5760405162461bcd60e51b81526004016105ce90613d9e565b6001600160a01b038116611e745760405162461bcd60e51b815260206004820152604160248201527f75706461746552655375626d6974746572416464726573733a205f726553756260448201527f6d69747465724164647265737320697320746865207a65726f206164647265736064820152607360f81b608482015260a4016105ce565b60a280546001600160a01b038381166001600160a01b031983168117909355604080519190921680825260208201939093527f84756a63b0b7003b255a685f66d60e972c20c2dd95acbc14c2e52fc1e91e6b3791016106b7565b611ed66127f2565b6001600160a01b038116611f4b5760405162461bcd60e51b815260206004820152603660248201527f75706461746553657175656e636572416464726573733a205f73657175656e63604482015275657220697320746865207a65726f206164647265737360501b60648201526084016105ce565b609780546001600160a01b038381166001600160a01b031983168117909355604080519190921680825260208201939093527fe12a0ecca55e8af7ccbe853ac12e9d45a828685168f3e7c75edd4381b26e317191016106b7565b611fcb604051806060016040528060008152602001600081526020016000151581525090565b5063ffffffff166000908152609f60209081526040918290208251606081018452815481526001820154928101929092526002015460ff1615159181019190915290565b6097546001600160a01b031633146120395760405162461bcd60e51b81526004016105ce90613d9e565b609c80549082905560408051828152602081018490527f52d7ac606181dee95c39c1f26eaf69c99d262a01c7665cdd62497c29989694ab91016106b7565b61207f6127f2565b6001600160a01b0381166120e45760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016105ce565b6120ed8161284c565b50565b6097546001600160a01b0316331461211a5760405162461bcd60e51b81526004016105ce90613d9e565b805b609d5481101561215a576000818152609e6020526040902080546cffffffffffffffffffffffffff191690558061215281613fa7565b91505061211c565b50609d556001609a819055609b55565b600080826000015183602001518460400151856060015186608001518760a001518860c001518960e0015160405160200161221798979695949392919097885260e096871b6001600160e01b031990811660208a015295871b8616602489015293861b851660288801529190941b909216602c85015260a09290921b6001600160a01b031916603084015260601b6bffffffffffffffffffffffff1916603c830152605082015260700190565b60408051601f1981840301815291905280516020909101209392505050565b6000808567ffffffffffffffff811115612252576122526137d9565b60405190808252806020026020018201604052801561227b578160200160208202803683370190505b50905060006123088b8b6040805160c08101825260006080820181815260a0830182905282526020820181905291810182905260608101919091525050604080518082018252823581526020838101358183015282516080810184529182528383013560e090811c918301919091526044840135811c92820192909252604890920135901c606082015290565b90508460005b818110156125cc576123de83612324838e6141b0565b8a8a8581811061233657612336613f3f565b905060200281019061234891906141d8565b8b8b8681811061235a5761235a613f3f565b905060200281019061236c91906141d8565b6040018c8c8781811061238157612381613f3f565b905060200281019061239391906141d8565b6080018036038101906123a69190614249565b8d8d888181106123b8576123b8613f3f565b90506020028101906123ca91906141d8565b6123d990610100810190613dfc565b6128cd565b6124355760405162461bcd60e51b815260206004820152602260248201527f52657665616c206661696c65642064756520746f206e6f6e20312070616972696044820152616e6760f01b60648201526084016105ce565b89898281811061244757612447613f3f565b90506020028101906124599190613dfc565b90508360200151602061246c91906142a6565b65ffffffffffff16146124e75760405162461bcd60e51b815260206004820152603860248201527f506f6c796e6f6d69616c206d757374206861766520612032353620626974206360448201527f6f656666696369656e7420666f722065616368207465726d000000000000000060648201526084016105ce565b8989828181106124f9576124f9613f3f565b905060200281019061250b9190613dfc565b604051612519929190613e43565b604051809103902088888381811061253357612533613f3f565b905060200281019061254591906141d8565b3589898481811061255857612558613f3f565b905060200281019061256a91906141d8565b60405161259193929160209081013591019283526020830191909152604082015260600190565b604051602081830303815290604052805190602001208482815181106125b9576125b9613f3f565b602090810291909101015260010161230e565b506000600080516020614488833981519152846040516020016125ef9190614307565b6040516020818303038152906040528051906020012060001c6126129190613ee1565b905061261c6136f0565b60008051602061448883398151915285600060405160200161263f929190614313565b6040516020818303038152906040528051906020012060001c6126629190613ee1565b808252602082015260008989828161267c5761267c613f3f565b905060200281019061268e91906141d8565b61269e903681900381019061432c565b905060006126d08d8d60008181106126b8576126b8613f3f565b90506020028101906126ca9190613dfc565b86612a24565b905060015b8a8110156127a957612727836127228e8e858181106126f6576126f6613f3f565b905060200281019061270891906141d8565b612718903681900381019061432c565b6020880151612aa6565b612b3d565b925060006127588f8f8481811061274057612740613f3f565b90506020028101906127529190613dfc565b88612a24565b905060008051602061448883398151915280828760016020020151098408602086015186519194506000805160206144888339815191529109602086015250806127a181613fa7565b9150506126d5565b506127b6828a8684612bd1565b97505050505050505098975050505050505050565b604482013560e01c5b92915050565b60008183106127e957816127eb565b825b9392505050565b6033546001600160a01b03163314611a475760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016105ce565b603380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600054610100900460ff166128c55760405162461bcd60e51b81526004016105ce9061435e565b611a47612cac565b600061298883838080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250505060208b015161291e915065ffffffffffff16612cdc565b86516020808201519151818a01518083015190516040805194850195909552938301919091526060820152608081019190915260a0016040516020818303038152906040528051906020012061297d8b8d604001518e60600151612fd5565b63ffffffff16613136565b6129d45760405162461bcd60e51b815260206004820181905260248201527f496e636f7272656374207a65726f20706f6c79206d65726b6c652070726f6f6660448201526064016105ce565b87516000906129f4906127226129ef368b90038b018b61432c565b61314e565b9050612a17612a083688900388018861432c565b8683612a1261320d565b6132cd565b9998505050505050505050565b600080836001825b82811015612a9a576000888289612a44826020613eb3565b92612a5193929190613f55565b612a5a916143a9565b905060008051602061448883398151915280848309860894506000805160206144888339815191528784099250612a92602083613eb3565b915050612a2c565b50919695505050505050565b6040805180820190915260008082526020820152612ac261370e565b835181526020808501519082015260408082018490526000908360608460076107d05a03fa9050808015612af557612af7565bfe5b5080612b355760405162461bcd60e51b815260206004820152600d60248201526c1958cb5b5d5b0b59985a5b1959609a1b60448201526064016105ce565b505092915050565b6040805180820190915260008082526020820152612b5961372c565b835181526020808501518183015283516040808401919091529084015160608301526000908360808460066107d05a03fa9050808015612af5575080612b355760405162461bcd60e51b815260206004820152600d60248201526c1958cb5859190b59985a5b1959609a1b60448201526064016105ce565b60408051808201909152600181526002602082015260009081612bfc612bf68361314e565b86612aa6565b604080518082019091527f220ac48bb1f91fd93f502a3d0caa077ac70e0af8819b9d8fa26a168a2c558a5781527f08f54b82af08ceaf7cd5f180bac94870f6d8100a9c9afa9dd09a4491653891126020820152909150612c5c8183612b3d565b91506000612c72612c6c8561314e565b87612aa6565b90506000612c808a83612b3d565b9050612c9e84612c95368c90038c018c614249565b83612a1261320d565b9a9950505050505050505050565b600054610100900460ff16612cd35760405162461bcd60e51b81526004016105ce9061435e565b611a473361284c565b600080612ce88361353a565b905080612d1757507fe82cea94884b1b895ea0742840a3b19249a723810fd1b04d8564d675b0a416f192915050565b8060011415612d4857507f4843774a80fc8385b31024f5bd18b42e62de439206ab9468d42d826796d41f6792915050565b8060021415612d7957507f092d3e5f87f5293e7ab0cc2ca6b0b5e4adb5e0011656544915f7cea34e69e5ab92915050565b8060031415612daa57507f494b208540ec8624fbbb3f2c64ffccdaf6253f8f4e50c0d93922d88195b0775592915050565b8060041415612ddb57507ffdb44b84a82893cfa0e37a97f09ffc4298ad5e62be1bea1d03320ae836213d2292915050565b8060051415612e0c57507f3f50cb08231d2a76853ba9dbb20dad45a1b75c57cdaff6223bfe069752cff3d492915050565b8060061415612e3d57507fbb39eebd8138eefd5802a49d571e65b3e0d4e32277c28fbf5fbca66e7fb0431092915050565b8060071415612e6e57507ff0a39b513e11fa80cbecbf352f69310eddd5cd03148768e0e9542bd600b133ec92915050565b8060081415612e9f57507f038cca2238865414efb752cc004fffec9e6069b709f495249cdf36efbd5952f692915050565b8060091415612ed057507f2a26b054ed559dd255d8ac9060ebf6b95b768d87de767f8174ad2f9a4e48dd0192915050565b80600a1415612f0157507f1fe180d0bc4ff7c69fefa595b3b5f3c284535a280f6fdcf69b20770d1e20e1fc92915050565b80600b1415612f3257507f60e34ad57c61cd6fdd8177437c30e4a30334e63d7683989570cf27020efc820192915050565b80600c1415612f6357507feda2417e770ddbe88f083acf06b6794dfb76301314a32bd0697440d76f6cd9cc92915050565b80600d1415612f9457507f8cbe9b8cf92ce70e3bec8e1e72a0f85569017a7e43c3db50e4a5badb8dea7ce892915050565b60405162461bcd60e51b81526020600482015260166024820152754c6f67206e6f7420696e2076616c69642072616e676560501b60448201526064016105ce565b600080612fe283856141b0565b90506000612ff58563ffffffff166135a0565b9050600061300386846143c7565b63ffffffff1615613015576001613018565b60005b60ff1661302587856143ea565b61302f91906141b0565b9050600061304b613040838561440d565b63ffffffff166135a0565b90508663ffffffff168863ffffffff16101561308d578061306c828a6135cd565b6130789061010061440d565b61308291906143ea565b9450505050506127eb565b6130978784614430565b6130a19082614430565b63ffffffff168863ffffffff1610156130d3578061306c81856130c48b8d614430565b6130ce91906141b0565b6135cd565b60405162461bcd60e51b815260206004820152603260248201527f43616e6e6f7420637265617465206e756d626572206f66206672616d6520686960448201527167686572207468616e20706f737369626c6560701b60648201526084016105ce565b60008361314486858561360c565b1495945050505050565b6040805180820190915260008082526020820152815115801561317357506020820151155b15613191575050604080518082019091526000808252602082015290565b6040518060400160405280836000015181526020017f30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd4784602001516131d69190613ee1565b613200907f30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd47613f28565b905292915050565b919050565b61321561374a565b50604080516080810182527f198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c28183019081527f1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed6060830152815281518083019092527f275dc4a288d1afb3cbb1ac09187524c7db36395df7be3b99e673b13a075a65ec82527f1d9befcd05a5323e6da4d435f3b617cdb3af83285c2df711ef39c01571827f9d60208381019190915281019190915290565b6040805180820182528581526020808201859052825180840190935285835282018390526000916132fc61376a565b60005b60028110156134c1576000613315826006613f09565b905084826002811061332957613329613f3f565b6020020151518361333b836000613eb3565b600c811061334b5761334b613f3f565b602002015284826002811061336257613362613f3f565b602002015160200151838260016133799190613eb3565b600c811061338957613389613f3f565b60200201528382600281106133a0576133a0613f3f565b60200201515151836133b3836002613eb3565b600c81106133c3576133c3613f3f565b60200201528382600281106133da576133da613f3f565b60200201515160016020020151836133f3836003613eb3565b600c811061340357613403613f3f565b602002015283826002811061341a5761341a613f3f565b60200201516020015160006002811061343557613435613f3f565b602002015183613446836004613eb3565b600c811061345657613456613f3f565b602002015283826002811061346d5761346d613f3f565b60200201516020015160016002811061348857613488613f3f565b602002015183613499836005613eb3565b600c81106134a9576134a9613f3f565b602002015250806134b981613fa7565b9150506132ff565b506134ca613789565b60006020826101808560086107d05a03fa9050808015612af557508061352a5760405162461bcd60e51b81526020600482015260156024820152741c185a5c9a5b99cb5bdc18dbd9194b59985a5b1959605a1b60448201526064016105ce565b5051151598975050505050505050565b60008082116135815760405162461bcd60e51b8152602060048201526013602482015272131bd9c81b5d5cdd081899481919599a5b9959606a1b60448201526064016105ce565b60005b600183821c146127d4578061359881613fa7565b915050613584565b600060015b82816001901b10156135c357806135bb81613fa7565b9150506135a5565b6001901b92915050565b6000806135df8463ffffffff1661353a565b6135ea906020614430565b90508063ffffffff166135fc8461367a565b63ffffffff16901c949350505050565b60008260205b8551811161367157613625600285613ee1565b6136465781600052808601516020526040600020915060028404935061365f565b8086015160005281602052604060002091506002840493505b61366a602082613eb3565b9050613612565b50949350505050565b600080805b60208110156136c1576001811b84811663ffffffff16156136ae576136a582601f613f28565b6001901b831792505b50806136b981613fa7565b91505061367f565b5092915050565b604080516080810182526000808252602082018190529181018290529060608201905b905290565b60405180604001604052806002906020820280368337509192915050565b60405180606001604052806003906020820280368337509192915050565b60405180608001604052806004906020820280368337509192915050565b604051806040016040528061375d6136f0565b81526020016136eb6136f0565b604051806101800160405280600c906020820280368337509192915050565b60405180602001604052806001906020820280368337509192915050565b80356001600160a01b038116811461320857600080fd5b6000602082840312156137d057600080fd5b6127eb826137a7565b634e487b7160e01b600052604160045260246000fd5b6040516080810167ffffffffffffffff81118282101715613812576138126137d9565b60405290565b604051610100810167ffffffffffffffff81118282101715613812576138126137d9565b6040805190810167ffffffffffffffff81118282101715613812576138126137d9565b63ffffffff811681146120ed57600080fd5b80356132088161385f565b80356bffffffffffffffffffffffff8116811461320857600080fd5b803560ff8116811461320857600080fd5b60008183036101608112156138bd57600080fd5b6138c56137ef565b9150610100808212156138d757600080fd5b6138df613818565b91508335825260208401356138f38161385f565b602083015261390460408501613871565b604083015261391560608501613871565b606083015261392660808501613871565b608083015261393760a0850161387c565b60a083015261394860c085016137a7565b60c083015260e084013560e0830152818352613965818501613898565b6020840152505061012082013560408201526139846101408301613871565b606082015292915050565b6000806000806101c085870312156139a657600080fd5b84359350602085013592506139be86604087016138a9565b91506101a085013567ffffffffffffffff8111156139db57600080fd5b850161010081880312156139ee57600080fd5b939692955090935050565b60008060008060608587031215613a0f57600080fd5b843567ffffffffffffffff80821115613a2757600080fd5b818701915087601f830112613a3b57600080fd5b813581811115613a4a57600080fd5b8860208260051b8501011115613a5f57600080fd5b6020928301999098509187013596604001359550909350505050565b60005b83811015613a96578181015183820152602001613a7e565b83811115613aa5576000848401525b50505050565b6020815260008251806020840152613aca816040850160208701613a7b565b601f01601f19169190910160400192915050565b600060208284031215613af057600080fd5b5035919050565b634e487b7160e01b600052602160045260246000fd5b60038110613b2b57634e487b7160e01b600052602160045260246000fd5b9052565b600060808201905063ffffffff8084511683528060208501511660208401528060408501511660408401525060608301516136c16060840182613b0d565b60008083601f840112613b7f57600080fd5b50813567ffffffffffffffff811115613b9757600080fd5b602083019150836020828501011115613baf57600080fd5b9250929050565b8035801515811461320857600080fd5b600080600080600080600080610220898b031215613be357600080fd5b883567ffffffffffffffff811115613bfa57600080fd5b613c068b828c01613b6d565b9099509750613c1a90508a60208b016138a9565b955061018089013594506101a089013593506101c0890135613c3b8161385f565b92506101e08901359150613c526102008a01613bb6565b90509295985092959890939650565b63ffffffff858116825284811660208301528316604082015260808101613c8b6060830184613b0d565b95945050505050565b60008060008060008060008060e0898b031215613cb057600080fd5b883567ffffffffffffffff811115613cc757600080fd5b613cd38b828c01613b6d565b9099509750613ce6905060208a01613898565b95506040890135613cf68161385f565b9450606089013593506080890135925060a0890135613d148161385f565b9150613c5260c08a01613bb6565b60008060008060008060c08789031215613d3b57600080fd5b613d44876137a7565b9550613d52602088016137a7565b9450613d60604088016137a7565b9350606087013592506080870135915060a087013590509295509295509295565b600060208284031215613d9357600080fd5b81356127eb8161385f565b60208082526025908201527f4f6e6c79207468652073657175656e6365722063616e20646f2074686973206160408201526431ba34b7b760d91b606082015260800190565b600060208284031215613df557600080fd5b5051919050565b6000808335601e19843603018112613e1357600080fd5b83018035915067ffffffffffffffff821115613e2e57600080fd5b602001915036819003821315613baf57600080fd5b8183823760009101908152919050565b6000808335601e19843603018112613e6a57600080fd5b83018035915067ffffffffffffffff821115613e8557600080fd5b6020019150600581901b3603821315613baf57600080fd5b634e487b7160e01b600052601160045260246000fd5b60008219821115613ec657613ec6613e9d565b500190565b634e487b7160e01b600052601260045260246000fd5b600082613ef057613ef0613ecb565b500690565b600082613f0457613f04613ecb565b500490565b6000816000190483118215151615613f2357613f23613e9d565b500290565b600082821015613f3a57613f3a613e9d565b500390565b634e487b7160e01b600052603260045260246000fd5b60008085851115613f6557600080fd5b83861115613f7257600080fd5b5050820193919092039150565b60008451613f91818460208901613a7b565b8201838582376000930192835250909392505050565b6000600019821415613fbb57613fbb613e9d565b5060010190565b60208082526062908201527f636f6e6669726d446174613a20446174612073746f726520656974686572207760408201527f6173206e6f7420696e697469616c697a65642062792074686520726f6c6c757060608201527f20636f6e74726163742c206f7220697320616c726561647920636f6e6669726d608082015261195960f21b60a082015260c00190565b81835281816020850137506000828201602090810191909152601f909101601f19169091010190565b600061018080835261408e8184018688614050565b915050825180516020840152602081015163ffffffff8082166040860152806040840151166060860152806060840151166080860152505060808101516140dd60a085018263ffffffff169052565b5060a08101516bffffffffffffffffffffffff1660c0848101919091528101516001600160a01b031660e0808501919091520151610100830152602083015160ff16610120830152604083015161014083015260609092015163ffffffff166101609091015292915050565b60006020828403121561415b57600080fd5b81516127eb8161385f565b6001600160a01b0388811682528716602082015260ff8616604082015263ffffffff85811660608301528416608082015260c060a08201819052600090612a179083018486614050565b600063ffffffff8083168185168083038211156141cf576141cf613e9d565b01949350505050565b6000823561011e198336030181126141ef57600080fd5b9190910192915050565b600082601f83011261420a57600080fd5b61421261383c565b80604084018581111561422457600080fd5b845b8181101561423e578035845260209384019301614226565b509095945050505050565b60006080828403121561425b57600080fd5b6040516040810181811067ffffffffffffffff8211171561427e5761427e6137d9565b60405261428b84846141f9565b815261429a84604085016141f9565b60208201529392505050565b600065ffffffffffff808316818516818304811182151516156142cb576142cb613e9d565b02949350505050565b60008151602080840160005b838110156142fc578151875295820195908201906001016142e0565b509495945050505050565b60006127eb82846142d4565b600061431f82856142d4565b9283525050602001919050565b60006040828403121561433e57600080fd5b61434661383c565b82358152602083013560208201528091505092915050565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b803560208310156127d457600019602084900360031b1b1692915050565b600063ffffffff808416806143de576143de613ecb565b92169190910692915050565b600063ffffffff8084168061440157614401613ecb565b92169190910492915050565b600063ffffffff808316818516818304811182151516156142cb576142cb613e9d565b600063ffffffff8381169083168181101561444d5761444d613e9d565b03939250505056fe2d2d5468697320697320612062616420737472696e672e204e6f626f64792073617973207468697320737472696e672e2d2d30644e72e131a029b85045b68181585d2833e84879b9709143e1f593f0000001a2646970667358221220b09199499b73161d5ebb82ac5f8b4f2e901aebb86eab86c1c53fff7982a5160964736f6c63430008090033", + "deployedBytecode": "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", "devdoc": { "kind": "dev", "methods": { diff --git a/packages/contracts/deployments/mainnet/Proxy__BVM_EigenDataLayrChain.json b/packages/contracts/deployments/mainnet/Proxy__BVM_EigenDataLayrChain.json index 3a6ce1c3c..60546b659 100644 --- a/packages/contracts/deployments/mainnet/Proxy__BVM_EigenDataLayrChain.json +++ b/packages/contracts/deployments/mainnet/Proxy__BVM_EigenDataLayrChain.json @@ -1,5 +1,5 @@ { - "address": "0x729967093AA8E67c359Fd78f271C2E540CAcbd5E", + "address": "0x50Fa427235C7C8cAA4A0C21b5009f5a0d015B23A", "abi": [ { "inputs": [ @@ -146,81 +146,81 @@ "type": "receive" } ], - "transactionHash": "0x5dccdb73ecbb461222b0a030fbfdcfb95e193a1675731f30049f9fe15232052f", + "transactionHash": "0x2b2bda7f01a3baec5d0e7b369e36172365d35b9eb9137c074d3260308c838ce8", "receipt": { "to": null, "from": "0x2A2954F3989a83Cc43DD58B0f038D5F276f21333", - "contractAddress": "0x729967093AA8E67c359Fd78f271C2E540CAcbd5E", - "transactionIndex": 14, + "contractAddress": "0x50Fa427235C7C8cAA4A0C21b5009f5a0d015B23A", + "transactionIndex": 4, "gasUsed": "797453", - "logsBloom": "0x00000000000000000000000000000000400000000000000000800000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000002000001000000000000000000000000000000000000020000000000000000000800000000800000010000000000000000400000000000000000000000000000000000000000000080000000000000800000000020000000000000000000040400080000000000008000100000000000000000000020008000000000000000040000000000000400000000000000000020000000000000000000000000000000000000000000000000000000080000000000", - "blockHash": "0xc2f458983377fead699000944837315f32713cea7e0c81fe69bf7540d63b6d87", - "transactionHash": "0x5dccdb73ecbb461222b0a030fbfdcfb95e193a1675731f30049f9fe15232052f", + "logsBloom": "0x00000000000000000000000000000000400000000000000000800000000000000000000000000000000000008000000000000000000080000000000000000000000000080000000000000000001002000001000000000000000000000000000000000000020000000000000000000800000000800000000000000000000000400000000000000002000000000000000000000000000080000000000000800000000020000000000000000000000400080000000000020000000000000000000000000020000000000000000002040000000000000400000000000000000020000000000000000000000000000000000000000000000000000000000000000000", + "blockHash": "0x32debc525c92acdb87e76e47ba51b9633864d621eb9def1adc5526b945b247e1", + "transactionHash": "0x2b2bda7f01a3baec5d0e7b369e36172365d35b9eb9137c074d3260308c838ce8", "logs": [ { - "transactionIndex": 14, - "blockNumber": 17578165, - "transactionHash": "0x5dccdb73ecbb461222b0a030fbfdcfb95e193a1675731f30049f9fe15232052f", - "address": "0x729967093AA8E67c359Fd78f271C2E540CAcbd5E", + "transactionIndex": 4, + "blockNumber": 17604795, + "transactionHash": "0x2b2bda7f01a3baec5d0e7b369e36172365d35b9eb9137c074d3260308c838ce8", + "address": "0x50Fa427235C7C8cAA4A0C21b5009f5a0d015B23A", "topics": [ "0xbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b", - "0x0000000000000000000000004215bfd622ea609c0da9d3d53dfec26cddae324c" + "0x000000000000000000000000df401d4229fc6ca52238f7e55a04fa8ebc24c55a" ], "data": "0x", - "logIndex": 82, - "blockHash": "0xc2f458983377fead699000944837315f32713cea7e0c81fe69bf7540d63b6d87" + "logIndex": 11, + "blockHash": "0x32debc525c92acdb87e76e47ba51b9633864d621eb9def1adc5526b945b247e1" }, { - "transactionIndex": 14, - "blockNumber": 17578165, - "transactionHash": "0x5dccdb73ecbb461222b0a030fbfdcfb95e193a1675731f30049f9fe15232052f", - "address": "0x729967093AA8E67c359Fd78f271C2E540CAcbd5E", + "transactionIndex": 4, + "blockNumber": 17604795, + "transactionHash": "0x2b2bda7f01a3baec5d0e7b369e36172365d35b9eb9137c074d3260308c838ce8", + "address": "0x50Fa427235C7C8cAA4A0C21b5009f5a0d015B23A", "topics": [ "0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000002a2954f3989a83cc43dd58b0f038d5f276f21333" ], "data": "0x", - "logIndex": 83, - "blockHash": "0xc2f458983377fead699000944837315f32713cea7e0c81fe69bf7540d63b6d87" + "logIndex": 12, + "blockHash": "0x32debc525c92acdb87e76e47ba51b9633864d621eb9def1adc5526b945b247e1" }, { - "transactionIndex": 14, - "blockNumber": 17578165, - "transactionHash": "0x5dccdb73ecbb461222b0a030fbfdcfb95e193a1675731f30049f9fe15232052f", - "address": "0x729967093AA8E67c359Fd78f271C2E540CAcbd5E", + "transactionIndex": 4, + "blockNumber": 17604795, + "transactionHash": "0x2b2bda7f01a3baec5d0e7b369e36172365d35b9eb9137c074d3260308c838ce8", + "address": "0x50Fa427235C7C8cAA4A0C21b5009f5a0d015B23A", "topics": [ "0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498" ], "data": "0x0000000000000000000000000000000000000000000000000000000000000001", - "logIndex": 84, - "blockHash": "0xc2f458983377fead699000944837315f32713cea7e0c81fe69bf7540d63b6d87" + "logIndex": 13, + "blockHash": "0x32debc525c92acdb87e76e47ba51b9633864d621eb9def1adc5526b945b247e1" }, { - "transactionIndex": 14, - "blockNumber": 17578165, - "transactionHash": "0x5dccdb73ecbb461222b0a030fbfdcfb95e193a1675731f30049f9fe15232052f", - "address": "0x729967093AA8E67c359Fd78f271C2E540CAcbd5E", + "transactionIndex": 4, + "blockNumber": 17604795, + "transactionHash": "0x2b2bda7f01a3baec5d0e7b369e36172365d35b9eb9137c074d3260308c838ce8", + "address": "0x50Fa427235C7C8cAA4A0C21b5009f5a0d015B23A", "topics": [ "0x7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f" ], "data": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000004e59e778a0fb77fbb305637435c62faed9aed40f", - "logIndex": 85, - "blockHash": "0xc2f458983377fead699000944837315f32713cea7e0c81fe69bf7540d63b6d87" + "logIndex": 14, + "blockHash": "0x32debc525c92acdb87e76e47ba51b9633864d621eb9def1adc5526b945b247e1" } ], - "blockNumber": 17578165, - "cumulativeGasUsed": "2893852", + "blockNumber": 17604795, + "cumulativeGasUsed": "1137571", "status": 1, "byzantium": true }, "args": [ - "0x4215bFD622ea609C0da9d3d53DFEc26CDDAe324C", + "0xDF401d4229Fc6cA52238f7e55A04FA8EBc24C55a", "0x4e59e778a0fb77fBb305637435C62FaeD9aED40f", "0x728cdbca0000000000000000000000002f40d796917ffb642bd2e2bdd2c762a5e40fd7490000000000000000000000005bd63a7ecc13b955c4f57e3f12a64c10263c14c1000000000000000000000000630e93130809c4ace55249229ee6b043b929a9ad00000000000000000000000000000000000000000000000000000000000001f40000000000000000000000000000000000000000000000000000000000000e100000000000000000000000000000000000000000000000000000000000000001" ], "numDeployments": 1, - "solcInputHash": "27d28af861d021ebdc26d0374c908fe2", + "solcInputHash": "d035642f5a990d3e19917cab0da6926d", "metadata": "{\"compiler\":{\"version\":\"0.8.9+commit.e5eed63a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_logic\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"_data\",\"type\":\"bytes\"}],\"stateMutability\":\"payable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"previousAdmin\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"AdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"beacon\",\"type\":\"address\"}],\"name\":\"BeaconUpgraded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"implementation\",\"type\":\"address\"}],\"name\":\"Upgraded\",\"type\":\"event\"},{\"stateMutability\":\"payable\",\"type\":\"fallback\"},{\"inputs\":[],\"name\":\"admin\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"admin_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newAdmin\",\"type\":\"address\"}],\"name\":\"changeAdmin\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"implementation\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"implementation_\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"}],\"name\":\"upgradeTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newImplementation\",\"type\":\"address\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"upgradeToAndCall\",\"outputs\":[],\"stateMutability\":\"payable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"details\":\"This contract implements a proxy that is upgradeable by an admin. To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector clashing], which can potentially be used in an attack, this contract uses the https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two things that go hand in hand: 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if that call matches one of the admin functions exposed by the proxy itself. 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the implementation. If the admin tries to call a function on the implementation it will fail with an error that says \\\"admin cannot fallback to proxy target\\\". These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due to sudden errors when trying to call a function from the proxy implementation. Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way, you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.\",\"kind\":\"dev\",\"methods\":{\"admin()\":{\"details\":\"Returns the current admin. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\"},\"changeAdmin(address)\":{\"details\":\"Changes the admin of the proxy. Emits an {AdminChanged} event. NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.\"},\"constructor\":{\"details\":\"Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.\"},\"implementation()\":{\"details\":\"Returns the current implementation. NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}. TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\"},\"upgradeTo(address)\":{\"details\":\"Upgrade the implementation of the proxy. NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\"},\"upgradeToAndCall(address,bytes)\":{\"details\":\"Upgrade the implementation of the proxy, and then call a function from the new implementation as specified by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the proxied contract. NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/chugsplash/TransparentUpgradeableProxy.sol\":\"TransparentUpgradeableProxy\"},\"evmVersion\":\"london\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"../Proxy.sol\\\";\\nimport \\\"./ERC1967Upgrade.sol\\\";\\n\\n/**\\n * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an\\n * implementation address that can be changed. This address is stored in storage in the location specified by\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the\\n * implementation behind the proxy.\\n */\\ncontract ERC1967Proxy is Proxy, ERC1967Upgrade {\\n /**\\n * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.\\n *\\n * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded\\n * function call, and allows initializating the storage of the proxy like a Solidity constructor.\\n */\\n constructor(address _logic, bytes memory _data) payable {\\n assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\\\"eip1967.proxy.implementation\\\")) - 1));\\n _upgradeToAndCall(_logic, _data, false);\\n }\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _implementation() internal view virtual override returns (address impl) {\\n return ERC1967Upgrade._getImplementation();\\n }\\n}\\n\",\"keccak256\":\"0xca2eb23a188f213d914fad982985d07e491dbc9960a387d4469bfce5c48911b1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.2;\\n\\nimport \\\"../beacon/IBeacon.sol\\\";\\nimport \\\"../../utils/Address.sol\\\";\\nimport \\\"../../utils/StorageSlot.sol\\\";\\n\\n/**\\n * @dev This abstract contract provides getters and event emitting update functions for\\n * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.\\n *\\n * _Available since v4.1._\\n *\\n * @custom:oz-upgrades-unsafe-allow delegatecall\\n */\\nabstract contract ERC1967Upgrade {\\n // This is the keccak-256 hash of \\\"eip1967.proxy.rollback\\\" subtracted by 1\\n bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;\\n\\n /**\\n * @dev Storage slot with the address of the current implementation.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.implementation\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n\\n /**\\n * @dev Emitted when the implementation is upgraded.\\n */\\n event Upgraded(address indexed implementation);\\n\\n /**\\n * @dev Returns the current implementation address.\\n */\\n function _getImplementation() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 implementation slot.\\n */\\n function _setImplementation(address newImplementation) private {\\n require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n }\\n\\n /**\\n * @dev Perform implementation upgrade\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeTo(address newImplementation) internal {\\n _setImplementation(newImplementation);\\n emit Upgraded(newImplementation);\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCall(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _upgradeTo(newImplementation);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(newImplementation, data);\\n }\\n }\\n\\n /**\\n * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.\\n *\\n * Emits an {Upgraded} event.\\n */\\n function _upgradeToAndCallSecure(\\n address newImplementation,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n address oldImplementation = _getImplementation();\\n\\n // Initial upgrade and setup call\\n _setImplementation(newImplementation);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(newImplementation, data);\\n }\\n\\n // Perform rollback test if not already in progress\\n StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);\\n if (!rollbackTesting.value) {\\n // Trigger rollback using upgradeTo from the new implementation\\n rollbackTesting.value = true;\\n Address.functionDelegateCall(\\n newImplementation,\\n abi.encodeWithSignature(\\\"upgradeTo(address)\\\", oldImplementation)\\n );\\n rollbackTesting.value = false;\\n // Check rollback was effective\\n require(oldImplementation == _getImplementation(), \\\"ERC1967Upgrade: upgrade breaks further upgrades\\\");\\n // Finally reset to the new implementation and log the upgrade\\n _upgradeTo(newImplementation);\\n }\\n }\\n\\n /**\\n * @dev Storage slot with the admin of the contract.\\n * This is the keccak-256 hash of \\\"eip1967.proxy.admin\\\" subtracted by 1, and is\\n * validated in the constructor.\\n */\\n bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;\\n\\n /**\\n * @dev Emitted when the admin account has changed.\\n */\\n event AdminChanged(address previousAdmin, address newAdmin);\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _getAdmin() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new address in the EIP1967 admin slot.\\n */\\n function _setAdmin(address newAdmin) private {\\n require(newAdmin != address(0), \\\"ERC1967: new admin is the zero address\\\");\\n StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n */\\n function _changeAdmin(address newAdmin) internal {\\n emit AdminChanged(_getAdmin(), newAdmin);\\n _setAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.\\n * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.\\n */\\n bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;\\n\\n /**\\n * @dev Emitted when the beacon is upgraded.\\n */\\n event BeaconUpgraded(address indexed beacon);\\n\\n /**\\n * @dev Returns the current beacon.\\n */\\n function _getBeacon() internal view returns (address) {\\n return StorageSlot.getAddressSlot(_BEACON_SLOT).value;\\n }\\n\\n /**\\n * @dev Stores a new beacon in the EIP1967 beacon slot.\\n */\\n function _setBeacon(address newBeacon) private {\\n require(Address.isContract(newBeacon), \\\"ERC1967: new beacon is not a contract\\\");\\n require(\\n Address.isContract(IBeacon(newBeacon).implementation()),\\n \\\"ERC1967: beacon implementation is not a contract\\\"\\n );\\n StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;\\n }\\n\\n /**\\n * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does\\n * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).\\n *\\n * Emits a {BeaconUpgraded} event.\\n */\\n function _upgradeBeaconToAndCall(\\n address newBeacon,\\n bytes memory data,\\n bool forceCall\\n ) internal {\\n _setBeacon(newBeacon);\\n emit BeaconUpgraded(newBeacon);\\n if (data.length > 0 || forceCall) {\\n Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);\\n }\\n }\\n}\\n\",\"keccak256\":\"0xcbccf806d646bd9e2594650917208245d45998b887d5fc914de424247f5f9f9d\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/Proxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\\n * be specified by overriding the virtual {_implementation} function.\\n *\\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\\n * different contract through the {_delegate} function.\\n *\\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\\n */\\nabstract contract Proxy {\\n /**\\n * @dev Delegates the current call to `implementation`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _delegate(address implementation) internal virtual {\\n assembly {\\n // Copy msg.data. We take full control of memory in this inline assembly\\n // block because it will not return to Solidity code. We overwrite the\\n // Solidity scratch pad at memory position 0.\\n calldatacopy(0, 0, calldatasize())\\n\\n // Call the implementation.\\n // out and outsize are 0 because we don't know the size yet.\\n let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\\n\\n // Copy the returned data.\\n returndatacopy(0, 0, returndatasize())\\n\\n switch result\\n // delegatecall returns 0 on error.\\n case 0 {\\n revert(0, returndatasize())\\n }\\n default {\\n return(0, returndatasize())\\n }\\n }\\n }\\n\\n /**\\n * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function\\n * and {_fallback} should delegate.\\n */\\n function _implementation() internal view virtual returns (address);\\n\\n /**\\n * @dev Delegates the current call to the address returned by `_implementation()`.\\n *\\n * This function does not return to its internall call site, it will return directly to the external caller.\\n */\\n function _fallback() internal virtual {\\n _beforeFallback();\\n _delegate(_implementation());\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\\n * function in the contract matches the call data.\\n */\\n fallback() external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\\n * is empty.\\n */\\n receive() external payable virtual {\\n _fallback();\\n }\\n\\n /**\\n * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\\n * call, or as part of the Solidity `fallback` or `receive` functions.\\n *\\n * If overriden should call `super._beforeFallback()`.\\n */\\n function _beforeFallback() internal virtual {}\\n}\\n\",\"keccak256\":\"0x8ddea9f930f26e588ea606f44c90d2623560c908e38614a03a4ca78aea8f9202\",\"license\":\"MIT\"},\"@openzeppelin/contracts/proxy/beacon/IBeacon.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev This is the interface that {BeaconProxy} expects of its beacon.\\n */\\ninterface IBeacon {\\n /**\\n * @dev Must return an address that can be used as a delegate call target.\\n *\\n * {BeaconProxy} will check that this address is a contract.\\n */\\n function implementation() external view returns (address);\\n}\\n\",\"keccak256\":\"0x5615339d191e77be7e46319b67856f9355786f705b7b3c4a7237ab70c1864ab1\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/Address.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary Address {\\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 function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n assembly {\\n size := extcodesize(account)\\n }\\n return size > 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 Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionDelegateCall(target, data, \\\"Address: low-level delegate call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a delegate call.\\n *\\n * _Available since v3.4._\\n */\\n function functionDelegateCall(\\n address target,\\n bytes memory data,\\n string memory errorMessage\\n ) internal returns (bytes memory) {\\n require(isContract(target), \\\"Address: delegate call to non-contract\\\");\\n\\n (bool success, bytes memory returndata) = target.delegatecall(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\\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\":\"0x3336baae5cf23e94274d75336e2d412193be508504aee185e61dc7d58cd05c8a\",\"license\":\"MIT\"},\"@openzeppelin/contracts/utils/StorageSlot.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\n/**\\n * @dev Library for reading and writing primitive types to specific storage slots.\\n *\\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\\n * This library helps with reading and writing to such slots without the need for inline assembly.\\n *\\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\\n *\\n * Example usage to set ERC1967 implementation slot:\\n * ```\\n * contract ERC1967 {\\n * bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\\n *\\n * function _getImplementation() internal view returns (address) {\\n * return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\\n * }\\n *\\n * function _setImplementation(address newImplementation) internal {\\n * require(Address.isContract(newImplementation), \\\"ERC1967: new implementation is not a contract\\\");\\n * StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\\n * }\\n * }\\n * ```\\n *\\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\\n */\\nlibrary StorageSlot {\\n struct AddressSlot {\\n address value;\\n }\\n\\n struct BooleanSlot {\\n bool value;\\n }\\n\\n struct Bytes32Slot {\\n bytes32 value;\\n }\\n\\n struct Uint256Slot {\\n uint256 value;\\n }\\n\\n /**\\n * @dev Returns an `AddressSlot` with member `value` located at `slot`.\\n */\\n function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\\n */\\n function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\\n */\\n function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\\n assembly {\\n r.slot := slot\\n }\\n }\\n\\n /**\\n * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\\n */\\n function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\\n assembly {\\n r.slot := slot\\n }\\n }\\n}\\n\",\"keccak256\":\"0x5d15d280d1f868f59a8264dc73f7ea8c51f10d78aac864b2f2ad29412d187ff5\",\"license\":\"MIT\"},\"contracts/chugsplash/TransparentUpgradeableProxy.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity ^0.8.0;\\n\\nimport \\\"@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol\\\";\\n\\n/**\\n * @dev This contract implements a proxy that is upgradeable by an admin.\\n *\\n * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector\\n * clashing], which can potentially be used in an attack, this contract uses the\\n * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two\\n * things that go hand in hand:\\n *\\n * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if\\n * that call matches one of the admin functions exposed by the proxy itself.\\n * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the\\n * implementation. If the admin tries to call a function on the implementation it will fail with an error that says\\n * \\\"admin cannot fallback to proxy target\\\".\\n *\\n * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing\\n * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due\\n * to sudden errors when trying to call a function from the proxy implementation.\\n *\\n * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,\\n * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.\\n */\\ncontract TransparentUpgradeableProxy is ERC1967Proxy {\\n /**\\n * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and\\n * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.\\n */\\n constructor(\\n address _logic,\\n address admin_,\\n bytes memory _data\\n ) payable ERC1967Proxy(_logic, _data) {\\n assert(_ADMIN_SLOT == bytes32(uint256(keccak256(\\\"eip1967.proxy.admin\\\")) - 1));\\n _changeAdmin(admin_);\\n }\\n\\n /**\\n * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.\\n */\\n modifier ifAdmin() {\\n if (msg.sender == _getAdmin()) {\\n _;\\n } else {\\n _fallback();\\n }\\n }\\n\\n /**\\n * @dev Returns the current admin.\\n *\\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.\\n *\\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`\\n */\\n function admin() external ifAdmin returns (address admin_) {\\n admin_ = _getAdmin();\\n }\\n\\n /**\\n * @dev Returns the current implementation.\\n *\\n * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.\\n *\\n * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the\\n * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.\\n * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`\\n */\\n function implementation() external ifAdmin returns (address implementation_) {\\n implementation_ = _implementation();\\n }\\n\\n /**\\n * @dev Changes the admin of the proxy.\\n *\\n * Emits an {AdminChanged} event.\\n *\\n * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.\\n */\\n function changeAdmin(address newAdmin) external virtual ifAdmin {\\n _changeAdmin(newAdmin);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy.\\n *\\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.\\n */\\n function upgradeTo(address newImplementation) external ifAdmin {\\n _upgradeToAndCall(newImplementation, bytes(\\\"\\\"), false);\\n }\\n\\n /**\\n * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified\\n * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the\\n * proxied contract.\\n *\\n * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.\\n */\\n function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {\\n _upgradeToAndCall(newImplementation, data, true);\\n }\\n\\n /**\\n * @dev Returns the current admin.\\n */\\n function _admin() internal view virtual returns (address) {\\n return _getAdmin();\\n }\\n\\n /**\\n * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.\\n */\\n function _beforeFallback() internal virtual override {\\n require(msg.sender != _getAdmin(), \\\"TransparentUpgradeableProxy: admin cannot fallback to proxy target\\\");\\n super._beforeFallback();\\n }\\n}\\n\",\"keccak256\":\"0x9a9b713a923026d1ee9f84602874012db980f0af888d30b72d7791a796fa9534\",\"license\":\"MIT\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "0x60806040526004361061004e5760003560e01c80633659cfe6146100655780634f1ef286146100855780635c60da1b146100985780638f283970146100c9578063f851a440146100e95761005d565b3661005d5761005b6100fe565b005b61005b6100fe565b34801561007157600080fd5b5061005b6100803660046106d6565b610118565b61005b6100933660046106f1565b61015f565b3480156100a457600080fd5b506100ad6101d0565b6040516001600160a01b03909116815260200160405180910390f35b3480156100d557600080fd5b5061005b6100e43660046106d6565b61020b565b3480156100f557600080fd5b506100ad610235565b610106610292565b610116610111610331565b61033b565b565b61012061035f565b6001600160a01b0316336001600160a01b031614156101575761015481604051806020016040528060008152506000610392565b50565b6101546100fe565b61016761035f565b6001600160a01b0316336001600160a01b031614156101c8576101c38383838080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525060019250610392915050565b505050565b6101c36100fe565b60006101da61035f565b6001600160a01b0316336001600160a01b03161415610200576101fb610331565b905090565b6102086100fe565b90565b61021361035f565b6001600160a01b0316336001600160a01b0316141561015757610154816103bd565b600061023f61035f565b6001600160a01b0316336001600160a01b03161415610200576101fb61035f565b606061028583836040518060600160405280602781526020016107f060279139610411565b9392505050565b3b151590565b61029a61035f565b6001600160a01b0316336001600160a01b031614156101165760405162461bcd60e51b815260206004820152604260248201527f5472616e73706172656e745570677261646561626c6550726f78793a2061646d60448201527f696e2063616e6e6f742066616c6c6261636b20746f2070726f78792074617267606482015261195d60f21b608482015260a4015b60405180910390fd5b60006101fb6104e5565b3660008037600080366000845af43d6000803e80801561035a573d6000f35b3d6000fd5b60007fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035b546001600160a01b0316919050565b61039b8361050d565b6000825111806103a85750805b156101c3576103b78383610260565b50505050565b7f7e644d79422f17c01e4894b5f4f588d331ebfa28653d42ae832dc59e38c9798f6103e661035f565b604080516001600160a01b03928316815291841660208301520160405180910390a16101548161054d565b6060833b6104705760405162461bcd60e51b815260206004820152602660248201527f416464726573733a2064656c65676174652063616c6c20746f206e6f6e2d636f6044820152651b9d1c9858dd60d21b6064820152608401610328565b600080856001600160a01b03168560405161048b91906107a0565b600060405180830381855af49150503d80600081146104c6576040519150601f19603f3d011682016040523d82523d6000602084013e6104cb565b606091505b50915091506104db8282866105f6565b9695505050505050565b60007f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc610383565b6105168161062f565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b90600090a250565b6001600160a01b0381166105b25760405162461bcd60e51b815260206004820152602660248201527f455243313936373a206e65772061646d696e20697320746865207a65726f206160448201526564647265737360d01b6064820152608401610328565b807fb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d61035b80546001600160a01b0319166001600160a01b039290921691909117905550565b60608315610605575081610285565b8251156106155782518084602001fd5b8160405162461bcd60e51b815260040161032891906107bc565b803b6106935760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b6064820152608401610328565b807f360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc6105d5565b80356001600160a01b03811681146106d157600080fd5b919050565b6000602082840312156106e857600080fd5b610285826106ba565b60008060006040848603121561070657600080fd5b61070f846106ba565b9250602084013567ffffffffffffffff8082111561072c57600080fd5b818601915086601f83011261074057600080fd5b81358181111561074f57600080fd5b87602082850101111561076157600080fd5b6020830194508093505050509250925092565b60005b8381101561078f578181015183820152602001610777565b838111156103b75750506000910152565b600082516107b2818460208701610774565b9190910192915050565b60208152600082518060208401526107db816040850160208701610774565b601f01601f1916919091016040019291505056fe416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a26469706673582212204c42c8a05d38921bf3b9c46c2d6959383ec3cf89d820f0f9ee530ce0a4c93bba64736f6c63430008090033",