chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/consensus/multiprocess_validation.py

@@ -1,36 +1,34 @@
 from __future__ import annotations
 
 import asyncio
+import copy
 import logging
 import time
 import traceback
+from collections.abc import Awaitable, Collection
 from concurrent.futures import Executor
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Sequence, Tuple
+from typing import Optional
 
-from chia_rs import AugSchemeMPL, SpendBundleConditions
+from chia_rs import SpendBundleConditions, get_flags_for_height_and_constants, run_block_generator, run_block_generator2
 
 from chia.consensus.block_header_validation import validate_finished_header_block
 from chia.consensus.block_record import BlockRecord
-from chia.consensus.blockchain_interface import BlocksProtocol
+from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.constants import ConsensusConstants
-from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.full_block_to_block_record import block_to_block_record
 from chia.consensus.get_block_challenge import get_block_challenge
 from chia.consensus.get_block_generator import get_block_generator
 from chia.consensus.pot_iterations import calculate_iterations_quality, is_overflow_block
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
 from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.full_block import FullBlock
 from chia.types.generator_types import BlockGenerator
-from chia.types.unfinished_block import UnfinishedBlock
+from chia.types.validation_state import ValidationState
 from chia.util.augmented_chain import AugmentedBlockchain
-from chia.util.block_cache import BlockCache
-from chia.util.condition_tools import pkm_pairs
-from chia.util.errors import Err, ValidationError
+from chia.util.errors import Err
 from chia.util.generator_tools import get_block_header, tx_removals_and_additions
 from chia.util.ints import uint16, uint32, uint64
 from chia.util.streamable import Streamable, streamable
@@ -44,322 +42,227 @@ class PreValidationResult(Streamable):
     error: Optional[uint16]
     required_iters: Optional[uint64]  # Iff error is None
     conds: Optional[SpendBundleConditions]  # Iff error is None and block is a transaction block
-    validated_signature: bool
     timing: uint32  # the time (in milliseconds) it took to pre-validate the block
 
+    @property
+    def validated_signature(self) -> bool:
+        if self.conds is None:
+            return False
+        return self.conds.validated_signature
 
-def batch_pre_validate_blocks(
+
+# this layer of abstraction is here to let wallet tests monkeypatch it
+def _run_block(
+    block: FullBlock, prev_generators: list[bytes], constants: ConsensusConstants
+) -> tuple[Optional[int], Optional[SpendBundleConditions]]:
+    assert block.transactions_generator is not None
+    assert block.transactions_info is not None
+    flags = get_flags_for_height_and_constants(block.height, constants)
+    if block.height >= constants.HARD_FORK_HEIGHT:
+        run_block = run_block_generator2
+    else:
+        run_block = run_block_generator
+    return run_block(
+        bytes(block.transactions_generator),
+        prev_generators,
+        block.transactions_info.cost,
+        flags,
+        block.transactions_info.aggregated_signature,
+        None,
+        constants,
+    )
+
+
+def _pre_validate_block(
     constants: ConsensusConstants,
-    blocks_pickled: Dict[bytes, bytes],
-    full_blocks_pickled: List[bytes],
-    prev_transaction_generators: List[Optional[List[bytes]]],
-    conditions: Dict[uint32, bytes],
-    expected_difficulty: List[uint64],
-    expected_sub_slot_iters: List[uint64],
-    validate_signatures: bool,
-    prev_ses_block_bytes: Optional[List[Optional[bytes]]] = None,
-) -> List[bytes]:
-    blocks: Dict[bytes32, BlockRecord] = {}
-    for k, v in blocks_pickled.items():
-        blocks[bytes32(k)] = BlockRecord.from_bytes_unchecked(v)
-    results: List[PreValidationResult] = []
-
-    # In this case, we are validating full blocks, not headers
-    for i in range(len(full_blocks_pickled)):
-        try:
-            validation_start = time.monotonic()
-            block: FullBlock = FullBlock.from_bytes_unchecked(full_blocks_pickled[i])
-            tx_additions: List[Coin] = []
-            removals: List[bytes32] = []
-            conds: Optional[SpendBundleConditions] = None
-            if block.height in conditions:
-                conds = SpendBundleConditions.from_bytes(conditions[block.height])
-                removals, tx_additions = tx_removals_and_additions(conds)
-            elif block.transactions_generator is not None:
-                # TODO: this function would be simpler if conditions were
-                # required to be passed in for all transaction blocks. We would
-                # no longer need prev_transaction_generators
-                prev_generators = prev_transaction_generators[i]
-                assert prev_generators is not None
-                assert block.transactions_info is not None
-                block_generator = BlockGenerator(block.transactions_generator, prev_generators)
-                assert block_generator.program == block.transactions_generator
-                npc_result = get_name_puzzle_conditions(
-                    block_generator,
-                    min(constants.MAX_BLOCK_COST_CLVM, block.transactions_info.cost),
-                    mempool_mode=False,
-                    height=block.height,
-                    constants=constants,
-                )
-                if npc_result.error is not None:
-                    validation_time = time.monotonic() - validation_start
-                    results.append(
-                        PreValidationResult(
-                            uint16(npc_result.error), None, npc_result.conds, False, uint32(validation_time * 1000)
-                        )
-                    )
-                    continue
-                assert npc_result.conds is not None
-                conds = npc_result.conds
-                removals, tx_additions = tx_removals_and_additions(conds)
-
-            header_block = get_block_header(block, tx_additions, removals)
-            prev_ses_block = None
-            if prev_ses_block_bytes is not None and len(prev_ses_block_bytes) > 0:
-                buffer = prev_ses_block_bytes[i]
-                if buffer is not None:
-                    prev_ses_block = BlockRecord.from_bytes_unchecked(buffer)
-            required_iters, error = validate_finished_header_block(
-                constants,
-                BlockCache(blocks),
-                header_block,
-                True,  # check_filter
-                expected_difficulty[i],
-                expected_sub_slot_iters[i],
-                prev_ses_block=prev_ses_block,
-            )
-            error_int: Optional[uint16] = None
-            if error is not None:
-                error_int = uint16(error.code.value)
-
-            successfully_validated_signatures = False
-            # If we failed header block validation, no need to validate
-            # signature, the block is already invalid If this is False, it means
-            # either we don't have a signature (not a tx block) or we have an
-            # invalid signature (which also puts in an error) or we didn't
-            # validate the signature because we want to validate it later.
-            # add_block will attempt to validate the signature later.
-            if error_int is None and validate_signatures and conds is not None:
-                assert block.transactions_info is not None
-                pairs_pks, pairs_msgs = pkm_pairs(conds, constants.AGG_SIG_ME_ADDITIONAL_DATA)
-                if not AugSchemeMPL.aggregate_verify(
-                    pairs_pks, pairs_msgs, block.transactions_info.aggregated_signature
-                ):
-                    error_int = uint16(Err.BAD_AGGREGATE_SIGNATURE.value)
-                else:
-                    successfully_validated_signatures = True
-
-            validation_time = time.monotonic() - validation_start
-            results.append(
-                PreValidationResult(
-                    error_int,
-                    required_iters,
-                    conds,
-                    successfully_validated_signatures,
-                    uint32(validation_time * 1000),
+    blockchain: BlockRecordsProtocol,
+    block: FullBlock,
+    prev_generators: Optional[list[bytes]],
+    conds: Optional[SpendBundleConditions],
+    expected_vs: ValidationState,
+) -> PreValidationResult:
+    """
+    Args:
+        constants:
+        blockchain:
+        block:
+        prev_generators:
+        conds:
+        expected_vs: The validation state that we calculate for the next block
+            if it's validated.
+    """
+
+    try:
+        validation_start = time.monotonic()
+        removals_and_additions: Optional[tuple[Collection[bytes32], Collection[Coin]]] = None
+        if conds is not None:
+            assert conds.validated_signature is True
+            assert block.transactions_generator is not None
+            removals_and_additions = tx_removals_and_additions(conds)
+        elif block.transactions_generator is not None:
+            assert prev_generators is not None
+            assert block.transactions_info is not None
+
+            if block.transactions_info.cost > constants.MAX_BLOCK_COST_CLVM:
+                validation_time = time.monotonic() - validation_start
+                return PreValidationResult(
+                    uint16(Err.BLOCK_COST_EXCEEDS_MAX.value), None, None, uint32(validation_time * 1000)
                 )
-            )
-        except Exception:
-            error_stack = traceback.format_exc()
-            log.error(f"Exception: {error_stack}")
-            validation_time = time.monotonic() - validation_start
-            results.append(
-                PreValidationResult(uint16(Err.UNKNOWN.value), None, None, False, uint32(validation_time * 1000))
-            )
-    return [bytes(r) for r in results]
-
-
-async def pre_validate_blocks_multiprocessing(
+
+            err, conds = _run_block(block, prev_generators, constants)
+
+            assert (err is None) != (conds is None)
+            if err is not None:
+                validation_time = time.monotonic() - validation_start
+                return PreValidationResult(uint16(err), None, None, uint32(validation_time * 1000))
+            assert conds is not None
+            assert conds.validated_signature is True
+            removals_and_additions = tx_removals_and_additions(conds)
+        elif block.is_transaction_block():
+            # This is a transaction block with just reward coins.
+            removals_and_additions = ([], [])
+
+        assert conds is None or conds.validated_signature is True
+        header_block = get_block_header(block, removals_and_additions)
+        required_iters, error = validate_finished_header_block(
+            constants,
+            blockchain,
+            header_block,
+            True,  # check_filter
+            expected_vs,
+        )
+        error_int: Optional[uint16] = None
+        if error is not None:
+            error_int = uint16(error.code.value)
+
+        validation_time = time.monotonic() - validation_start
+        return PreValidationResult(
+            error_int,
+            required_iters,
+            conds,
+            uint32(validation_time * 1000),
+        )
+    except Exception:
+        error_stack = traceback.format_exc()
+        log.error(f"Exception: {error_stack}")
+        validation_time = time.monotonic() - validation_start
+        return PreValidationResult(uint16(Err.UNKNOWN.value), None, None, uint32(validation_time * 1000))
+
+
+async def pre_validate_block(
     constants: ConsensusConstants,
-    block_records: BlocksProtocol,
-    blocks: Sequence[FullBlock],
+    blockchain: AugmentedBlockchain,
+    block: FullBlock,
     pool: Executor,
-    block_height_conds_map: Dict[uint32, SpendBundleConditions],
+    conds: Optional[SpendBundleConditions],
+    vs: ValidationState,
     *,
-    sub_slot_iters: uint64,
-    difficulty: uint64,
-    prev_ses_block: Optional[BlockRecord],
-    wp_summaries: Optional[List[SubEpochSummary]] = None,
-    validate_signatures: bool = True,
-) -> List[PreValidationResult]:
+    wp_summaries: Optional[list[SubEpochSummary]] = None,
+) -> Awaitable[PreValidationResult]:
     """
     This method must be called under the blockchain lock
-    If all the full blocks pass pre-validation, (only validates header), returns the list of required iters.
-    if any validation issue occurs, returns False.
+    The block passed to this function is submitted to be validated in the
+    executor passed in as "pool". The future for the job is then returned.
+    When awaited, the return value is the PreValidationResult for the block.
+    The PreValidationResult indicates whether the block was valid or not.
 
     Args:
         constants:
-        pool:
-        constants:
-        block_records:
-        blocks: list of full blocks to validate (must be connected to current chain)
-        npc_results
+        blockchain: The blockchain object to validate these blocks with respect to.
+            It's an AugmentedBlockchain to allow for previous batches of blocks to
+            be included, even if they haven't been added to the underlying blockchain
+            database yet. The blocks passed in will be added/augmented onto this blockchain.
+        pool: The executor to submit the validation jobs to
+        block: The full block to validate (must be connected to current chain)
+        conds: The SpendBundleConditions for transaction blocks, if we have one.
+            This will be computed if None is passed.
+        vs: The ValidationState refers to the state for the block.
+            This is an in-out parameter that will be updated to the validation state
+            for the next block. It includes subslot iterators, difficulty and
+            the previous sub epoch summary (ses) block.
+        wp_summaries:
+        validate_signatures:
     """
     prev_b: Optional[BlockRecord] = None
 
-    # Collects all the recent blocks (up to the previous sub-epoch)
-    recent_blocks: Dict[bytes32, BlockRecord] = {}
-    num_sub_slots_found = 0
-    num_blocks_seen = 0
+    async def return_error(error_code: Err) -> PreValidationResult:
+        return PreValidationResult(uint16(error_code.value), None, None, uint32(0))
 
-    if blocks[0].height > 0:
-        curr = block_records.try_block_record(blocks[0].prev_header_hash)
+    if block.height > 0:
+        curr = blockchain.try_block_record(block.prev_header_hash)
         if curr is None:
-            return [PreValidationResult(uint16(Err.INVALID_PREV_BLOCK_HASH.value), None, None, False, uint32(0))]
+            return return_error(Err.INVALID_PREV_BLOCK_HASH)
         prev_b = curr
-        num_sub_slots_to_look_for = 3 if curr.overflow else 2
-        header_hash = curr.header_hash
-        while (
-            curr.sub_epoch_summary_included is None
-            or num_blocks_seen < constants.NUMBER_OF_TIMESTAMPS
-            or num_sub_slots_found < num_sub_slots_to_look_for
-        ) and curr.height > 0:
-            if curr.first_in_sub_slot:
-                assert curr.finished_challenge_slot_hashes is not None
-                num_sub_slots_found += len(curr.finished_challenge_slot_hashes)
-            recent_blocks[header_hash] = curr
-            if curr.is_transaction_block:
-                num_blocks_seen += 1
-            header_hash = curr.prev_hash
-            curr = block_records.block_record(curr.prev_hash)
-            assert curr is not None
-        recent_blocks[header_hash] = curr
-
-    # the agumented blockchain object will let us add temporary block records
-    # they won't actually be added to the underlying blockchain object
-    blockchain = AugmentedBlockchain(block_records)
-
-    diff_ssis: List[Tuple[uint64, uint64]] = []
-    prev_ses_block_list: List[Optional[BlockRecord]] = []
-
-    for block in blocks:
-        if len(block.finished_sub_slots) > 0:
-            if block.finished_sub_slots[0].challenge_chain.new_difficulty is not None:
-                difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty
-            if block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None:
-                sub_slot_iters = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
-        overflow = is_overflow_block(constants, block.reward_chain_block.signage_point_index)
-        challenge = get_block_challenge(constants, block, BlockCache(recent_blocks), prev_b is None, overflow, False)
-        if block.reward_chain_block.challenge_chain_sp_vdf is None:
-            cc_sp_hash: bytes32 = challenge
-        else:
-            cc_sp_hash = block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
-        q_str: Optional[bytes32] = verify_and_get_quality_string(
-            block.reward_chain_block.proof_of_space, constants, challenge, cc_sp_hash, height=block.height
-        )
-        if q_str is None:
-            return [PreValidationResult(uint16(Err.INVALID_POSPACE.value), None, None, False, uint32(0))]
-
-        required_iters: uint64 = calculate_iterations_quality(
-            constants.DIFFICULTY_CONSTANT_FACTOR,
-            q_str,
-            block.reward_chain_block.proof_of_space.size,
-            difficulty,
-            cc_sp_hash,
-        )
 
-        try:
-            block_rec = block_to_block_record(
-                constants,
-                blockchain,
-                required_iters,
-                block,
-                sub_slot_iters=sub_slot_iters,
-                prev_ses_block=prev_ses_block,
-            )
-        except ValueError:
-            return [PreValidationResult(uint16(Err.INVALID_SUB_EPOCH_SUMMARY.value), None, None, False, uint32(0))]
-
-        if block_rec.sub_epoch_summary_included is not None and wp_summaries is not None:
-            next_ses = wp_summaries[int(block.height / constants.SUB_EPOCH_BLOCKS) - 1]
-            if not block_rec.sub_epoch_summary_included.get_hash() == next_ses.get_hash():
-                log.error("sub_epoch_summary does not match wp sub_epoch_summary list")
-                return [PreValidationResult(uint16(Err.INVALID_SUB_EPOCH_SUMMARY.value), None, None, False, uint32(0))]
-
-        recent_blocks[block_rec.header_hash] = block_rec
-        blockchain.add_extra_block(block, block_rec)  # Temporarily add block to chain
-        prev_b = block_rec
-        diff_ssis.append((difficulty, sub_slot_iters))
-        prev_ses_block_list.append(prev_ses_block)
-        if block_rec.sub_epoch_summary_included is not None:
-            prev_ses_block = block_rec
-
-    conditions_pickled = {}
-    for k, v in block_height_conds_map.items():
-        conditions_pickled[k] = bytes(v)
-    futures = []
-    # Pool of workers to validate blocks concurrently
-    recent_blocks_bytes = {bytes(k): bytes(v) for k, v in recent_blocks.items()}  # convert to bytes
-
-    batch_size = 4
-    for i in range(0, len(blocks), batch_size):
-        end_i = min(i + batch_size, len(blocks))
-        blocks_to_validate = blocks[i:end_i]
-        b_pickled: List[bytes] = []
-        previous_generators: List[Optional[List[bytes]]] = []
-        for block in blocks_to_validate:
-            assert isinstance(block, FullBlock)
-            b_pickled.append(bytes(block))
-            try:
-                block_generator: Optional[BlockGenerator] = await get_block_generator(
-                    blockchain.lookup_block_generators, block
-                )
-            except ValueError:
-                return [
-                    PreValidationResult(
-                        uint16(Err.FAILED_GETTING_GENERATOR_MULTIPROCESSING.value), None, None, False, uint32(0)
-                    )
-                ]
-            if block_generator is not None:
-                previous_generators.append(block_generator.generator_refs)
-            else:
-                previous_generators.append(None)
-
-        ses_blocks_bytes_list: List[Optional[bytes]] = []
-        for j in range(i, end_i):
-            ses_block_rec = prev_ses_block_list[j]
-            if ses_block_rec is None:
-                ses_blocks_bytes_list.append(None)
-            else:
-                ses_blocks_bytes_list.append(bytes(ses_block_rec))
-
-        futures.append(
-            asyncio.get_running_loop().run_in_executor(
-                pool,
-                batch_pre_validate_blocks,
-                constants,
-                recent_blocks_bytes,
-                b_pickled,
-                previous_generators,
-                conditions_pickled,
-                [diff_ssis[j][0] for j in range(i, end_i)],
-                [diff_ssis[j][1] for j in range(i, end_i)],
-                validate_signatures,
-                ses_blocks_bytes_list,
-            )
-        )
-    # Collect all results into one flat list
-    return [
-        PreValidationResult.from_bytes(result)
-        for batch_result in (await asyncio.gather(*futures))
-        for result in batch_result
-    ]
+    assert isinstance(block, FullBlock)
+    if len(block.finished_sub_slots) > 0:
+        if block.finished_sub_slots[0].challenge_chain.new_difficulty is not None:
+            vs.difficulty = block.finished_sub_slots[0].challenge_chain.new_difficulty
+        if block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters is not None:
+            vs.ssi = block.finished_sub_slots[0].challenge_chain.new_sub_slot_iters
+    overflow = is_overflow_block(constants, block.reward_chain_block.signage_point_index)
+    challenge = get_block_challenge(constants, block, blockchain, prev_b is None, overflow, False)
+    if block.reward_chain_block.challenge_chain_sp_vdf is None:
+        cc_sp_hash: bytes32 = challenge
+    else:
+        cc_sp_hash = block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
+    q_str: Optional[bytes32] = verify_and_get_quality_string(
+        block.reward_chain_block.proof_of_space, constants, challenge, cc_sp_hash, height=block.height
+    )
+    if q_str is None:
+        return return_error(Err.INVALID_POSPACE)
 
+    required_iters: uint64 = calculate_iterations_quality(
+        constants.DIFFICULTY_CONSTANT_FACTOR,
+        q_str,
+        block.reward_chain_block.proof_of_space.size,
+        vs.difficulty,
+        cc_sp_hash,
+    )
 
-def _run_generator(
-    constants: ConsensusConstants,
-    unfinished_block_bytes: bytes,
-    block_generator_bytes: bytes,
-    height: uint32,
-) -> Optional[bytes]:
-    """
-    Runs the CLVM generator from bytes inputs. This is meant to be called under a ProcessPoolExecutor, in order to
-    validate the heavy parts of a block (clvm program) in a different process.
-    """
     try:
-        unfinished_block: UnfinishedBlock = UnfinishedBlock.from_bytes(unfinished_block_bytes)
-        assert unfinished_block.transactions_info is not None
-        block_generator: BlockGenerator = BlockGenerator.from_bytes(block_generator_bytes)
-        assert block_generator.program == unfinished_block.transactions_generator
-        npc_result: NPCResult = get_name_puzzle_conditions(
-            block_generator,
-            min(constants.MAX_BLOCK_COST_CLVM, unfinished_block.transactions_info.cost),
-            mempool_mode=False,
-            height=height,
-            constants=constants,
+        block_rec = block_to_block_record(
+            constants,
+            blockchain,
+            required_iters,
+            block,
+            sub_slot_iters=vs.ssi,
+            prev_ses_block=vs.prev_ses_block,
         )
-        return bytes(npc_result)
-    except ValidationError as e:
-        return bytes(NPCResult(uint16(e.code.value), None))
-    except Exception:
-        return bytes(NPCResult(uint16(Err.UNKNOWN.value), None))
+    except ValueError:
+        log.exception("block_to_block_record()")
+        return return_error(Err.INVALID_SUB_EPOCH_SUMMARY)
+
+    if block_rec.sub_epoch_summary_included is not None and wp_summaries is not None:
+        next_ses = wp_summaries[int(block.height / constants.SUB_EPOCH_BLOCKS) - 1]
+        if not block_rec.sub_epoch_summary_included.get_hash() == next_ses.get_hash():
+            log.error("sub_epoch_summary does not match wp sub_epoch_summary list")
+            return return_error(Err.INVALID_SUB_EPOCH_SUMMARY)
+
+    blockchain.add_extra_block(block, block_rec)  # Temporarily add block to chain
+    prev_b = block_rec
+
+    previous_generators: Optional[list[bytes]] = None
+
+    try:
+        block_generator: Optional[BlockGenerator] = await get_block_generator(blockchain.lookup_block_generators, block)
+        if block_generator is not None:
+            previous_generators = block_generator.generator_refs
+    except ValueError:
+        return return_error(Err.FAILED_GETTING_GENERATOR_MULTIPROCESSING)
+
+    future = asyncio.get_running_loop().run_in_executor(
+        pool,
+        _pre_validate_block,
+        constants,
+        blockchain,
+        block,
+        previous_generators,
+        conds,
+        copy.copy(vs),
+    )
+
+    if block_rec.sub_epoch_summary_included is not None:
+        vs.prev_ses_block = block_rec
+
+    return future

chia/consensus/vdf_info_computation.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import List, Optional, Tuple
+from typing import Optional
 
 from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
@@ -13,13 +13,13 @@ from chia.util.ints import uint64, uint128
 
 def get_signage_point_vdf_info(
     constants: ConsensusConstants,
-    finished_sub_slots: List[EndOfSubSlotBundle],
+    finished_sub_slots: list[EndOfSubSlotBundle],
     overflow: bool,
     prev_b: Optional[BlockRecord],
     blocks: BlockRecordsProtocol,
     sp_total_iters: uint128,
     sp_iters: uint64,
-) -> Tuple[bytes32, bytes32, ClassgroupElement, ClassgroupElement, uint64, uint64]:
+) -> tuple[bytes32, bytes32, ClassgroupElement, ClassgroupElement, uint64, uint64]:
     """
     Returns the following information, for the VDF of the signage point at sp_total_iters.
     cc and rc challenge hash