@lodestar/state-transition 1.44.0-dev.6ef8199cfa → 1.44.0-dev.762dd5f186

package/src/stateView/stateViewFactory.ts

@@ -31,6 +31,7 @@ type NativeOpts = {
 export function createBeaconStateView(opts: NodeJSOpts | NativeOpts): IBeaconStateView {
   if (opts.useNative) {
     throw new Error("Native (Zig) BeaconStateView not yet implemented");
+    // TODO: return a new instance of NativeBeaconStateView
   }
   const {anchorState, config, pubkeyCache} = opts;
   const cachedState = createCachedBeaconState(anchorState, {config, pubkeyCache}, {skipSyncPubkeys: true});
@@ -69,6 +70,7 @@ type RegenNativeOpts = {
 export function createBeaconStateViewForHistoricalRegen(opts: RegenNodeJSOpts | RegenNativeOpts): IBeaconStateView {
   if (opts.useNative) {
     throw new Error("Native (Zig) BeaconStateView not yet implemented");
+    // TODO: return a new instance of NativeBeaconStateView
   }
   const {config, stateBytes} = opts;
   const state = getStateTypeFromBytes(config, stateBytes).deserializeToViewDU(stateBytes);

package/src/util/epochShuffling.ts

@@ -124,7 +124,7 @@ export async function computeEpochShufflingAsync(
 }
 
 export function calculateDecisionRoot(state: BeaconStateAllForks, epoch: Epoch): RootHex {
-  const pivotSlot = computeStartSlotAtEpoch(epoch - 1) - 1;
+  const pivotSlot = Math.max(GENESIS_SLOT, computeStartSlotAtEpoch(epoch - 1) - 1);
   return toRootHex(getBlockRootAtSlot(state, pivotSlot));
 }
 

package/src/util/gloas.ts

@@ -1,8 +1,11 @@
+import {PublicKey, Signature, verify} from "@chainsafe/blst";
+import {BeaconConfig} from "@lodestar/config";
 import {
   BUILDER_INDEX_FLAG,
   BUILDER_PAYMENT_THRESHOLD_DENOMINATOR,
   BUILDER_PAYMENT_THRESHOLD_NUMERATOR,
   BUILDER_WITHDRAWAL_PREFIX,
+  DOMAIN_BUILDER_DEPOSIT,
   EFFECTIVE_BALANCE_INCREMENT,
   FAR_FUTURE_EPOCH,
   MIN_DEPOSIT_AMOUNT,
@@ -10,15 +13,18 @@ import {
   PTC_SIZE,
   SLOTS_PER_EPOCH,
 } from "@lodestar/params";
-import {BuilderIndex, Epoch, ValidatorIndex, gloas} from "@lodestar/types";
+import {BuilderIndex, Epoch, ValidatorIndex, gloas, ssz} from "@lodestar/types";
 import {AttestationData} from "@lodestar/types/phase0";
 import {byteArrayEquals} from "@lodestar/utils";
+import {ZERO_HASH} from "../constants/index.js";
 import {CachedBeaconStateFulu, CachedBeaconStateGloas} from "../types.js";
 import {getBlockRootAtSlot} from "./blockRoot.js";
+import {computeDomain} from "./domain.js";
 import {computeEpochAtSlot} from "./epoch.js";
 import {computeEpochShuffling} from "./epochShuffling.js";
 import {RootCache} from "./rootCache.js";
 import {computePayloadTimelinessCommitteesForEpoch} from "./seed.js";
+import {computeSigningRoot} from "./signingRoot.js";
 import {getActiveValidatorIndices} from "./validator.js";
 
 export function isBuilderWithdrawalCredential(withdrawalCredentials: Uint8Array): boolean {
@@ -73,6 +79,34 @@ export function isActiveBuilder(builder: gloas.Builder, finalizedEpoch: Epoch):
   return builder.depositEpoch < finalizedEpoch && builder.withdrawableEpoch === FAR_FUTURE_EPOCH;
 }
 
+/**
+ * Compute the gas limit that satisfies the EIP-1559 adjustment rule from `parentGasLimit`,
+ * clamping `targetGasLimit` into the allowed window of `±max(parentGasLimit / 1024, 1) - 1`.
+ *
+ * From https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1559.md
+ */
+export function getExpectedGasLimit(parentGasLimit: number, targetGasLimit: number): number {
+  const maxGasLimitDifference = Math.max(Math.floor(parentGasLimit / 1024), 1) - 1;
+
+  if (targetGasLimit > parentGasLimit) {
+    const gasDiff = targetGasLimit - parentGasLimit;
+    return parentGasLimit + Math.min(gasDiff, maxGasLimitDifference);
+  }
+
+  const gasDiff = parentGasLimit - targetGasLimit;
+  return parentGasLimit - Math.min(gasDiff, maxGasLimitDifference);
+}
+
+/**
+ * Check if `gasLimit` is compatible with `targetGasLimit` under the EIP-1559 transition rule
+ * from `parentGasLimit`. The bid must hit `targetGasLimit` when the target is within one
+ * adjustment step of the parent, otherwise it must hit the clamped boundary.
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.8/specs/gloas/builder.md#new-is_gas_limit_target_compatible
+ */
+export function isGasLimitTargetCompatible(parentGasLimit: number, gasLimit: number, targetGasLimit: number): boolean {
+  return gasLimit === getExpectedGasLimit(parentGasLimit, targetGasLimit);
+}
+
 /**
  * Get the total pending balance to withdraw for a builder (from withdrawals + payments).
  * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.1/specs/gloas/beacon-chain.md#new-get_pending_balance_to_withdraw_for_builder
@@ -213,3 +247,72 @@ export function getPtcWindowEpochCacheData(state: CachedBeaconStateGloas): {
     nextPayloadTimelinessCommittees: toUint32Arrays(nextPtcWindow),
   };
 }
+
+/**
+ * Add a new builder to the builders registry. Reuses slots from exited and fully withdrawn
+ * builders when available, otherwise appends.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#new-add_builder_to_registry
+ */
+export function addBuilderToRegistry(
+  state: CachedBeaconStateGloas,
+  pubkey: Uint8Array,
+  version: number,
+  executionAddress: Uint8Array,
+  amount: number,
+  slot: number
+): void {
+  const currentEpoch = computeEpochAtSlot(state.slot);
+  const depositEpoch = computeEpochAtSlot(slot);
+
+  let builderIndex = state.builders.length;
+  for (let i = 0; i < state.builders.length; i++) {
+    const builder = state.builders.getReadonly(i);
+    if (builder.withdrawableEpoch <= currentEpoch && builder.balance === 0) {
+      builderIndex = i;
+      break;
+    }
+  }
+
+  const newBuilder = ssz.gloas.Builder.toViewDU({
+    pubkey,
+    version,
+    executionAddress,
+    balance: amount,
+    depositEpoch,
+    withdrawableEpoch: FAR_FUTURE_EPOCH,
+  });
+
+  if (builderIndex < state.builders.length) {
+    state.builders.set(builderIndex, newBuilder);
+  } else {
+    state.builders.push(newBuilder);
+  }
+}
+
+/**
+ * Verify the proof of possession on a builder deposit request.
+ *
+ * The dedicated `DOMAIN_BUILDER_DEPOSIT` (vs the validator `DOMAIN_DEPOSIT`) prevents replay
+ * of validator deposit signatures against the builder deposit contract and vice versa.
+ *
+ * Spec: https://github.com/ethereum/consensus-specs/blob/v1.7.0-alpha.11/specs/gloas/beacon-chain.md#new-is_valid_builder_deposit_signature
+ */
+export function isValidBuilderDepositSignature(
+  config: BeaconConfig,
+  pubkey: Uint8Array,
+  withdrawalCredentials: Uint8Array,
+  amount: number,
+  signature: Uint8Array
+): boolean {
+  const depositMessage = {pubkey, withdrawalCredentials, amount};
+  const domain = computeDomain(DOMAIN_BUILDER_DEPOSIT, config.GENESIS_FORK_VERSION, ZERO_HASH);
+  const signingRoot = computeSigningRoot(ssz.phase0.DepositMessage, depositMessage, domain);
+  try {
+    const publicKey = PublicKey.fromBytes(pubkey, true);
+    const sig = Signature.fromBytes(signature, true);
+    return verify(signingRoot, publicKey, sig);
+  } catch (_e) {
+    return false;
+  }
+}

package/src/util/shuffling.ts

@@ -21,8 +21,8 @@ import {EpochShuffling} from "./epochShuffling.js";
  * Computed for the requested epoch, not `state.epoch`, so it is correct when `state` is one
  * epoch off the requested epoch (e.g. serving next-epoch duties from the current state).
  *
- * Returns `null` when the genesis block decides its own shuffling (caller falls back to the
- * genesis block root).
+ * Returns `null` when the decision block is not in the state's past (the genesis block decides
+ * its own shuffling, or it has not been produced yet); caller supplies the fallback.
  */
 export function proposerShufflingDecisionRoot(
   fork: ForkName,
@@ -30,7 +30,8 @@ export function proposerShufflingDecisionRoot(
   proposalEpoch: Epoch
 ): Root | null {
   const decisionSlot = proposerShufflingDecisionSlot(fork, proposalEpoch);
-  if (state.slot === decisionSlot) {
+  // Return null when the decision block is not in the state's past or the getBlockRootAtSlot() api will throw
+  if (decisionSlot >= state.slot) {
     return null;
   }
   return state.getBlockRootAtSlot(decisionSlot);