support contract proxy

contracts/DecentralizedKV.sol

@@ -1,24 +1,25 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
+import "@openzeppelin/contracts/proxy/utils/Initializable.sol";
 import "./MerkleLib.sol";
 import "./BinaryRelated.sol";
 
-contract DecentralizedKV {
+contract DecentralizedKV is Initializable {
     event Remove(uint256 indexed kvIdx, uint256 indexed lastKvIdx);
 
     enum DecodeType {
         RawData,
         PaddingPer31Bytes
     }
 
-    uint256 public immutable storageCost; // Upfront storage cost (pre-dcf)
+    uint256 public storageCost; // Upfront storage cost (pre-dcf)
     // Discounted cash flow factor in seconds
     // E.g., 0.85 yearly discount in second = 0.9999999948465585 = 340282365167313208607671216367074279424 in Q128.128
-    uint256 public immutable dcfFactor;
-    uint256 public immutable startTime;
-    uint256 public immutable maxKvSize;
-    uint40 public lastKvIdx = 0; // number of entries in the store
+    uint256 public dcfFactor;
+    uint256 public startTime;
+    uint256 public maxKvSize;
+    uint40 public lastKvIdx; // number of entries in the store
 
     struct PhyAddr {
         /* Internal address seeking */
@@ -34,7 +35,8 @@ contract DecentralizedKV {
     /* index - skey, reverse lookup */
     mapping(uint256 => bytes32) internal idxMap;
 
-    constructor(uint256 _maxKvSize, uint256 _startTime, uint256 _storageCost, uint256 _dcfFactor) payable {
+    function __init_KV(uint256 _maxKvSize, uint256 _startTime, uint256 _storageCost, uint256 _dcfFactor) public onlyInitializing {
+        lastKvIdx = 0;
         startTime = _startTime;
         maxKvSize = _maxKvSize;
         storageCost = _storageCost;

contracts/EthStorageAdmin.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+
+contract EthStorageAdmin is ProxyAdmin {
+
+    constructor(address initialOwner) ProxyAdmin(initialOwner) {}
+
+}

contracts/EthStorageContract.sol

@@ -41,15 +41,16 @@ contract EthStorageContract is StorageContract, Decoder {
 
     event PutBlob(uint256 indexed kvIdx, uint256 indexed kvSize, bytes32 indexed dataHash);
 
-    constructor(
+    function __init_eth_storage(
         Config memory _config,
         uint256 _startTime,
         uint256 _storageCost,
         uint256 _dcfFactor,
         uint256 _nonceLimit,
         address _treasury,
         uint256 _prepaidAmount
-    ) payable StorageContract(_config, _startTime, _storageCost, _dcfFactor, _nonceLimit, _treasury, _prepaidAmount) {
+    ) public payable onlyInitializing {
+        __init_storage(_config, _startTime, _storageCost, _dcfFactor, _nonceLimit, _treasury, _prepaidAmount);
         hashGetter = address(new BlobHashGetterFactory());
     }
 

contracts/EthStorageContract2.sol

@@ -6,21 +6,23 @@ import "./Decoder2.sol";
 
 
 contract EthStorageContract2 is EthStorageContract, Decoder2 {
-    
-    constructor(
+
+    function initialize(
         Config memory _config,
         uint256 _startTime,
         uint256 _storageCost,
         uint256 _dcfFactor,
         uint256 _nonceLimit,
         address _treasury,
         uint256 _prepaidAmount
-    ) EthStorageContract(_config, _startTime, _storageCost, _dcfFactor, _nonceLimit, _treasury, _prepaidAmount) {}
+    ) public payable initializer {
+        __init_eth_storage(_config, _startTime, _storageCost, _dcfFactor, _nonceLimit, _treasury, _prepaidAmount);
+    }
 
     function decodeSample(
         uint256[] memory masks,
         bytes calldata decodeProof
-    ) public view returns (bool) {        
+    ) public view returns (bool) {
         (uint[2] memory pA, uint[2][2] memory pB, uint[2] memory pC) = abi.decode(decodeProof, (uint[2], uint[2][2], uint[2]));
         // verifyProof uses the opcode 'return', so if we call verifyProof directly, it will lead to a compiler warning about 'unreachable code' 
         // and causes the caller function return directly
@@ -56,5 +58,5 @@ contract EthStorageContract2 is EthStorageContract, Decoder2 {
 
         require(decodeSample(masks, decodeProof[0]), "decode failed");
         return hash0;
-    }    
+    }
 }

contracts/EthStorageUpgradeableProxy.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+
+contract EthStorageUpgradeableProxy is TransparentUpgradeableProxy {
+
+    constructor(address _logic, address initialOwner, bytes memory _data) payable TransparentUpgradeableProxy(_logic, initialOwner, _data) {}
+
+    function admin() public view virtual returns (address) {
+        return ERC1967Utils.getAdmin();
+    }
+}

contracts/StorageContract.sol

@@ -20,36 +20,38 @@ abstract contract StorageContract is DecentralizedKV {
 
     uint256 public constant sampleSizeBits = 5; // 32 bytes per sample
 
-    uint256 public immutable maxKvSizeBits;
-    uint256 public immutable shardSizeBits;
-    uint256 public immutable shardEntryBits;
-    uint256 public immutable sampleLenBits;
-    uint256 public immutable randomChecks;
-    uint256 public immutable minimumDiff;
-    uint256 public immutable cutoff;
-    uint256 public immutable diffAdjDivisor;
-    uint256 public immutable treasuryShare; // 10000 = 1.0
-    uint256 public immutable prepaidAmount;
+    uint256 public maxKvSizeBits;
+    uint256 public shardSizeBits;
+    uint256 public shardEntryBits;
+    uint256 public sampleLenBits;
+    uint256 public randomChecks;
+    uint256 public minimumDiff;
+    uint256 public cutoff;
+    uint256 public diffAdjDivisor;
+    uint256 public treasuryShare; // 10000 = 1.0
+    uint256 public prepaidAmount;
 
     mapping(uint256 => MiningLib.MiningInfo) public infos;
     uint256 public nonceLimit; // maximum nonce per block
     address public treasury;
     uint256 public prepaidLastMineTime;
 
-    constructor(
+    function __init_storage(
         Config memory _config,
         uint256 _startTime,
         uint256 _storageCost,
         uint256 _dcfFactor,
         uint256 _nonceLimit,
         address _treasury,
         uint256 _prepaidAmount
-    ) payable DecentralizedKV(1 << _config.maxKvSizeBits, _startTime, _storageCost, _dcfFactor) {
+    ) public onlyInitializing {
         /* Assumptions */
         require(_config.shardSizeBits >= _config.maxKvSizeBits, "shardSize too small");
         require(_config.maxKvSizeBits >= sampleSizeBits, "maxKvSize too small");
         require(_config.randomChecks > 0, "At least one checkpoint needed");
 
+        __init_KV(1 << _config.maxKvSizeBits, _startTime, _storageCost, _dcfFactor);
+
         shardSizeBits = _config.shardSizeBits;
         maxKvSizeBits = _config.maxKvSizeBits;
         shardEntryBits = _config.shardSizeBits - _config.maxKvSizeBits;

contracts/TestDecentralizedKV.sol

@@ -8,12 +8,14 @@ contract TestDecentralizedKV is DecentralizedKV {
 
     mapping(uint256 => bytes) internal dataMap;
 
-    constructor(
+    function initialize(
         uint256 _maxKvSize,
         uint256 _startTime,
         uint256 _storageCost,
         uint256 _dcfFactor
-    ) DecentralizedKV(_maxKvSize, _startTime, _storageCost, _dcfFactor) {}
+    ) public initializer {
+        __init_KV(_maxKvSize, _startTime, _storageCost, _dcfFactor);
+    }
 
     function setTimestamp(uint256 ts) public {
         require(ts > currentTimestamp, "ts");

contracts/TestEthStorageContract.sol

@@ -13,15 +13,17 @@ contract TestEthStorageContract is EthStorageContract {
         bytes32[] proofs;
     }
 
-    constructor(
+    function initialize(
         Config memory _config,
         uint256 _startTime,
         uint256 _storageCost,
         uint256 _dcfFactor,
         uint256 _nonceLimit,
         address _treasury,
         uint256 _prepaidAmount
-    ) EthStorageContract(_config, _startTime, _storageCost, _dcfFactor, _nonceLimit, _treasury, _prepaidAmount) {}
+    ) public payable initializer {
+        __init_eth_storage(_config, _startTime, _storageCost, _dcfFactor, _nonceLimit, _treasury, _prepaidAmount);
+    }
 
     function setTimestamp(uint256 ts) public {
         require(ts > currentTimestamp, "ts");
@@ -69,7 +71,7 @@ contract TestEthStorageContract is EthStorageContract {
         return bytes32(expectedEncodedData) == encodedData;
     }
 
-    function getSampleIdx(uint256 startShardId, bytes32 hash0) public view returns (uint256, uint256, uint256) {
+    function getSampleIdx0(uint256 startShardId, bytes32 hash0) public view returns (uint256, uint256, uint256) {
         // calculate the number of samples range of the sample check
         uint256 rows = 1 << (shardEntryBits + sampleLenBits); // kvNumbersPerShard * smapleNumersPerKV
 

contracts/TestEthStorageContractKZG.sol

@@ -1,19 +1,9 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "./EthStorageContract.sol";
-
-contract TestEthStorageContractKZG is EthStorageContract {
-    constructor(
-        Config memory _config,
-        uint256 _startTime,
-        uint256 _storageCost,
-        uint256 _dcfFactor,
-        uint256 _nonceLimit,
-        address _treasury,
-        uint256 _prepaidAmount
-    ) EthStorageContract(_config, _startTime, _storageCost, _dcfFactor, _nonceLimit, _treasury, _prepaidAmount) {}
+import "./EthStorageContract2.sol";
 
+contract TestEthStorageContractKZG is EthStorageContract2 {
     // a test only method to upload multiple blobs in one tx
     function putBlobs(bytes32[] memory keys) public payable {
         for (uint256 i = 0; i < keys.length; i++) {

hardhat.config.js

@@ -70,7 +70,7 @@ module.exports = {
     timeout: 120000,
   },
   solidity: {
-    version: "0.8.16",
+    version: "0.8.20",
     settings: {
       optimizer: {
         enabled: true,