Basefee calculation release

yaroslavyaroslav · yaroslavyaroslav · commit 1e2b0faf6f3e · 2022-03-29T19:05:33.000+03:00
- Add methods documentation
- Refactor calcBaseFee method
- refactor ChainVersion mainNetFisrtBlockNumber for clarity
- Delete useless ChainVersion Comparable method
- Refactor EIP1559Tests class
- Add testCalcBaseFee test

All tests are green.
diff --git a/Sources/web3swift/Web3/Web3+EIP1559.swift b/Sources/web3swift/Web3/Web3+EIP1559.swift
@@ -17,7 +17,8 @@ import BigInt
 public extension Web3 {
     func verifyGasLimit(parentGasLimit: BigUInt, currentGasLimit: BigUInt) -> Bool {
         var diff = BigInt(parentGasLimit) - BigInt(currentGasLimit)
-        
+
+        // make diff positive number
         diff = diff < 0 ? diff * -1 : diff
 
         let limit = parentGasLimit / Web3.GasLimitBoundDivisor
@@ -31,55 +32,61 @@ public extension Web3 {
         return true
     }
 
-    /// VerifyEip1559Header verifies some header attributes which were changed in EIP-1559,
+    /// Method to check is given block valid EIP-1559 block
+    ///
+    /// Verifies some header attributes which were changed in EIP-1559
+    ///
     /// - gas limit check
     /// - basefee check
-    /// This function make checks that this given block is valid post EIP-1559 block and returns true if it is
-    /// and thors an error if it isn't.
-    func verifyEip1559Block(parent: Block, current: Block) -> Bool {
-        var parentGasLimit = parent.gasLimit
-        if parent.chainVersion != .London {
-            parentGasLimit = parent.gasLimit * Web3.ElasticityMultiplier
-        }
+    ///
+    /// - Parameters:
+    ///   - parent: Previous Block
+    ///   - current: Current block
+    /// - Returns: True or false if block is EIP-1559 or not
+    func isEip1559Block(parent: Block, current: Block) -> Bool {
+        let parentGasLimit = parent.chainVersion >= .London ? parent.gasLimit : parent.gasLimit * Web3.ElasticityMultiplier
 
         guard verifyGasLimit(parentGasLimit: parentGasLimit, currentGasLimit: current.gasLimit) else { return false }
 
-        // ??? In go implementation this field is optional
-        // if current.baseFeePerGas == nil { throw Web3Error.unknownError }
-
-        let expectedBaseFeePerGas = self.calcBaseFee(parent)
-
-        // TODO: Make all errors trows more descriptive errors
-        // ("invalid baseFee: have %s, want %s, parentBaseFee %s, parentGasUsed %d", expectedBaseFee, header.BaseFee, parent.BaseFee, parent.GasUsed)
-        guard expectedBaseFeePerGas == current.baseFeePerGas else { return false }
+        guard calcBaseFee(parent) == current.baseFeePerGas else { return false }
 
         return true
     }
 
+    /// Calculates base fee amount
+    ///
+    /// You should pass **parent** block to that method to calculate **expected** baseFee for currently
+    /// processing by blockchain `Block`
+    ///
+    /// Calculation for current `Block` based on parents block object only
+    ///
+    /// If passed block isn't `ChainVersion.London` one will return
+    ///
+    /// - Parameter parent: Parent `Block`
+    /// - Returns: Amount of expected base fee for current `Block`
     func calcBaseFee(_ parent: Block) -> BigUInt {
-        // If the current block is the first EIP-1559 block, return the InitialBaseFee.
-        guard parent.chainVersion == .London else { return Web3.InitialBaseFee }
+        // If given blocks ChainVersion is lower than London — always returns InitialBaseFee
+        guard parent.chainVersion >= .London else { return Web3.InitialBaseFee }
 
         let parentGasTarget = parent.gasLimit / Web3.ElasticityMultiplier
 
-        // If the parent gasUsed is the same as the target, the baseFee remains unchanged.
-        if parent.gasUsed == parentGasTarget {
-            return parent.baseFeePerGas
-            
-        } else if parent.gasUsed > parentGasTarget {
+        if parent.gasUsed > parentGasTarget {
             // If the parent block used more gas than its target, the baseFee should increase.
             let gasUsedDelta = parent.gasUsed - parentGasTarget
             let baseFeePerGasDelta = max(parent.baseFeePerGas * gasUsedDelta / parentGasTarget / Web3.BaseFeeChangeDenominator, 1)
             let expectedBaseFeePerGas = parent.baseFeePerGas + baseFeePerGasDelta
 
             return expectedBaseFeePerGas
-        } else {
+        } else if parent.gasUsed < parentGasTarget  {
             // Otherwise if the parent block used less gas than its target, the baseFee should decrease.
             let gasUsedDelta = parentGasTarget - parent.gasUsed
             let baseFeePerGasDelta = parent.baseFeePerGas * gasUsedDelta / parentGasTarget / Web3.BaseFeeChangeDenominator
             let expectedBaseFeePerGas = parent.baseFeePerGas - baseFeePerGasDelta
 
             return expectedBaseFeePerGas
+        } else {
+            // If the parent gasUsed is the same as the target, the baseFee remains unchanged.
+            return parent.baseFeePerGas
         }
     }
 }
@@ -135,7 +142,7 @@ public extension Web3 {
         /// Block number: 13_773_000
         case ArrowGlacier
 
-        var blockNumber: BigUInt {
+        var mainNetFisrtBlockNumber: BigUInt {
             switch self {
                 case .Byzantium: return 4_370_000
                 case .Constantinople: return 7_280_000
@@ -152,28 +159,26 @@ public extension Web3 {
     static func getChainVersion(of block: BigUInt) -> ChainVersion {
         // Iterate given block number over each ChainVersion block numbers
         // to get the block's ChainVersion.
-        if block < ChainVersion.Constantinople.blockNumber {
+        if block < ChainVersion.Constantinople.mainNetFisrtBlockNumber {
             return .Byzantium
         // ~= means included in a given range
-        } else if ChainVersion.Constantinople.blockNumber..<ChainVersion.Istanbul.blockNumber ~= block {
+        } else if ChainVersion.Constantinople.mainNetFisrtBlockNumber..<ChainVersion.Istanbul.mainNetFisrtBlockNumber ~= block {
             return .Constantinople
-        } else if ChainVersion.Istanbul.blockNumber..<ChainVersion.MuirGlacier.blockNumber ~= block {
+        } else if ChainVersion.Istanbul.mainNetFisrtBlockNumber..<ChainVersion.MuirGlacier.mainNetFisrtBlockNumber ~= block {
             return .Istanbul
-        } else if ChainVersion.MuirGlacier.blockNumber..<ChainVersion.Berlin.blockNumber ~= block {
+        } else if ChainVersion.MuirGlacier.mainNetFisrtBlockNumber..<ChainVersion.Berlin.mainNetFisrtBlockNumber ~= block {
             return .MuirGlacier
-        } else if ChainVersion.Berlin.blockNumber..<ChainVersion.London.blockNumber ~= block {
+        } else if ChainVersion.Berlin.mainNetFisrtBlockNumber..<ChainVersion.London.mainNetFisrtBlockNumber ~= block {
             return .Berlin
-        } else if ChainVersion.London.blockNumber..<ChainVersion.ArrowGlacier.blockNumber ~= block {
+        } else if ChainVersion.London.mainNetFisrtBlockNumber..<ChainVersion.ArrowGlacier.mainNetFisrtBlockNumber ~= block {
             return .London
-        } else if block >= ChainVersion.ArrowGlacier.blockNumber {
+        } else if block >= ChainVersion.ArrowGlacier.mainNetFisrtBlockNumber {
             // Pass to the default return.
         }
         return .ArrowGlacier
     }
 }
 
 extension Web3.ChainVersion: Comparable {
-    public static func < (lhs: Web3.ChainVersion, rhs: Web3.ChainVersion) -> Bool { return lhs.blockNumber < rhs.blockNumber }
-
-    public static func <= (lhs: Web3.ChainVersion, rhs: Web3.ChainVersion) -> Bool { return lhs.blockNumber <= rhs.blockNumber }
+    public static func < (lhs: Web3.ChainVersion, rhs: Web3.ChainVersion) -> Bool { return lhs.mainNetFisrtBlockNumber < rhs.mainNetFisrtBlockNumber }
  }
diff --git a/Tests/web3swiftTests/localTests/EIP1559Tests.swift b/Tests/web3swiftTests/localTests/EIP1559Tests.swift
@@ -5,39 +5,38 @@ import BigInt
 import web3swift
 
 class EIP1559Tests: XCTestCase {
+    let web3 = Web3()
+
+    let uselessBlockPart = (
+        number: BigUInt(12_965_000),
+        hash: Data(from: "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46")!, // "hash":
+        parentHash: Data(from: "0x2302e1c0b972d00932deb5dab9eb2982f570597d9d42504c05d9c2147eaf9c88")!, // "parentHash":
+        nonce: Data(from: "0xfb6e1a62d119228b"), // "nonce":
+        sha3Uncles: Data(from: "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347")!, // "sha3Uncles":
+        receiptsRoot: Data(from: "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347")!, // "receiptsRoot":
+        logsBloom: EthereumBloomFilter(Data(from: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")!), // "logsBloom":
+        transactionsRoot: Data(from: "0x3a1b03875115b79539e5bd33fb00d8f7b7cd61929d5a3c574f507b8acf415bee")!, // "transactionsRoot":
+        stateRoot: Data(from: "0xf1133199d44695dfa8fd1bcfe424d82854b5cebef75bddd7e40ea94cda515bcb")!, // "stateRoot":
+        miner: EthereumAddress( Data(from: "0x8888f1f195afa192cfee860698584c030f4c9db1")!)!, // "miner":
+        difficulty: BigUInt(21345678965432), // "difficulty":
+        totalDifficulty: BigUInt(324567845321), // "totalDifficulty":
+        size: BigUInt(616), // "size":
+        extraData: Data(from: "0x")!, // extraData":
+        gasLimit: BigUInt(3141592), // "gasLimit":
+        gasUsed: BigUInt(21662), // "gasUsed":
+        timestamp: Date(), // "timestamp":
+        transactions: [TransactionInBlock](), // "transactions":
+        uncles: [Data]() // "uncles":
+    )
 
     /// testBlockGasLimits tests the gasLimit checks for blocks both across
     /// the EIP-1559 boundary and post-1559 blocks
     func testBlockGasLimits() throws {
-        let uselessBlockPart = (
-            number: BigUInt(3),
-
-            hash: Data(from: "0xef95f2f1ed3ca60b048b4bf67cde2195961e0bba6f70bcbea9a2c4e133e34b46")!, // "hash":
-            parentHash: Data(from: "0x2302e1c0b972d00932deb5dab9eb2982f570597d9d42504c05d9c2147eaf9c88")!, // "parentHash":
-//            baseFeePerGas: 58713056622, // baseFeePerGas":
-            nonce: Data(from: "0xfb6e1a62d119228b"), // "nonce":
-            sha3Uncles: Data(from: "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347")!, // "sha3Uncles":
-            receiptsRoot: Data(from: "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347")!, // "receiptsRoot":
-            logsBloom: EthereumBloomFilter(Data(from: "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")!), // "logsBloom":
-            transactionsRoot: Data(from: "0x3a1b03875115b79539e5bd33fb00d8f7b7cd61929d5a3c574f507b8acf415bee")!, // "transactionsRoot":
-            stateRoot: Data(from: "0xf1133199d44695dfa8fd1bcfe424d82854b5cebef75bddd7e40ea94cda515bcb")!, // "stateRoot":
-            miner: EthereumAddress( Data(from: "0x8888f1f195afa192cfee860698584c030f4c9db1")!)!, // "miner":
-            difficulty: BigUInt(21345678965432), // "difficulty":
-            totalDifficulty: BigUInt(324567845321), // "totalDifficulty":
-            size: BigUInt(616), // "size":
-            extraData: Data(from: "0x")!, // extraData":
-            gasLimit: BigUInt(3141592), // "gasLimit":
-            gasUsed: BigUInt(21662), // "gasUsed":
-            timestamp: Date(), // "timestamp":
-            transactions: [TransactionInBlock](), // "transactions":
-            uncles: [Data]() // "uncles":
-        )
-
         // [0] - parentGasLimit
         // [1] - parentNumber
         // [2] - currentGasLimit
         // [3] - Should fail or not
-        let headerArray: [(BigUInt, BigUInt, BigUInt, Bool) ] = [
+        let headerArray: [(BigUInt, BigUInt, BigUInt, Bool)] = [
             // Transitions from non-london to london
             (10_000_000, 12_964_999, 20_000_000, true),  // No change
             (10_000_000, 12_964_999, 20_019_530, true),  // Upper limit
@@ -55,9 +54,9 @@ class EIP1559Tests: XCTestCase {
             (40_000_000, 12_965_000, 40_039_062, false), // Upper limit +1
             (40_000_000, 12_965_000, 39_960_939, true),  // lower limit
             (40_000_000, 12_965_000, 39_960_938, false), // Lower limit -1
-        ] 
+        ]
 
-        try headerArray.forEach { (touple: (parentGasLimit: BigUInt, parentNumber: BigUInt, currentGasLimit: BigUInt, isOk: Bool)) in
+        headerArray.forEach { (touple: (parentGasLimit: BigUInt, parentNumber: BigUInt, currentGasLimit: BigUInt, is1559: Bool)) in
             let parent = Block(number: touple.parentNumber,
                                hash: uselessBlockPart.hash,
                                parentHash: uselessBlockPart.parentHash,
@@ -100,51 +99,55 @@ class EIP1559Tests: XCTestCase {
                                 transactions: uselessBlockPart.transactions,
                                 uncles: uselessBlockPart.uncles)
 
-            let web3 = Web3()
-
-            if touple.isOk {
-                XCTAssertTrue(web3.verifyEip1559Block(parent: parent, current: current),
+            if touple.is1559 {
+                XCTAssertTrue(web3.isEip1559Block(parent: parent, current: current),
                               "Shoult not fail, got parent: \(parent.gasLimit), current: \(current.gasLimit)")
             } else {
-                XCTAssertFalse(web3.verifyEip1559Block(parent: parent, current: current),
+                XCTAssertFalse(web3.isEip1559Block(parent: parent, current: current),
                                "Should fail, got parent: \(parent.gasLimit), current: \(current.gasLimit)")
             }
         }
     }
 
     /// testCalcBaseFee assumes all blocks are 1559-blocks
     func testCalcBaseFee() throws {
+        // [0] - parentBaseFee
+        // [1] - parentNumber
+        // [2] - parentGasLimit
+        // [3] - parentGasUsed
+        // [4] - expectedBaseFee
+        let headerArray: [(BigUInt, BigUInt, BigUInt, BigUInt, BigUInt)] = [
+            (Web3.InitialBaseFee, 12_964_999, 20000000, 10000000, Web3.InitialBaseFee),     // parent is not London
+            (Web3.InitialBaseFee, 12_965_000, 20000000, 10000000, Web3.InitialBaseFee),     // current == target
+            (Web3.InitialBaseFee, 12_965_000, 20000000, 9000000, 987500000),                // current below target
+            (Web3.InitialBaseFee, 12_965_000, 20000000, 11000000, 1012500000),              // current above target
+        ]
+
+        headerArray.forEach { (touple: (parentBaseFee: BigUInt, parentNumber: BigUInt, parentGasLimit: BigUInt, parentGasUsed: BigUInt, expectedBaseFee: BigUInt)) in
+            let parent = Block(number: touple.parentNumber,
+                               hash: uselessBlockPart.hash,
+                               parentHash: uselessBlockPart.parentHash,
+                               nonce: uselessBlockPart.nonce,
+                               sha3Uncles: uselessBlockPart.sha3Uncles,
+                               logsBloom: uselessBlockPart.logsBloom,
+                               transactionsRoot: uselessBlockPart.transactionsRoot,
+                               stateRoot: uselessBlockPart.stateRoot,
+                               receiptsRoot: uselessBlockPart.receiptsRoot,
+                               miner: uselessBlockPart.miner,
+                               difficulty: uselessBlockPart.difficulty,
+                               totalDifficulty: uselessBlockPart.totalDifficulty,
+                               extraData: uselessBlockPart.extraData,
+                               size: uselessBlockPart.size,
+                               gasLimit: touple.parentGasLimit,
+                               gasUsed: touple.parentGasUsed,
+                               baseFeePerGas: Web3.InitialBaseFee,
+                               timestamp: uselessBlockPart.timestamp,
+                               transactions: uselessBlockPart.transactions,
+                               uncles: uselessBlockPart.uncles)
 
-    }
-
-
-
-}
+            let calculatedBaseFee = web3.calcBaseFee(parent)
 
-/*
-// TestCalcBaseFee assumes all blocks are 1559-blocks
-func TestCalcBaseFee(t *testing.T) {
-    tests := []struct {
-        parentBaseFee   int64
-        parentGasLimit  uint64
-        parentGasUsed   uint64
-        expectedBaseFee int64
-    }{
-        {params.InitialBaseFee, 20000000, 10000000, params.InitialBaseFee}, // usage == target
-        {params.InitialBaseFee, 20000000, 9000000, 987500000},              // usage below target
-        {params.InitialBaseFee, 20000000, 11000000, 1012500000},            // usage above target
-    }
-    for i, test := range tests {
-        parent := &types.Header{
-            Number:   common.Big32,
-            GasLimit: test.parentGasLimit,
-            GasUsed:  test.parentGasUsed,
-            BaseFee:  big.NewInt(test.parentBaseFee),
-        }
-        if have, want := CalcBaseFee(config(), parent), big.NewInt(test.expectedBaseFee); have.Cmp(want) != 0 {
-            t.Errorf("test %d: have %d  want %d, ", i, have, want)
+            XCTAssertEqual(calculatedBaseFee, touple.expectedBaseFee, "Base fee calculation fails: should be \(touple.expectedBaseFee), got: \(calculatedBaseFee)")
         }
     }
 }
-
-*/
