op-besu

diff --git hyperledger/besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/Transaction.java optimism-java/op-besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/Transaction.java index d6751852bce8c19951abf5564bef79bbb6a940dc..5f244b0e16da029b7fe81fb68a4ae37461471089 100644 --- hyperledger/besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/Transaction.java +++ optimism-java/op-besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/Transaction.java @@ -208,6 +208,34 @@ */ Optional<BlobsWithCommitments> getBlobsWithCommitments();   /** + * Return the source hash for this transaction. + * + * @return optional source hash + */ + Optional<Hash> getSourceHash(); + + /** + * Return the mint value for this transaction. + * + * @return optional mint value + */ + Optional<Wei> getMint(); + + /** + * Return the is system transaction flag for this transaction. + * + * @return optional is system transaction flag + */ + Optional<Boolean> getIsSystemTx(); + + /** + * Return the roll up gas data. + * + * @return roll up gas data + */ + RollupGasData getRollupGasData(); + + /** * Return the address of the contract, if the transaction creates one * * @return address of new contract or empty otherwise

diff --git hyperledger/besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/TransactionType.java optimism-java/op-besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/TransactionType.java index df4a07193b8ef96623841236b7287c36c271dedb..b52ac76cfc9c9ef8c6f57bb201d00421f79c5b1b 100644 --- hyperledger/besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/TransactionType.java +++ optimism-java/op-besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/TransactionType.java @@ -29,7 +29,9 @@ EIP1559(0x02), /** Blob transaction type. */ BLOB(0x03), /** Eip7702 transaction type. */ - SET_CODE(0x04); + SET_CODE(0x04), + /** Optimism Deposit transaction type. */ + OPTIMISM_DEPOSIT(0x7e);   private static final Set<TransactionType> ACCESS_LIST_SUPPORTED_TRANSACTION_TYPES = Set.of(ACCESS_LIST, EIP1559, BLOB, SET_CODE); @@ -86,6 +88,7 @@ TransactionType.FRONTIER, TransactionType.ACCESS_LIST, TransactionType.EIP1559, TransactionType.BLOB, + TransactionType.OPTIMISM_DEPOSIT, TransactionType.SET_CODE }) .filter(transactionType -> transactionType.typeValue == serializedTypeValue) @@ -111,7 +114,7 @@ * * @return the boolean */ public boolean supports1559FeeMarket() { - return !LEGACY_FEE_MARKET_TRANSACTION_TYPES.contains(this); + return !LEGACY_FEE_MARKET_TRANSACTION_TYPES.contains(this) && !this.equals(OPTIMISM_DEPOSIT); }   /** @@ -120,7 +123,7 @@ * * @return the boolean */ public boolean requiresChainId() { - return !this.equals(FRONTIER); + return !this.equals(FRONTIER) && !this.equals(OPTIMISM_DEPOSIT); }   /**

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/Transaction.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/Transaction.java index 513cfb8319d4f3b89a33f3f864b42917958082f6..ffe2709ad0e57384e56cd92b2429bdf988964996 100644 --- hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/Transaction.java +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/Transaction.java @@ -31,6 +31,7 @@ import org.hyperledger.besu.datatypes.BlobsWithCommitments; import org.hyperledger.besu.datatypes.Hash; import org.hyperledger.besu.datatypes.KZGCommitment; import org.hyperledger.besu.datatypes.KZGProof; +import org.hyperledger.besu.datatypes.RollupGasData; import org.hyperledger.besu.datatypes.SetCodeAuthorization; import org.hyperledger.besu.datatypes.Sha256Hash; import org.hyperledger.besu.datatypes.TransactionType; @@ -126,6 +127,12 @@ private final Optional<BlobsWithCommitments> blobsWithCommitments; private final Optional<List<SetCodeAuthorization>> maybeAuthorizationList;   + private final Optional<Hash> sourceHash; + + private final Optional<Wei> mint; + + private final Optional<Boolean> isSystemTx; + public static Builder builder() { return new Builder(); } @@ -162,6 +169,9 @@ * <p>The {@code to} will be an {@code Optional.empty()} for a contract creation transaction; * otherwise it should contain an address. * <p>The {@code chainId} must be greater than 0 to be applied to a specific chain; otherwise * it will default to any chain. + * @param sourceHash Hash that uniquely identifies the source of the deposit. + * @param mint The ETH value to mint on L2. + * @param isSystemTx Field indicating if this transaction is exempt from the L2 gas limit. */ private Transaction( final boolean forCopy, @@ -181,7 +191,10 @@ final Address sender, final Optional<BigInteger> chainId, final Optional<List<VersionedHash>> versionedHashes, final Optional<BlobsWithCommitments> blobsWithCommitments, - final Optional<List<SetCodeAuthorization>> maybeAuthorizationList) { + final Optional<List<SetCodeAuthorization>> maybeAuthorizationList, + final Optional<Hash> sourceHash, + final Optional<Wei> mint, + final Optional<Boolean> isSystemTx) {   if (!forCopy) { if (transactionType.requiresChainId()) { @@ -242,6 +255,9 @@ this.chainId = chainId; this.versionedHashes = versionedHashes; this.blobsWithCommitments = blobsWithCommitments; this.maybeAuthorizationList = maybeAuthorizationList; + this.sourceHash = sourceHash; + this.mint = mint; + this.isSystemTx = isSystemTx; }   /** @@ -251,6 +267,9 @@ * @return the transaction nonce */ @Override public long getNonce() { + if (TransactionType.OPTIMISM_DEPOSIT.equals(transactionType)) { + return 0L; + } return nonce; }   @@ -304,7 +323,9 @@ public Wei getEffectivePriorityFeePerGas(final Optional<Wei> maybeBaseFee) { return maybeBaseFee .map( baseFee -> { - if (getType().supports1559FeeMarket()) { + if (getType().equals(TransactionType.OPTIMISM_DEPOSIT)) { + return Wei.ZERO; + } else if (getType().supports1559FeeMarket()) { if (baseFee.greaterOrEqualThan(getMaxFeePerGas().get())) { return Wei.ZERO; } @@ -426,7 +447,7 @@ * @return the transaction sender */ @Override public Address getSender() { - if (sender == null) { + if (sender == null && !TransactionType.OPTIMISM_DEPOSIT.equals(getType())) { Optional<Address> cachedSender = Optional.ofNullable(senderCache.getIfPresent(getHash())); sender = cachedSender.orElseGet(this::computeSender); } @@ -497,16 +518,25 @@ }   @Override public BigInteger getR() { + if (TransactionType.OPTIMISM_DEPOSIT.equals(getType())) { + return BigInteger.ZERO; + } return signature.getR(); }   @Override public BigInteger getS() { + if (TransactionType.OPTIMISM_DEPOSIT.equals(getType())) { + return BigInteger.ZERO; + } return signature.getS(); }   @Override public BigInteger getV() { + if (TransactionType.OPTIMISM_DEPOSIT.equals(getType())) { + return BigInteger.ZERO; + } if (transactionType != null && transactionType != TransactionType.FRONTIER) { // EIP-2718 typed transaction, use yParity: return null; @@ -520,7 +550,9 @@ }   @Override public BigInteger getYParity() { - if (transactionType != null && transactionType != TransactionType.FRONTIER) { + if (transactionType != null + && transactionType != TransactionType.FRONTIER + && transactionType != TransactionType.OPTIMISM_DEPOSIT) { // EIP-2718 typed transaction, return yParity: return BigInteger.valueOf(signature.getRecId()); } else { @@ -641,6 +673,9 @@ * * @return max fee per gas in wei */ public Wei getMaxGasPrice() { + if (TransactionType.OPTIMISM_DEPOSIT.equals(getType())) { + return Wei.ZERO; + } return maxFeePerGas.orElseGet( () -> gasPrice.orElseThrow( @@ -662,6 +697,9 @@ * @param baseFeePerGas optional baseFee from the block header, if we are post-london * @return the effective gas price. */ public final Wei getEffectiveGasPrice(final Optional<Wei> baseFeePerGas) { + if (TransactionType.OPTIMISM_DEPOSIT.equals(getType())) { + return Wei.ZERO; + } return getEffectivePriorityFeePerGas(baseFeePerGas).addExact(baseFeePerGas.orElse(Wei.ZERO)); }   @@ -690,6 +728,27 @@ public int authorizationListSize() { return maybeAuthorizationList.map(List::size).orElse(0); }   + @Override + public Optional<Hash> getSourceHash() { + return sourceHash; + } + + @Override + public Optional<Wei> getMint() { + return mint; + } + + @Override + public Optional<Boolean> getIsSystemTx() { + return isSystemTx; + } + + @Override + public RollupGasData getRollupGasData() { + return RollupGasData.fromPayload( + TransactionEncoder.encodeOpaqueBytes(this, EncodingContext.BLOCK_BODY)); + } + /** * Return the list of transaction hashes extracted from the collection of Transaction passed as * argument @@ -759,6 +818,8 @@ () -> new IllegalStateException( "Developer error: the transaction should be guaranteed to have an access list here")), chainId); + // Optimism deposit transaction sender will never be empty + case OPTIMISM_DEPOSIT -> Bytes.EMPTY; case SET_CODE -> setCodePreimage( nonce, @@ -1111,7 +1172,10 @@ sender, chainId, detachedVersionedHashes, detachedBlobsWithCommitments, - maybeAuthorizationList); + maybeAuthorizationList, + sourceHash, + mint, + isSystemTx);   // copy also the computed fields, to avoid to recompute them copiedTx.sender = this.sender; @@ -1180,6 +1244,10 @@ protected Optional<BigInteger> v = Optional.empty(); protected List<VersionedHash> versionedHashes = null; private BlobsWithCommitments blobsWithCommitments; protected Optional<List<SetCodeAuthorization>> setCodeTransactionPayloads = Optional.empty(); + + protected Hash sourceHash; + protected Wei mint; + protected Boolean isSystemTx;   public Builder copiedFrom(final Transaction toCopy) { this.transactionType = toCopy.transactionType; @@ -1285,8 +1353,25 @@ this.versionedHashes = versionedHashes; return this; }   + public Builder sourceHash(final Hash sourceHash) { + this.sourceHash = sourceHash; + return this; + } + + public Builder mint(final Wei mint) { + this.mint = mint; + return this; + } + + public Builder isSystemTx(final Boolean isSystemTx) { + this.isSystemTx = isSystemTx; + return this; + } + public Builder guessType() { - if (versionedHashes != null && !versionedHashes.isEmpty()) { + if (sourceHash != null || transactionType == TransactionType.OPTIMISM_DEPOSIT) { + transactionType = TransactionType.OPTIMISM_DEPOSIT; + } else if (versionedHashes != null && !versionedHashes.isEmpty()) { transactionType = TransactionType.BLOB; } else if (maxPriorityFeePerGas != null || maxFeePerGas != null) { transactionType = TransactionType.EIP1559; @@ -1324,7 +1409,10 @@ sender, chainId, Optional.ofNullable(versionedHashes), Optional.ofNullable(blobsWithCommitments), - setCodeTransactionPayloads); + setCodeTransactionPayloads, + Optional.ofNullable(sourceHash), + Optional.ofNullable(mint), + Optional.ofNullable(isSystemTx)); }   public Transaction signAndBuild(final KeyPair keys) {

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/TransactionReceipt.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/TransactionReceipt.java index 79fb1a50149a5bb92139f72d71c7452e5d9085b0..b1f217b37e2fab2fc5f188129d2f983918840d3f 100644 --- hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/TransactionReceipt.java +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/TransactionReceipt.java @@ -58,6 +58,9 @@ private final int status; private final TransactionReceiptType transactionReceiptType; private final Optional<Bytes> revertReason;   + private final Optional<Long> depositNonce; + private final Optional<Long> depositReceiptVersion; + /** * Creates an instance of a state root-encoded transaction receipt. * @@ -78,25 +81,29 @@ NONEXISTENT, cumulativeGasUsed, logs, LogsBloomFilter.builder().insertLogs(logs).build(), - revertReason); + revertReason, + Optional.empty(), + Optional.empty()); }   - private TransactionReceipt( - final TransactionType transactionType, - final Hash stateRoot, - final long cumulativeGasUsed, - final List<Log> logs, - final LogsBloomFilter bloomFilter, - final Optional<Bytes> revertReason) { - this( - transactionType, - stateRoot, - NONEXISTENT, - cumulativeGasUsed, - logs, - bloomFilter, - revertReason); - } + // private TransactionReceipt( + // final TransactionType transactionType, + // final Hash stateRoot, + // final long cumulativeGasUsed, + // final List<Log> logs, + // final LogsBloomFilter bloomFilter, + // final Optional<Bytes> revertReason) { + // this( + // transactionType, + // stateRoot, + // NONEXISTENT, + // cumulativeGasUsed, + // logs, + // bloomFilter, + // revertReason, + // Optional.empty(), + // Optional.empty()); + // }   /** * Creates an instance of a status-encoded transaction receipt. @@ -118,7 +125,9 @@ status, cumulativeGasUsed, logs, LogsBloomFilter.builder().insertLogs(logs).build(), - revertReason); + revertReason, + Optional.empty(), + Optional.empty()); }   public TransactionReceipt( @@ -128,7 +137,16 @@ final long cumulativeGasUsed, final List<Log> logs, final LogsBloomFilter bloomFilter, final Optional<Bytes> revertReason) { - this(transactionType, null, status, cumulativeGasUsed, logs, bloomFilter, revertReason); + this( + transactionType, + null, + status, + cumulativeGasUsed, + logs, + bloomFilter, + revertReason, + Optional.empty(), + Optional.empty()); }   public TransactionReceipt( @@ -146,14 +164,36 @@ LogsBloomFilter.builder().insertLogs(logs).build(), maybeRevertReason); }   - private TransactionReceipt( + public TransactionReceipt( + final TransactionType transactionType, + final int status, + final long cumulativeGasUsed, + final List<Log> logs, + final Optional<Bytes> maybeRevertReason, + final Optional<Long> depositNonce, + final Optional<Long> depositReceiptVersion) { + this( + transactionType, + null, + status, + cumulativeGasUsed, + logs, + LogsBloomFilter.builder().insertLogs(logs).build(), + maybeRevertReason, + depositNonce, + depositReceiptVersion); + } + + public TransactionReceipt( final TransactionType transactionType, final Hash stateRoot, final int status, final long cumulativeGasUsed, final List<Log> logs, final LogsBloomFilter bloomFilter, - final Optional<Bytes> revertReason) { + final Optional<Bytes> revertReason, + final Optional<Long> depositNonce, + final Optional<Long> depositReceiptVersion) { this.transactionType = transactionType; this.stateRoot = stateRoot; this.cumulativeGasUsed = cumulativeGasUsed; @@ -162,6 +202,8 @@ this.logs = logs; this.bloomFilter = bloomFilter; this.transactionReceiptType = stateRoot == null ? TransactionReceiptType.STATUS : TransactionReceiptType.ROOT; + this.depositNonce = depositNonce; + this.depositReceiptVersion = depositReceiptVersion; this.revertReason = revertReason; }   @@ -204,10 +246,38 @@ } else { rlpOutput.writeLongScalar(status); } rlpOutput.writeLongScalar(cumulativeGasUsed); + // TODO + + // Optional<Bytes> revertReason = Optional.empty(); + // Optional<Long> depositNonce = Optional.empty(); + // Optional<Long> depositReceptVersion = Optional.empty(); + // + // var element = input.readBytes(); + // if (input.isEndOfCurrentList() && revertReasonAllowed) { + // revertReason = Optional.of(element); + // } else { + // depositNonce = Optional.of(element).map(Bytes::toLong); + // depositReceptVersion = Optional.of(input.readBytes()).map(Bytes::toLong); + // } + // if (revertReasonAllowed && revertReason.isEmpty()) { + // if (!input.isEndOfCurrentList()) { + // revertReason = Optional.of(input.readBytes()); + // } + // } else if (!revertReasonAllowed && !input.isEndOfCurrentList()) { + // throw new RLPException("Unexpected value at end of TransactionReceipt"); + // } + if (!compacted) { rlpOutput.writeBytes(bloomFilter); } rlpOutput.writeList(logs, (log, logOutput) -> log.writeTo(logOutput, compacted)); + + if (transactionType.equals(TransactionType.OPTIMISM_DEPOSIT) + && depositReceiptVersion.isPresent()) { + depositNonce.ifPresentOrElse(rlpOutput::writeLongScalar, rlpOutput::writeNull); + depositReceiptVersion.ifPresentOrElse(rlpOutput::writeLongScalar, rlpOutput::writeNull); + } + if (withRevertReason && revertReason.isPresent()) { rlpOutput.writeBytes(revertReason.get()); } @@ -254,6 +324,7 @@ if (hasLogs) { // The logs below will populate the bloom filter upon construction. bloomFilter = LogsBloomFilter.readFrom(input); } + // TODO consider validating that the logs and bloom filter match. final boolean compacted = !hasLogs; final List<Log> logs = input.readList(logInput -> Log.readFrom(logInput, compacted)); @@ -261,14 +332,21 @@ if (compacted) { bloomFilter = LogsBloomFilter.builder().insertLogs(logs).build(); }   - final Optional<Bytes> revertReason; - if (input.isEndOfCurrentList()) { - revertReason = Optional.empty(); - } else { - if (!revertReasonAllowed) { - throw new RLPException("Unexpected value at end of TransactionReceipt"); + Optional<Bytes> revertReason = Optional.empty(); + Optional<Long> depositNonce = Optional.empty(); + Optional<Long> depositReceptVersion = Optional.empty(); + + if (!input.isEndOfCurrentList()) { + var element = input.readBytes(); + if (!input.isEndOfCurrentList() && transactionType == TransactionType.OPTIMISM_DEPOSIT) { + depositNonce = Optional.of(element).map(Bytes::toLong); + depositReceptVersion = Optional.of(input.readBytes()).map(Bytes::toLong); + } else { + if (!revertReasonAllowed || !input.isEndOfCurrentList()) { + throw new RLPException("Unexpected value at end of TransactionReceipt"); + } + revertReason = Optional.of(element); } - revertReason = Optional.of(input.readBytes()); }   // Status code-encoded transaction receipts have a single @@ -277,12 +355,28 @@ if (firstElement.raw().size() == 1) { final int status = firstElement.readIntScalar(); input.leaveList(); return new TransactionReceipt( - transactionType, status, cumulativeGas, logs, bloomFilter, revertReason); + transactionType, + null, + status, + cumulativeGas, + logs, + bloomFilter, + revertReason, + depositNonce, + depositReceptVersion); } else { final Hash stateRoot = Hash.wrap(firstElement.readBytes32()); input.leaveList(); return new TransactionReceipt( - transactionType, stateRoot, cumulativeGas, logs, bloomFilter, revertReason); + transactionType, + stateRoot, + -1, + cumulativeGas, + logs, + bloomFilter, + revertReason, + depositNonce, + depositReceptVersion); } }   @@ -351,6 +445,14 @@ @Override public Optional<Bytes> getRevertReason() { return revertReason; + } + + public Optional<Long> getDepositNonce() { + return depositNonce; + } + + public Optional<Long> getDepositReceiptVersion() { + return depositReceiptVersion; }   @Override

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/OptimismDepositTransactionDecoder.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/OptimismDepositTransactionDecoder.java new file mode 100644 index 0000000000000000000000000000000000000000..23f888f899667244a1c0c299542c41d1819d24fb --- /dev/null +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/OptimismDepositTransactionDecoder.java @@ -0,0 +1,44 @@ +/* + * Copyright contributors to Hyperledger Besu. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + */ +package org.hyperledger.besu.ethereum.core.encoding; + +import org.hyperledger.besu.datatypes.Address; +import org.hyperledger.besu.datatypes.Hash; +import org.hyperledger.besu.datatypes.TransactionType; +import org.hyperledger.besu.datatypes.Wei; +import org.hyperledger.besu.ethereum.core.Transaction; +import org.hyperledger.besu.ethereum.rlp.RLPInput; + +import java.math.BigInteger; + +public class OptimismDepositTransactionDecoder { + + public static Transaction decode(final RLPInput input) { + input.enterList(); + final Transaction.Builder builder = + Transaction.builder() + .type(TransactionType.OPTIMISM_DEPOSIT) + .sourceHash(Hash.wrap(input.readBytes32())) + .sender(Address.wrap(input.readBytes())) + .to(input.readBytes(v -> v.isEmpty() ? null : Address.wrap(v))) + .mint(Wei.of(input.readUInt256Scalar())) + .value(Wei.of(input.readUInt256Scalar())) + .gasLimit(input.readLongScalar()) + .isSystemTx(input.readBigIntegerScalar().compareTo(BigInteger.ONE) == 0) + .payload(input.readBytes()); + input.leaveList(); + return builder.build(); + } +}

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/OptimismDepositTransactionEncoder.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/OptimismDepositTransactionEncoder.java new file mode 100644 index 0000000000000000000000000000000000000000..fd5b99e8ebbd50f861164b1086b3fb8b61fac814 --- /dev/null +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/OptimismDepositTransactionEncoder.java @@ -0,0 +1,40 @@ +/* + * Copyright contributors to Hyperledger Besu. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + */ +package org.hyperledger.besu.ethereum.core.encoding; + +import org.hyperledger.besu.datatypes.Wei; +import org.hyperledger.besu.ethereum.core.Transaction; +import org.hyperledger.besu.ethereum.rlp.RLPOutput; + +import java.math.BigInteger; + +import org.apache.tuweni.bytes.Bytes; + +public class OptimismDepositTransactionEncoder { + + public static void encode(final Transaction transaction, final RLPOutput out) { + out.startList(); + out.writeBytes(transaction.getSourceHash().orElseThrow()); + out.writeBytes(transaction.getSender()); + out.writeBytes(transaction.getTo().map(Bytes::copy).orElse(Bytes.EMPTY)); + out.writeUInt256Scalar(transaction.getMint().orElse(Wei.ZERO)); + out.writeUInt256Scalar(transaction.getValue() != null ? transaction.getValue() : Wei.ZERO); + out.writeLongScalar(transaction.getGasLimit()); + out.writeBigIntegerScalar( + transaction.getIsSystemTx().map(b -> b ? BigInteger.ONE : BigInteger.ZERO).orElseThrow()); + out.writeBytes(transaction.getPayload() != null ? transaction.getPayload() : Bytes.EMPTY); + out.endList(); + } +}

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionDecoder.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionDecoder.java index 2a63d8f24baa0e68eeee175b91229f9a4c92c887..5170ebe64c262a8c9586d07a6cb718210804dcbc 100644 --- hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionDecoder.java +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionDecoder.java @@ -41,6 +41,8 @@ TransactionType.EIP1559, EIP1559TransactionDecoder::decode, TransactionType.BLOB, BlobTransactionDecoder::decode, + TransactionType.OPTIMISM_DEPOSIT, + OptimismDepositTransactionDecoder::decode, TransactionType.SET_CODE, SetCodeTransactionDecoder::decode);

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionEncoder.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionEncoder.java index 49959756219d3ed7408d78c1d7c0fee9b811da2d..f65f46b29e162777a0f53f67d01b6adb0c779f03 100644 --- hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionEncoder.java +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/core/encoding/TransactionEncoder.java @@ -40,6 +40,8 @@ TransactionType.EIP1559, EIP1559TransactionEncoder::encode, TransactionType.BLOB, BlobTransactionEncoder::encode, + TransactionType.OPTIMISM_DEPOSIT, + OptimismDepositTransactionEncoder::encode, TransactionType.SET_CODE, SetCodeTransactionEncoder::encode);

diff --git hyperledger/besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/RollupGasData.java optimism-java/op-besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/RollupGasData.java new file mode 100644 index 0000000000000000000000000000000000000000..dce7ac07ce3ad23251d5dba2abd87daede4ecfe0 --- /dev/null +++ optimism-java/op-besu/datatypes/src/main/java/org/hyperledger/besu/datatypes/RollupGasData.java @@ -0,0 +1,186 @@ +/* + * Copyright contributors to Hyperledger Besu. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + */ +package org.hyperledger.besu.datatypes; + +import org.apache.tuweni.bytes.Bytes; + +/** Optimism roll up data records. */ +public class RollupGasData { + + private static final RollupGasData empty = new RollupGasData(0L, 0L, 0L); + + private final long zeroes; + + private final long ones; + + private final long fastLzSize; + + /** + * Create a new roll up data record. + * + * @param zeroes the count of zeroes + * @param ones the count of ones + * @param fastLzSize the fast-lz size + */ + public RollupGasData(final long zeroes, final long ones, final long fastLzSize) { + this.zeroes = zeroes; + this.ones = ones; + this.fastLzSize = fastLzSize; + } + + /** + * Get the number of zeroes. + * + * @return the number of zeroes + */ + public long getZeroes() { + return zeroes; + } + + /** + * Get the number of non-zeroes. + * + * @return the number of non-zeroes + */ + public long getOnes() { + return ones; + } + + /** + * Get the number of fast-lz size. + * + * @return the number of fast-lz size + */ + public long getFastLzSize() { + return fastLzSize; + } + + /** + * Create a new roll up data record from a payload bytes. + * + * @param payload the transaction rlp encoded bytes + * @return the roll up data record + */ + public static RollupGasData fromPayload(final Bytes payload) { + if (payload == null) { + return empty; + } + final int length = payload.size(); + int zeroes = 0; + int ones = 0; + for (int i = 0; i < length; i++) { + byte b = payload.get(i); + if (b == 0) { + zeroes++; + } else { + ones++; + } + } + var fastLzSize = flzCompressLength(payload.toArray()); + return new RollupGasData(zeroes, ones, fastLzSize); + } + + /** + * FlzCompressLen returns the length of the data after compression through FastLZ, based on <a + * href="">https://github.com/Vectorized/solady/blob/5315d937d79b335c668896d7533ac603adac5315/js/solady.js</a> + */ + static long flzCompressLength(final byte[] ib) { + var n = 0; + var ht = new int[8192]; + + var a = 0; + var ipLimit = ib.length > 13 ? ib.length - 13 : 0; + for (var ip = a + 2; ip < ipLimit; ) { + var r = 0; + var d = 0; + for (; ; ) { + var s = u24(ib, ip); + var h = hash(s); + r = ht[h]; + ht[h] = ip; + d = ip - r; + if (ip >= ipLimit) { + break; + } + ip++; + if (d <= 0x1fff && s == u24(ib, r)) { + break; + } + } + if (ip >= ipLimit) { + break; + } + ip--; + if (ip > a) { + n = literals(n, ip - a); + } + var l = cmp(ib, r + 3, ip + 3, ipLimit + 9); + n = match(n, l); + ip = setNextHash(ib, ht, setNextHash(ib, ht, ip + l)); + a = ip; + } + n = literals(n, ib.length - a); + return n; + } + + static int u24(final byte[] ib, final int i) { + return (ib[i] & 0xFF) | (ib[i + 1] & 0xFF) << 8 | (ib[i + 2] & 0xFF) << 16; + } + + static int cmp(final byte[] ib, final int p, final int q, final int e) { + var loopCount = 0; + var value = e; + for (value = value - q; loopCount < value; loopCount++) { + if ((ib[p + loopCount] & 0xFF) != (ib[q + loopCount] & 0xFF)) { + value = 0; + } + } + return loopCount; + } + + static int literals(final int n, final int r) { + var a = n; + var b = r; + + a += 0x21 * (b / 0x20); + b %= 0x20; + if (b != 0) { + a += b + 1; + } + return a; + } + + static int match(final int n, final int l) { + var a = n; + var b = l; + b--; + a += 3 * (b / 262); + if (b % 262 >= 6) { + a += 3; + } else { + a += 2; + } + return a; + } + + static int hash(final int v) { + return (int) ((2654435769L * v) >> 19) & 0x1fff; + } + + static int setNextHash(final byte[] ib, final int[] ht, final int ip) { + ht[hash(u24(ib, ip))] = ip; + return ip + 1; + } +}

diff --git hyperledger/besu/datatypes/src/test/java/org/hyperledger/besu/datatypes/RollupGasDataTest.java optimism-java/op-besu/datatypes/src/test/java/org/hyperledger/besu/datatypes/RollupGasDataTest.java new file mode 100644 index 0000000000000000000000000000000000000000..db6b1a2963990befa7ce7b36fb8f34cc6e4aa2f2 --- /dev/null +++ optimism-java/op-besu/datatypes/src/test/java/org/hyperledger/besu/datatypes/RollupGasDataTest.java @@ -0,0 +1,62 @@ +/* + * Copyright contributors to Hyperledger Besu. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + */ +package org.hyperledger.besu.datatypes; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.Arrays; + +import org.bouncycastle.util.encoders.Hex; +import org.junit.jupiter.api.Test; + +class RollupGasDataTest { + + @Test + void testFlzCompressLength() { + long flzSize = RollupGasData.flzCompressLength(new byte[0]); + assertEquals(0, flzSize); + + byte[] data = new byte[1000]; + Arrays.fill(data, (byte) 1); + flzSize = RollupGasData.flzCompressLength(data); + assertEquals(21, flzSize); + + data = new byte[1000]; + flzSize = RollupGasData.flzCompressLength(data); + assertEquals(21, flzSize); + + byte[] emptyTx = Hex.decode("DD80808094095E7BAEA6A6C7C4C2DFEB977EFAC326AF552D878080808080"); + flzSize = RollupGasData.flzCompressLength(emptyTx); + assertEquals(31, flzSize); + + byte[] contractCallTx = + Hex.decode( + "02f901550a758302df1483be21b88304743f94f8" + + "0e51afb613d764fa61751affd3313c190a86bb870151bd62fd12adb8" + + "e41ef24f3f0000000000000000000000000000000000000000000000" + + "00000000000000006e000000000000000000000000af88d065e77c8c" + + "c2239327c5edb3a432268e5831000000000000000000000000000000" + + "000000000000000000000000000003c1e50000000000000000000000" + + "00000000000000000000000000000000000000000000000000000000" + + "000000000000000000000000000000000000000000000000a0000000" + + "00000000000000000000000000000000000000000000000000000000" + + "148c89ed219d02f1a5be012c689b4f5b731827bebe00000000000000" + + "0000000000c001a033fd89cb37c31b2cba46b6466e040c61fc9b2a36" + + "75a7f5f493ebd5ad77c497f8a07cdf65680e238392693019b4092f61" + + "0222e71b7cec06449cb922b93b6a12744e"); + flzSize = RollupGasData.flzCompressLength(contractCallTx); + assertEquals(202, flzSize); + } +}

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/L1CostCalculator.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/L1CostCalculator.java new file mode 100644 index 0000000000000000000000000000000000000000..009d9cbfdf2e91a9b6489de4c1df8bb193128462 --- /dev/null +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/L1CostCalculator.java @@ -0,0 +1,266 @@ +/* + * Copyright contributors to Hyperledger Besu. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + */ +package org.hyperledger.besu.ethereum.mainnet; + +import org.hyperledger.besu.config.GenesisConfigOptions; +import org.hyperledger.besu.datatypes.Address; +import org.hyperledger.besu.datatypes.RollupGasData; +import org.hyperledger.besu.datatypes.TransactionType; +import org.hyperledger.besu.datatypes.Wei; +import org.hyperledger.besu.ethereum.core.ProcessableBlockHeader; +import org.hyperledger.besu.ethereum.core.Transaction; +import org.hyperledger.besu.evm.account.MutableAccount; +import org.hyperledger.besu.evm.worldstate.WorldUpdater; + +import java.math.BigInteger; +import java.util.Arrays; + +import org.apache.tuweni.units.bigints.UInt256; +import org.web3j.utils.Numeric; + +/** L1 Cost calculator. */ +public class L1CostCalculator { + + private static final UInt256 SIXTEEN = UInt256.valueOf(16L); + + private static final BigInteger L1_COST_INTERCEPT = BigInteger.valueOf(-42_585_600L); + private static final BigInteger L1_COST_FAST_LZ_COEF = BigInteger.valueOf(836_500L); + + private static final BigInteger MIN_TX_SIZE = BigInteger.valueOf(100L); + private static final BigInteger MIN_TX_SIZE_SCALED = + BigInteger.valueOf(1_000_000L).multiply(MIN_TX_SIZE); + private static final UInt256 ECOTONE_DIVISOR = UInt256.valueOf(1_000_000L * 16L); + private static final BigInteger FJORD_DIVISOR = BigInteger.valueOf(1_000_000_000_000L); + + private static final int BASE_FEE_SCALAR_SLOT_OFFSET = 12; + // private static final int BLOB_BASE_FEE_SCALAR_SLOT_OFFSET = 8; + + private static final int SCALAR_SECTION_START = 32 - BASE_FEE_SCALAR_SLOT_OFFSET - 4; + + // private static final byte[] BedrockL1AttributesSelector = new byte[]{0x01, 0x5d, (byte) 0x8e, + // (byte) 0xb9}; + // private static final byte[] EcotoneL1AttributesSelector = new byte[]{0x44, 0x0a, 0x5e, 0x20}; + + private static final long TX_DATA_ZERO_COST = 4L; + + private static final long TX_DATA_NON_ZERO_GAS_EIP2028_COST = 16L; + private static final long TX_DATA_NON_ZERO_GAS_FRONTIER_COST = 68L; + + private static final Address l1BlockAddr = + Address.fromHexString("0x4200000000000000000000000000000000000015"); + private static final UInt256 l1BaseFeeSlot = UInt256.valueOf(1L); + private static final UInt256 overheadSlot = UInt256.valueOf(5L); + private static final UInt256 scalarSlot = UInt256.valueOf(6L); + + private static final byte[] emptyScalars = new byte[8]; + + /** + * l1BlobBaseFeeSlot was added with the Ecotone upgrade and stores the blobBaseFee L1 gas + * attribute. + */ + private static final UInt256 l1BlobBaseFeeSlot = UInt256.valueOf(7L); + + /** + * l1FeeScalarsSlot as of the Ecotone upgrade stores the 32-bit basefeeScalar and + * blobBaseFeeScalar L1 gas attributes at offsets `BaseFeeScalarSlotOffset` and + * `BlobBaseFeeScalarSlotOffset` respectively. + */ + private static final UInt256 l1FeeScalarsSlot = UInt256.valueOf(3L); + + public L1CostCalculator() {} + + /** + * Calculates the l1 cost of transaction. + * + * @param options genesis config options + * @param blockHeader block header info + * @param transaction transaction is checked + * @param worldState instance of the WorldState + * @return l1 costed gas + */ + public Wei l1Cost( + final GenesisConfigOptions options, + final ProcessableBlockHeader blockHeader, + final Transaction transaction, + final WorldUpdater worldState) { + if (!options.isOptimism()) { + return Wei.ZERO; + } + + // Note: the various state variables below are not initialized from the DB until this + // point to allow deposit transactions from the block to be processed first by state + // transition. This behavior is consensus critical! + if (!options.isEcotone(blockHeader.getTimestamp())) { + return l1CostInBedrock(options, blockHeader, transaction, worldState); + } else { + final MutableAccount systemConfig = worldState.getOrCreate(l1BlockAddr); + + var l1BlobBaseFee = systemConfig.getStorageValue(l1BlobBaseFeeSlot); + var l1FeeScalars = systemConfig.getStorageValue(l1FeeScalarsSlot).toArray(); + byte[] l1FeeScalarBytes = + Arrays.copyOfRange(l1FeeScalars, SCALAR_SECTION_START, SCALAR_SECTION_START + 8); + + // Edge case: the very first Ecotone block requires we use the Bedrock cost + // function. We detect this scenario by checking if the Ecotone parameters are + // unset. Not here we rely on assumption that the scalar parameters are adjacent + // in the buffer and basefeeScalar comes first. + if (l1BlobBaseFee.bitLength() == 0 && Arrays.equals(emptyScalars, l1FeeScalarBytes)) { + + return l1CostInBedrock(options, blockHeader, transaction, worldState); + } + + var l1BaseFee = systemConfig.getStorageValue(l1BaseFeeSlot); + var offset = SCALAR_SECTION_START; + var l1BaseFeeScalar = + UInt256.valueOf(Numeric.toBigInt(Arrays.copyOfRange(l1FeeScalars, offset, offset + 4))); + var l1BlobBaseFeeScalar = + UInt256.valueOf( + Numeric.toBigInt(Arrays.copyOfRange(l1FeeScalars, offset + 4, offset + 8))); + if (options.isFjord(blockHeader.getTimestamp())) { + return l1CostFjord( + transaction.getRollupGasData(), + l1BaseFee, + l1BlobBaseFee, + l1BaseFeeScalar, + l1BlobBaseFeeScalar); + } + return l1CostInEcotone( + transaction.getRollupGasData(), + l1BaseFee, + l1BlobBaseFee, + l1BaseFeeScalar, + l1BlobBaseFeeScalar); + } + } + + static Wei l1CostInBedrock( + final GenesisConfigOptions options, + final ProcessableBlockHeader blockHeader, + final Transaction tx, + final WorldUpdater worldState) { + final boolean isDepositTx = TransactionType.OPTIMISM_DEPOSIT.equals(tx.getType()); + if (isDepositTx) { + return Wei.ZERO; + } + final boolean isRegolith = options.isRegolith(blockHeader.getTimestamp()); + final MutableAccount systemConfig = worldState.getOrCreate(l1BlockAddr); + var l1BaseFee = systemConfig.getStorageValue(l1BaseFeeSlot); + var overhead = systemConfig.getStorageValue(overheadSlot); + var l1FeeScalar = systemConfig.getStorageValue(scalarSlot); + return l1CostInBedrockProcess( + tx.getRollupGasData(), l1BaseFee, overhead, l1FeeScalar, isRegolith); + } + + static Wei l1CostInBedrockProcess( + final RollupGasData rollupGasData, + final UInt256 l1BaseFee, + final UInt256 overhead, + final UInt256 l1FeeScalar, + final boolean isRegolith) { + var gas = calculateRollupDataGasCost(rollupGasData, isRegolith); + if (gas == 0L) { + return Wei.ZERO; + } + UInt256 l1GasUsed = + UInt256.valueOf(gas) + .add(overhead) + .multiply(l1BaseFee) + .multiply(l1FeeScalar) + .divide(UInt256.valueOf(1_000_000L)); + + return Wei.of(l1GasUsed); + } + + static Wei l1CostInEcotone( + final RollupGasData costData, + final UInt256 l1BaseFee, + final UInt256 l1BlobBaseFee, + final UInt256 l1BaseFeeScalar, + final UInt256 l1BlobBaseFeeScalar) { + // calldataGas = (costData.zeroes * 4) + (costData.ones * 16) + var calldataGas = + costData.getZeroes() * TX_DATA_ZERO_COST + + costData.getOnes() * TX_DATA_NON_ZERO_GAS_EIP2028_COST; + var calldataGasUsed = UInt256.valueOf(calldataGas); + + // Ecotone L1 cost function: + // + // (calldataGas/16)*(l1BaseFee*16*l1BaseFeeScalar + l1BlobBaseFee*l1BlobBaseFeeScalar)/1e6 + // + // We divide "calldataGas" by 16 to change from units of calldata gas to "estimated # of bytes + // when + // compressed". Known as "compressedTxSize" in the spec. + // + // Function is actually computed as follows for better precision under integer arithmetic: + // + // calldataGas*(l1BaseFee*16*l1BaseFeeScalar + l1BlobBaseFee*l1BlobBaseFeeScalar)/16e6 + var calldataCostPerByte = l1BaseFee.multiply(SIXTEEN).multiply(l1BaseFeeScalar); + var blobCostPerByte = l1BlobBaseFee.multiply(l1BlobBaseFeeScalar); + + // fee = (calldataCostPerByte + blobCostPerByte) * calldataGasUsed / (16e6) + var fee = + calldataCostPerByte.add(blobCostPerByte).multiply(calldataGasUsed).divide(ECOTONE_DIVISOR); + return Wei.of(fee); + } + + static Wei l1CostFjord( + final RollupGasData costData, + final UInt256 l1BaseFee, + final UInt256 l1BlobBaseFee, + final UInt256 l1BaseFeeScalar, + final UInt256 l1BlobBaseFeeScalar) { + // Fjord L1 cost function: + // l1FeeScaled = baseFeeScalar*l1BaseFee*16 + blobFeeScalar*l1BlobBaseFee + // estimatedSize = max(minTransactionSize, intercept + fastlzCoef*fastlzSize) + // l1Cost = estimatedSize * l1FeeScaled / 1e12 + + var scaledL1BaseFee = l1BaseFeeScalar.multiply(l1BaseFee); + var calldataCostPerByte = scaledL1BaseFee.multiply(SIXTEEN); + var blobCostPerByte = l1BlobBaseFeeScalar.multiply(l1BlobBaseFee); + var l1FeeScaled = calldataCostPerByte.add(blobCostPerByte); + + var estimatedSize = + L1_COST_INTERCEPT.add( + L1_COST_FAST_LZ_COEF.multiply(BigInteger.valueOf(costData.getFastLzSize()))); + + if (estimatedSize.compareTo(MIN_TX_SIZE_SCALED) < 0) { + estimatedSize = MIN_TX_SIZE_SCALED; + } + + var l1CostScaled = estimatedSize.multiply(l1FeeScaled.toBigInteger()); + var l1Cost = l1CostScaled.divide(FJORD_DIVISOR); + return Wei.of(l1Cost); + } + + /** + * calculates rollup data gas cost. + * + * @param rollupGasData rollup gas data record + * @param isRegolith flag that transaction time is bigger than regolith time + * @return the transaction gas value + */ + public static long calculateRollupDataGasCost( + final RollupGasData rollupGasData, final boolean isRegolith) { + var gas = rollupGasData.getZeroes() * TX_DATA_ZERO_COST; + if (isRegolith) { + gas += rollupGasData.getOnes() * TX_DATA_NON_ZERO_GAS_EIP2028_COST; + } else { + gas += + (rollupGasData.getOnes() + TX_DATA_NON_ZERO_GAS_FRONTIER_COST) + * TX_DATA_NON_ZERO_GAS_EIP2028_COST; + } + return gas; + } +}

diff --git hyperledger/besu/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/L1CostCalculatorTest.java optimism-java/op-besu/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/L1CostCalculatorTest.java new file mode 100644 index 0000000000000000000000000000000000000000..2ea81a43cda2e059e1c7349398e2cbb274e5c3d2 --- /dev/null +++ optimism-java/op-besu/ethereum/core/src/test/java/org/hyperledger/besu/ethereum/mainnet/L1CostCalculatorTest.java @@ -0,0 +1,165 @@ +/* + * Copyright contributors to Hyperledger Besu. + * + * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on + * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the + * specific language governing permissions and limitations under the License. + * + * SPDX-License-Identifier: Apache-2.0 + */ +package org.hyperledger.besu.ethereum.mainnet; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import org.hyperledger.besu.datatypes.RollupGasData; +import org.hyperledger.besu.datatypes.Wei; + +import java.util.Arrays; +import java.util.List; + +import org.apache.tuweni.bytes.Bytes; +import org.apache.tuweni.units.bigints.UInt256; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +class L1CostCalculatorTest { + private static UInt256 baseFee; + private static UInt256 overhead; + private static UInt256 scalar; + + private static UInt256 blobBaseFee; + private static UInt256 baseFeeScalar; + private static UInt256 blobBaseFeeScalar; + + private static Wei bedrockFee; + private static Wei regolithFee; + private static Wei ecotoneFee; + private static RollupGasData emptyRollData; + + @BeforeAll + static void setUp() { + baseFee = UInt256.valueOf(1000 * 1000_000); + overhead = UInt256.valueOf(50); + scalar = UInt256.valueOf(7 * 1000_000); + + blobBaseFee = UInt256.valueOf(10 * 1000_000); + baseFeeScalar = UInt256.valueOf(2); + blobBaseFeeScalar = UInt256.valueOf(3); + + bedrockFee = Wei.of(UInt256.valueOf(11326000000000L)); + regolithFee = Wei.of(UInt256.valueOf(3710000000000L)); + ecotoneFee = Wei.of(UInt256.valueOf(960900)); + + byte[] bytes = new byte[30]; + Arrays.fill(bytes, (byte) 1); + emptyRollData = RollupGasData.fromPayload(Bytes.wrap(bytes)); + } + + @Test + void l1CostInBedrockProcess() { + Wei bedrockGasUsed = + L1CostCalculator.l1CostInBedrockProcess(emptyRollData, baseFee, overhead, scalar, false); + assertEquals(bedrockFee, bedrockGasUsed); + + Wei regolithGasUsed = + L1CostCalculator.l1CostInBedrockProcess(emptyRollData, baseFee, overhead, scalar, true); + assertEquals(regolithFee, regolithGasUsed); + } + + @Test + void l1CostInEcotone() { + Wei ecotoneGasUsed = + L1CostCalculator.l1CostInEcotone( + emptyRollData, baseFee, blobBaseFee, baseFeeScalar, blobBaseFeeScalar); + assertEquals(ecotoneFee, ecotoneGasUsed); + } + + @Test + void l1CostInFjord() { + var funcBaseFee = UInt256.valueOf(1_000_000_000L); + var funcBlobBaseFee = UInt256.valueOf(10_000_000L); + var funcFeeScalar = UInt256.valueOf(2L); + var funcBlobBaseFeeScalar = UInt256.valueOf(3L); + + List<Long> fastLzsize = List.of(100L, 150L, 170L); + for (Long size : fastLzsize) { + Wei wei = + L1CostCalculator.l1CostFjord( + new RollupGasData(0, 0, size), + funcBaseFee, + funcBlobBaseFee, + funcFeeScalar, + funcBlobBaseFeeScalar); + assertEquals(Wei.of(UInt256.valueOf(3203000L)), wei); + } + + fastLzsize = List.of(171L, 175L, 200L); + for (Long size : fastLzsize) { + Wei wei = + L1CostCalculator.l1CostFjord( + new RollupGasData(0, 0, size), + funcBaseFee, + funcBlobBaseFee, + funcFeeScalar, + funcBlobBaseFeeScalar); + assertTrue(UInt256.valueOf(3203000L).compareTo(wei.toUInt256()) < 0); + } + } + + @Test + void l1CostInFjord2() { + var funcBaseFee = UInt256.valueOf(2000000L); + var funcBlobBaseFee = UInt256.valueOf(3000000L); + var funcFeeScalar = UInt256.valueOf(20L); + var funcBlobBaseFeeScalar = UInt256.valueOf(15L); + + Wei wei = + L1CostCalculator.l1CostFjord( + new RollupGasData(0, 0, 235), + funcBaseFee, + funcBlobBaseFee, + funcFeeScalar, + funcBlobBaseFeeScalar); + assertEquals(UInt256.valueOf(105484L), wei.toUInt256()); + } + + @Test + void l1CostInFjord3() { + var funcBaseFee = UInt256.valueOf(1000000000L); + var funcBlobBaseFee = UInt256.valueOf(10000000L); + var funcFeeScalar = UInt256.valueOf(2L); + var funcBlobBaseFeeScalar = UInt256.valueOf(3L); + + Wei wei = + L1CostCalculator.l1CostFjord( + new RollupGasData(0, 30, 31), + funcBaseFee, + funcBlobBaseFee, + funcFeeScalar, + funcBlobBaseFeeScalar); + assertEquals(UInt256.valueOf(3203000L), wei.toUInt256()); + } + + @Test + void l1CostInFjord4() { + var funcBaseFee = UInt256.valueOf(22232045986L); + var funcBlobBaseFee = UInt256.valueOf(652134L); + var funcFeeScalar = UInt256.valueOf(7600L); + var funcBlobBaseFeeScalar = UInt256.valueOf(862000L); + var rollUpGasData = + RollupGasData.fromPayload( + Bytes.fromHexString( + "0x02f92ad783aa37dc8301393684068e778084069dbacc834a6815945ff137d4b0fdcd49dca30c7cf57e578a026d278980b92a641fad948c0000000000000000000000000000000000000000000000000000000000000040000000000000000000000000cfa706659d0bbe85ebb5c145a2d9f1c89c76b1c40000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000006400000000000000000000000000000000000000000000000000000000000000b8000000000000000000000000000000000000000000000000000000000000010c000000000000000000000000000000000000000000000000000000000000015c00000000000000000000000000000000000000000000000000000000000001aa00000000000000000000000000000000000000000000000000000000000001fe000000000000000000000000000000000000000000000000000000000000024c00000000000000000000000000ce101773c1fed47e0e11f028a168de6caba3bdf0000000000000000000000000000000000000000000000000000000000000333000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000009e160000000000000000000000000000000000000000000000000000000000019bfd000000000000000000000000000000000000000000000000000000000000cb4000000000000000000000000000000000000000000000000000000000069dbacc00000000000000000000000000000000000000000000000000000000068e778000000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e40000189a0000000000000000000000005fd84259d66cd46123540766be93dfe6d43130d7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000003e9c6ea0deca37fe5312a9045706e8946121b4d50000000000000000000000000000000000000000000000000000000000000282000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000958817340e0a3435e06254f2ed411e6418cd070d6f000000000000000000000000000000000000000000000000000000006657532e0000000000000000000000000000000000000000000000000000000000000000a1640cdcc227c9da337db6bc52110a4c7c965dbd6cbff1bee1a09d5fd14fc4bd6cd86cb687a2e1b0fa7a9325731136a2476063f57e66a13459d107fec37e96191c000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000400000000000000000000000001965cd0bf68db7d007613e79d8386d48b9061ea6000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000665753400000000000000000000000000000000000000000000000000000000066574e909d764665dddccfa399306a13a741583d275182129b5e9b18cc02959ec84753ea00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000192443a8b54b6efbc27641ac942d12aba9bdd4e13b483e5c9ca7233d169eedee400000000000000000000000000000000000000000000000000000000000000414b9b57df8a561f7f588a6bc79d763d94fd276e5f4998f6e1412bc8307cc37af47cfd69bbe6aac67b7cd6380e281b837138158f1f6e9ff509bee312d5971035541c0000000000000000000000000000000000000000000000000000000000000000000000000000000000000017945d4c68e60ed9dc924a86f79e9fa17957d4c80000000000000000000000000000000000000000000000000000000000000338000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000009e160000000000000000000000000000000000000000000000000000000000019bfd000000000000000000000000000000000000000000000000000000000000cb4000000000000000000000000000000000000000000000000000000000069dbacc00000000000000000000000000000000000000000000000000000000068e778000000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e40000189a0000000000000000000000005fd84259d66cd46123540766be93dfe6d43130d7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000003e9c6ea0deca37fe5312a9045706e8946121b4d50000000000000000000000000000000000000000000000000000000000000282000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000958817340e0a3435e06254f2ed411e6418cd070d6f000000000000000000000000000000000000000000000000000000006657532e000000000000000000000000000000000000000000000000000000000000000078d31cbb6431eca16f545d61c07cf4c655073045d5191f4a235342d55721166b6077f2c473e62eb84d459ff6abcc51254345373cf25d59272873853a64dc3ece1b000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000400000000000000000000000001965cd0bf68db7d007613e79d8386d48b9061ea6000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000665753420000000000000000000000000000000000000000000000000000000066574e92dd485cdcb72d516c040b0c6a438174001a046f8321c74564c2212640106a7fc100000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000001cd51e9aae80ded84d02fb61abffd3706a36d0a7a93c8b890191c75f3ee577e8000000000000000000000000000000000000000000000000000000000000000416be4e940ebf61d42383fb695722a340dcf31f837c6814fbc2f6b2f193fe69003339f80436ae68a6674607200f069377e6334eb132865779c6d9d8eb5dae7da791c000000000000000000000000000000000000000000000000000000000000000000000000000000000000003aecdf2db1e82cf17038daee4eeb307f3336cd730000000000000000000000000000000000000000000000000000000000000333000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000009e160000000000000000000000000000000000000000000000000000000000019bfd000000000000000000000000000000000000000000000000000000000000cb4000000000000000000000000000000000000000000000000000000000069dbacc00000000000000000000000000000000000000000000000000000000068e778000000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e40000189a0000000000000000000000005fd84259d66cd46123540766be93dfe6d43130d7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000003e9c6ea0deca37fe5312a9045706e8946121b4d50000000000000000000000000000000000000000000000000000000000000282000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000958817340e0a3435e06254f2ed411e6418cd070d6f000000000000000000000000000000000000000000000000000000006657532e00000000000000000000000000000000000000000000000000000000000000003b0e99b9cca9828193abb297a0c29ae601e6a8a361f2371e00c0dca72f192c126bbe8b7e4c95f5008f06a3bc0f88f68c48f331d305387a7576c733f49bcc52171b000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000400000000000000000000000001965cd0bf68db7d007613e79d8386d48b9061ea6000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000665753440000000000000000000000000000000000000000000000000000000066574e94889abe46cea3fd69752c52fc5315b4b21f1dc49de40471a0b1c8caeb5d11cd2200000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000188d816417f451d1cfc74da4b12509a292915be16ec4a9c926d6a68462f2faaa30000000000000000000000000000000000000000000000000000000000000041d32067a87ab7d0effbfb2ee5584005b6cef9fa1b08c845146fd6a78efe2f0d6d269a461173eae10d56ca941ed99a9d4b8749a2dd49796e29357c3d4b8fac14371c000000000000000000000000000000000000000000000000000000000000000000000000000000000000004c541cb68820a72029682f61a1421f58f62b905f0000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000004cdb0000000000000000000000000000000000000000000000000000000000019b87000000000000000000000000000000000000000000000000000000000000c92400000000000000000000000000000000000000000000000000000000069dbacc00000000000000000000000000000000000000000000000000000000068e778000000000000000000000000000000000000000000000000000000000000002600000000000000000000000000000000000000000000000000000000000000320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000a40000189a0000000000000000000000004bd0b3b6325676644b7e8091c1683df3092e14d9000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000004183ff085000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000958817340e0a3435e06254f2ed411e6418cd070d6f000000000000000000000000000000000000000000000000000000006657533800000000000000000000000000000000000000000000000000000000000000007581619c4faf4a16190b3da8d6d60f401bdfc91da1b27d42810236c30bdab0bc548aea1c2fa45b6ec95a14ac6c26835be3809f51ec8c9ab1362b4462b3efe4611b000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000400000000000000000000000001965cd0bf68db7d007613e79d8386d48b9061ea60000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000006657533e0000000000000000000000000000000000000000000000000000000066574e8e417f13ba0f65553fb36522711b73060438cfa569a0ac4aee7304ae4a766f9c3b00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000001e900b8541679f627ffb517bf976e5e9ac2b96f537748cd3ec809878564f16a2a0000000000000000000000000000000000000000000000000000000000000041c587b62e6f564726c82bc290c85cfc62ff766e0503789f897a17620516b10b8457774d59449afac9ac57942b9725fadb641c74b4f4282d50e848e78b34e7782c1b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000546e42ceb74596b77dededf887960bba7680e97700000000000000000000000000000000000000000000000000000000000000350000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000057370000000000000000000000000000000000000000000000000000000000019b4b000000000000000000000000000000000000000000000000000000000000c89400000000000000000000000000000000000000000000000000000000069dbacc00000000000000000000000000000000000000000000000000000000068e778000000000000000000000000000000000000000000000000000000000000002400000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000840000189a000000000000000000000000a71b7c6d54aea61e56eb7ba91146e078701045e700000000000000000000000000000000000000000000000000000da475abf000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000958817340e0a3435e06254f2ed411e6418cd070d6f0000000000000000000000000000000000000000000000000000000066575310000000000000000000000000000000000000000000000000000000000000000004fcd4f8107d05d209745ee34ab949f730ce7bd9a6ac9ada1069f6515af3fff53c9faa5ca5a807cc80c0d62d5d6b0b297c3b3563667368d458696f74bc0ca6411c000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000400000000000000000000000001965cd0bf68db7d007613e79d8386d48b9061ea60000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000006657556c00000000000000000000000000000000000000000000000000000000665750bc309269900479e1f9ff4a2e8382e55bd87d2c37df5c83539cd604d9f67e1d28be00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000001f2870b5200d28c0946022b779a070e077a34e5e2c7c17c826d4dfaf37c3f9141000000000000000000000000000000000000000000000000000000000000004113afbbe1ce40ca4032529f677f4a6507e0d4b91231b466d5072a021b92fc08c874bb4e58608d7ef22b8a0fad605436e50f0962540cdcedf773e3acb2fc449e0b1b000000000000000000000000000000000000000000000000000000000000000000000000000000000000007a7542bfeac979a1e68e33131c5c4c21697fc5d20000000000000000000000000000000000000000000000000000000000000332000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000009e160000000000000000000000000000000000000000000000000000000000019bfd000000000000000000000000000000000000000000000000000000000000cb4000000000000000000000000000000000000000000000000000000000069dbacc00000000000000000000000000000000000000000000000000000000068e778000000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e40000189a0000000000000000000000005fd84259d66cd46123540766be93dfe6d43130d7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000003e9c6ea0deca37fe5312a9045706e8946121b4d50000000000000000000000000000000000000000000000000000000000000282000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000958817340e0a3435e06254f2ed411e6418cd070d6f000000000000000000000000000000000000000000000000000000006657532e000000000000000000000000000000000000000000000000000000000000000066046683044d66e4f32a1c8f72fb6b4bf8495cdcd76c9ef18e05534bc40f9b451001aec263d4397efca190917d21a0097545e7939bdb1b0b97565099494be57f1c000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000400000000000000000000000001965cd0bf68db7d007613e79d8386d48b9061ea6000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000665753460000000000000000000000000000000000000000000000000000000066574e96e59adfa7cfcbd44afd173daf0ef2737dd3c0febf13e6c5c809d3ab13600e5ee300000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000001dd65708cccb9aa642d81d15c579756a58a0a5dc78375520426533b3bbc09293400000000000000000000000000000000000000000000000000000000000000417b2f4eabe748a69bd0a3600349873b06e2d1fc9c32359bccd3dcc8c3c1ea756c2ad4ce5d7059700e4f866ae7a5504ec689f4576e8afa40face78983322c2be501b0000000000000000000000000000000000000000000000000000000000000000000000000000000000000086bf7f8f157509ed296485887a3e7c5de71975ed00000000000000000000000000000000000000000000000000000000000004960000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000057370000000000000000000000000000000000000000000000000000000000019b4b000000000000000000000000000000000000000000000000000000000000c8a000000000000000000000000000000000000000000000000000000000069dbacc00000000000000000000000000000000000000000000000000000000068e778000000000000000000000000000000000000000000000000000000000000002400000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000840000189a000000000000000000000000ca9eef6ab0595c2c2a926b5aa12b673ae69462fb0000000000000000000000000000000000000000000000000000105ef39b2000000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000958817340e0a3435e06254f2ed411e6418cd070d6f000000000000000000000000000000000000000000000000000000006657534200000000000000000000000000000000000000000000000000000000000000003e09853ae4682efdf309d09af7c5481df4152a5f997b56ab4e42a991c599324750e30f76001073b5469cac46068f1fab9202d7cecc85ddd0e65f5d9cea0eb12b1b000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000400000000000000000000000001965cd0bf68db7d007613e79d8386d48b9061ea60000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000006657559d00000000000000000000000000000000000000000000000000000000665750ed77177799f78621fa87d83126d829f06c2e7cd4860f3c9ca4f4f1c7b03e1effd600000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000011a97a30055598ff5d310ce62a953c7efa17083bf2043aa757ad3fcf34a6676840000000000000000000000000000000000000000000000000000000000000041625380383980b37744db6001c9dfc9313097c4ad5d963f974fb4657dae1c19211b5aaf414b87a794ff236d111576a978c8678e7756eeabea65de27541ae6f5201b00000000000000000000000000000000000000000000000000000000000000000000000000000000000000e8190d9cb6bef482c8315061ecd4be1eb08440eb00000000000000000000000000000000000000000000000000000000000002ea000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000009e160000000000000000000000000000000000000000000000000000000000019bfd000000000000000000000000000000000000000000000000000000000000cb4000000000000000000000000000000000000000000000000000000000069dbacc00000000000000000000000000000000000000000000000000000000068e778000000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000360000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e40000189a0000000000000000000000005fd84259d66cd46123540766be93dfe6d43130d7000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000044a9059cbb0000000000000000000000003e9c6ea0deca37fe5312a9045706e8946121b4d50000000000000000000000000000000000000000000000000000000000000282000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000958817340e0a3435e06254f2ed411e6418cd070d6f00000000000000000000000000000000000000000000000000000000665753380000000000000000000000000000000000000000000000000000000000000000caf938c7babf46dcee19335db9e0da279335335d00a8e895f90aa8bd3dc3fb101decca25e8bad1d90a8de818dd65f2aa2026fdffe8a7d00f37a9b8e8da9721421b000000000000000000000000000000000000000000000000000000000000000000000000000000000001c000000000000000000000000000000000000000000000000000000000000000400000000000000000000000001965cd0bf68db7d007613e79d8386d48b9061ea60000000000000000000000000000000000000000000000000000000000000160000000000000000000000000000000000000000000000000000000006657534c0000000000000000000000000000000000000000000000000000000066574e9cf58317f65dd53973aeca652dc56709959425b4dd821a6689780debf334c23f3800000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000000014a0c7d57cd365dd513782b6674da5754b2c229646aee2215b062bf4b861cc50600000000000000000000000000000000000000000000000000000000000000412efbaad853f6c2a374a0bcc9dfef8a54ff66ed9c2d199b8b4f679c1561bda62910b2b92a69232f26b033476e026e40c37923e401fd066de36ae3c37738726c0f1c00000000000000000000000000000000000000000000000000000000000000c001a0ff5343a591142a2f6d35d978d92b9e5cb0a32c89054d72508252a8bb563f3ccba03ff63e1121bde22fbe776a577fe18f7361e224ea6505c855a31f59d58d35f57b")); + + Wei wei = + L1CostCalculator.l1CostFjord( + rollUpGasData, funcBaseFee, funcBlobBaseFee, funcFeeScalar, funcBlobBaseFeeScalar); + assertEquals(UInt256.valueOf(6466915509330L), wei.toUInt256()); + } +}

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AbstractBlockProcessor.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AbstractBlockProcessor.java index 480a1d8d7ab6c60472dfc807b9d3c339cf4968af..cd767c0e487588b2cd8d9ca79816de910e70fd8a 100644 --- hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AbstractBlockProcessor.java +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/AbstractBlockProcessor.java @@ -17,6 +17,7 @@ import static org.hyperledger.besu.ethereum.mainnet.feemarket.ExcessBlobGasCalculator.calculateExcessBlobGasForParent; import static org.hyperledger.besu.evm.operation.BlockHashOperation.BlockHashLookup;   +import org.hyperledger.besu.config.GenesisConfigOptions; import org.hyperledger.besu.datatypes.Address; import org.hyperledger.besu.datatypes.TransactionType; import org.hyperledger.besu.datatypes.Wei; @@ -37,6 +38,7 @@ import org.hyperledger.besu.ethereum.trie.MerkleTrieException; import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldState; import org.hyperledger.besu.ethereum.trie.diffbased.bonsai.worldview.BonsaiWorldStateUpdateAccumulator; import org.hyperledger.besu.ethereum.vm.CachingBlockHashLookup; +import org.hyperledger.besu.evm.account.Account; import org.hyperledger.besu.evm.gascalculator.CancunGasCalculator; import org.hyperledger.besu.evm.operation.BlockHashOperation; import org.hyperledger.besu.evm.tracing.OperationTracer; @@ -47,6 +49,7 @@ import java.text.MessageFormat; import java.util.ArrayList; import java.util.List; import java.util.Optional; +import java.util.OptionalLong;   import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -63,6 +66,15 @@ WorldState worldState, long gasUsed); }   + @FunctionalInterface + public interface OpTransactionReceiptFactory { + TransactionReceipt create( + TransactionType transactionType, + TransactionProcessingResult result, + WorldState worldState, + long gasUsed); + } + private static final Logger LOG = LoggerFactory.getLogger(AbstractBlockProcessor.class);   static final int MAX_GENERATION = 6; @@ -77,6 +89,8 @@ protected final boolean skipZeroBlockRewards; private final ProtocolSchedule protocolSchedule;   protected final MiningBeneficiaryCalculator miningBeneficiaryCalculator; + + private final Optional<GenesisConfigOptions> genesisOptions;   protected AbstractBlockProcessor( final MainnetTransactionProcessor transactionProcessor, @@ -85,12 +99,31 @@ final Wei blockReward, final MiningBeneficiaryCalculator miningBeneficiaryCalculator, final boolean skipZeroBlockRewards, final ProtocolSchedule protocolSchedule) { + this( + transactionProcessor, + transactionReceiptFactory, + blockReward, + miningBeneficiaryCalculator, + skipZeroBlockRewards, + protocolSchedule, + Optional.empty()); + } + + protected AbstractBlockProcessor( + final MainnetTransactionProcessor transactionProcessor, + final TransactionReceiptFactory transactionReceiptFactory, + final Wei blockReward, + final MiningBeneficiaryCalculator miningBeneficiaryCalculator, + final boolean skipZeroBlockRewards, + final ProtocolSchedule protocolSchedule, + final Optional<GenesisConfigOptions> genesisOptions) { this.transactionProcessor = transactionProcessor; this.transactionReceiptFactory = transactionReceiptFactory; this.blockReward = blockReward; this.miningBeneficiaryCalculator = miningBeneficiaryCalculator; this.skipZeroBlockRewards = skipZeroBlockRewards; this.protocolSchedule = protocolSchedule; + this.genesisOptions = genesisOptions; }   @Override @@ -111,6 +144,9 @@ protocolSpec.getBlockHashProcessor().processBlockHashes(blockchain, worldState, blockHeader); final BlockHashLookup blockHashLookup = new CachingBlockHashLookup(blockHeader, blockchain);   + Create2DeployerFunction.ensureCreate2Deployer( + genesisOptions, blockHeader.getTimestamp(), worldState.updater()); + final Address miningBeneficiary = miningBeneficiaryCalculator.calculateBeneficiary(blockHeader);   Optional<BlockHeader> maybeParentHeader = @@ -143,6 +179,12 @@ return new BlockProcessingResult(Optional.empty(), "provided gas insufficient"); } final WorldUpdater blockUpdater = worldState.updater();   + OptionalLong nonce = OptionalLong.empty(); + if (TransactionType.OPTIMISM_DEPOSIT.equals(transaction.getType())) { + Account sender = blockUpdater.getOrCreate(transaction.getSender()); + nonce = OptionalLong.of(sender.getNonce()); + } + TransactionProcessingResult transactionProcessingResult = getTransactionProcessingResult( preProcessingContext, @@ -177,9 +219,30 @@ currentBlobGasUsed += (transaction.getVersionedHashes().get().size() * CancunGasCalculator.BLOB_GAS_PER_BLOB); }   - final TransactionReceipt transactionReceipt = - transactionReceiptFactory.create( - transaction.getType(), transactionProcessingResult, worldState, currentGasUsed); + TransactionReceipt transactionReceipt; + if (!TransactionType.OPTIMISM_DEPOSIT.equals(transaction.getType())) { + transactionReceipt = + transactionReceiptFactory.create( + transaction.getType(), transactionProcessingResult, worldState, currentGasUsed); + } else { + GenesisConfigOptions options = genesisOptions.orElseThrow(); + Optional<Long> depositNonce = + options.isRegolith(blockHeader.getTimestamp()) && nonce.isPresent() + ? Optional.of(nonce.getAsLong()) + : Optional.empty(); + + Optional<Long> canyonDepositReceiptVer = + options.isCanyon(blockHeader.getTimestamp()) ? Optional.of(1L) : Optional.empty(); + transactionReceipt = + new TransactionReceipt( + transaction.getType(), + transactionProcessingResult.isSuccessful() ? 1 : 0, + currentGasUsed, + transactionProcessingResult.getLogs(), + Optional.empty(), + depositNonce, + canyonDepositReceiptVer); + } receipts.add(transactionReceipt); } if (blockHeader.getBlobGasUsed().isPresent()

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetBlockProcessor.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetBlockProcessor.java index 9f2096f63d2661cd7b61ff8188a102bc28a78ce5..b153a04250754088dab1e536a97e4fd304d9a8cd 100644 --- hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetBlockProcessor.java +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetBlockProcessor.java @@ -14,6 +14,7 @@ * SPDX-License-Identifier: Apache-2.0 */ package org.hyperledger.besu.ethereum.mainnet;   +import org.hyperledger.besu.config.GenesisConfigOptions; import org.hyperledger.besu.datatypes.Address; import org.hyperledger.besu.datatypes.Wei; import org.hyperledger.besu.ethereum.core.BlockHeader; @@ -22,6 +23,7 @@ import org.hyperledger.besu.evm.account.MutableAccount; import org.hyperledger.besu.evm.worldstate.WorldUpdater;   import java.util.List; +import java.util.Optional;   import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -44,6 +46,24 @@ blockReward, miningBeneficiaryCalculator, skipZeroBlockRewards, protocolSchedule); + } + + public MainnetBlockProcessor( + final MainnetTransactionProcessor transactionProcessor, + final AbstractBlockProcessor.TransactionReceiptFactory transactionReceiptFactory, + final Wei blockReward, + final MiningBeneficiaryCalculator miningBeneficiaryCalculator, + final boolean skipZeroBlockRewards, + final ProtocolSchedule protocolSchedule, + final Optional<GenesisConfigOptions> genesisConfigOptions) { + super( + transactionProcessor, + transactionReceiptFactory, + blockReward, + miningBeneficiaryCalculator, + skipZeroBlockRewards, + protocolSchedule, + genesisConfigOptions); }   @Override

diff --git hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java index b008a8d5f603507c50d55e49667985511fa6b4b0..8e9a9372904f3f644b9e3c918139016ab6a07b93 100644 --- hyperledger/besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java +++ optimism-java/op-besu/ethereum/core/src/main/java/org/hyperledger/besu/ethereum/mainnet/MainnetTransactionProcessor.java @@ -21,8 +21,10 @@ import static org.hyperledger.besu.ethereum.mainnet.PrivateStateUtils.KEY_TRANSACTION_HASH; import static org.hyperledger.besu.evm.operation.BlockHashOperation.BlockHashLookup;   import org.hyperledger.besu.collections.trie.BytesTrieSet; +import org.hyperledger.besu.config.GenesisConfigOptions; import org.hyperledger.besu.datatypes.AccessListEntry; import org.hyperledger.besu.datatypes.Address; +import org.hyperledger.besu.datatypes.TransactionType; import org.hyperledger.besu.datatypes.Wei; import org.hyperledger.besu.ethereum.core.ProcessableBlockHeader; import org.hyperledger.besu.ethereum.core.Transaction; @@ -45,9 +47,11 @@ import org.hyperledger.besu.evm.tracing.OperationTracer; import org.hyperledger.besu.evm.worldstate.EVMWorldUpdater; import org.hyperledger.besu.evm.worldstate.WorldUpdater;   +import java.nio.charset.StandardCharsets; import java.util.Deque; import java.util.List; import java.util.Optional; +import java.util.OptionalLong; import java.util.Set;   import com.google.common.collect.HashMultimap; @@ -82,6 +86,10 @@ protected final FeeMarket feeMarket; private final CoinbaseFeePriceCalculator coinbaseFeePriceCalculator;   private final Optional<AuthorityProcessor> maybeAuthorityProcessor; + + private final Optional<GenesisConfigOptions> genesisConfigOptions; + + private final Optional<L1CostCalculator> l1CostCalculator;   public MainnetTransactionProcessor( final GasCalculator gasCalculator, @@ -127,6 +135,35 @@ this.maxStackSize = maxStackSize; this.feeMarket = feeMarket; this.coinbaseFeePriceCalculator = coinbaseFeePriceCalculator; this.maybeAuthorityProcessor = Optional.ofNullable(maybeAuthorityProcessor); + this.genesisConfigOptions = Optional.empty(); + this.l1CostCalculator = Optional.empty(); + } + + public MainnetTransactionProcessor( + final GasCalculator gasCalculator, + final TransactionValidatorFactory transactionValidatorFactory, + final AbstractMessageProcessor contractCreationProcessor, + final AbstractMessageProcessor messageCallProcessor, + final boolean clearEmptyAccounts, + final boolean warmCoinbase, + final int maxStackSize, + final FeeMarket feeMarket, + final CoinbaseFeePriceCalculator coinbaseFeePriceCalculator, + final AuthorityProcessor maybeAuthorityProcessor, + final Optional<GenesisConfigOptions> genesisConfigOptions, + final Optional<L1CostCalculator> l1CostCalculator) { + this.gasCalculator = gasCalculator; + this.transactionValidatorFactory = transactionValidatorFactory; + this.contractCreationProcessor = contractCreationProcessor; + this.messageCallProcessor = messageCallProcessor; + this.clearEmptyAccounts = clearEmptyAccounts; + this.warmCoinbase = warmCoinbase; + this.maxStackSize = maxStackSize; + this.feeMarket = feeMarket; + this.coinbaseFeePriceCalculator = coinbaseFeePriceCalculator; + this.maybeAuthorityProcessor = Optional.ofNullable(maybeAuthorityProcessor); + this.genesisConfigOptions = genesisConfigOptions; + this.l1CostCalculator = l1CostCalculator; }   /** @@ -286,6 +323,16 @@ final Boolean isPersistingPrivateState, final TransactionValidationParams transactionValidationParams, final PrivateMetadataUpdater privateMetadataUpdater, final Wei blobGasPrice) { + transaction + .getMint() + .ifPresent( + mint -> { + WorldUpdater mintUpdater = worldState.updater(); + final MutableAccount sender = + mintUpdater.getOrCreateSenderAccount(transaction.getSender()); + sender.incrementBalance(transaction.getMint().orElse(Wei.ZERO)); + mintUpdater.commit(); + }); final EVMWorldUpdater evmWorldUpdater = new EVMWorldUpdater(worldState); try { final var transactionValidator = transactionValidatorFactory.get(); @@ -293,6 +340,7 @@ LOG.trace("Starting execution of {}", transaction); ValidationResult<TransactionInvalidReason> validationResult = transactionValidator.validate( transaction, + OptionalLong.of(blockHeader.getTimestamp()), blockHeader.getBaseFee(), Optional.ofNullable(blobGasPrice), transactionValidationParams); @@ -311,6 +359,10 @@ validationResult = transactionValidator.validateForSender(transaction, sender, transactionValidationParams); if (!validationResult.isValid()) { LOG.debug("Invalid transaction: {}", validationResult.getErrorMessage()); + if (transaction.getType().equals(TransactionType.OPTIMISM_DEPOSIT)) { + return opDepositTxFailed( + worldState, blockHeader, transaction, validationResult.getErrorMessage()); + } return TransactionProcessingResult.invalid(validationResult); }   @@ -334,20 +386,39 @@ senderAddress, previousNonce, sender.getNonce());   - final Wei transactionGasPrice = - feeMarket.getTransactionPriceCalculator().price(transaction, blockHeader.getBaseFee()); + Wei transactionGasPrice = Wei.ZERO; + if (!TransactionType.OPTIMISM_DEPOSIT.equals(transaction.getType())) { + transactionGasPrice = + feeMarket.getTransactionPriceCalculator().price(transaction, blockHeader.getBaseFee());   - final long blobGas = gasCalculator.blobGasCost(transaction.getBlobCount()); + final long blobGas = gasCalculator.blobGasCost(transaction.getBlobCount());   - final Wei upfrontGasCost = - transaction.getUpfrontGasCost(transactionGasPrice, blobGasPrice, blobGas); - final Wei previousBalance = sender.decrementBalance(upfrontGasCost); - LOG.trace( - "Deducted sender {} upfront gas cost {} ({} -> {})", - senderAddress, - upfrontGasCost, - previousBalance, - sender.getBalance()); + final Wei upfrontGasCost = + transaction.getUpfrontGasCost(transactionGasPrice, blobGasPrice, blobGas); + final Wei previousBalance = sender.decrementBalance(upfrontGasCost); + LOG.trace( + "Deducted sender {} upfront gas cost {} ({} -> {})", + senderAddress, + upfrontGasCost, + previousBalance, + sender.getBalance()); + } + var l1CostGasFee = + genesisConfigOptions + .map( + options -> { + if (TransactionType.OPTIMISM_DEPOSIT.equals(transaction.getType())) { + return Wei.ZERO; + } + if (l1CostCalculator.isEmpty()) { + return Wei.ZERO; + } + return l1CostCalculator + .get() + .l1Cost(options, blockHeader, transaction, worldState); + }) + .orElse(Wei.ZERO); + sender.decrementBalance(l1CostGasFee);   final List<AccessListEntry> accessListEntries = transaction.getAccessList().orElse(List.of()); // we need to keep a separate hash set of addresses in case they specify no storage. @@ -410,7 +481,10 @@ .miningBeneficiary(miningBeneficiary) .blockHashLookup(blockHashLookup) .contextVariables(contextVariablesBuilder.build()) .accessListWarmAddresses(addressList) - .accessListWarmStorage(storageList); + .accessListWarmStorage(storageList) + .isDepositTx(TransactionType.OPTIMISM_DEPOSIT.equals(transaction.getType())) + .isSystemTx(transaction.getIsSystemTx().orElse(false)) + .mint(transaction.getMint());   if (transaction.getVersionedHashes().isPresent()) { commonMessageFrameBuilder.versionedHashes( @@ -484,12 +558,64 @@ transaction.getGasLimit() - initialFrame.getRemainingGas(), gasAvailable - initialFrame.getRemainingGas()); }   + boolean isRegolith = + genesisConfigOptions.isPresent() + && genesisConfigOptions.get().isRegolith(blockHeader.getTimestamp()); + + // if deposit: skip refunds, skip tipping coinbase + // Regolith changes this behaviour to report the actual gasUsed instead of always reporting + // all gas used. + if (initialFrame.isDepositTx() && !isRegolith) { + var gasUsed = transaction.getGasLimit(); + if (initialFrame.isSystemTx()) { + gasUsed = 0L; + } + if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) { + return TransactionProcessingResult.successful( + initialFrame.getLogs(), gasUsed, 0L, initialFrame.getOutputData(), validationResult); + } else { + return TransactionProcessingResult.failed( + gasUsed, 0L, validationResult, initialFrame.getRevertReason()); + } + } + // Refund the sender by what we should and pay the miner fee (note that we're doing them one // after the other so that if it is the same account somehow, we end up with the right result) final long selfDestructRefund = gasCalculator.getSelfDestructRefundAmount() * initialFrame.getSelfDestructs().size(); final long baseRefundGas = initialFrame.getGasRefund() + selfDestructRefund; - final long refundedGas = refunded(transaction, initialFrame.getRemainingGas(), baseRefundGas); + final long refundedGas = refunded(transaction, initialFrame, baseRefundGas); + final long gasUsedByTransaction = transaction.getGasLimit() - initialFrame.getRemainingGas(); + + // Skip coinbase payments for deposit tx in Regolith + if (initialFrame.isDepositTx() && isRegolith) { + operationTracer.traceEndTransaction( + worldUpdater, + transaction, + initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS, + initialFrame.getOutputData(), + initialFrame.getLogs(), + gasUsedByTransaction, + initialFrame.getSelfDestructs(), + 0L); + initialFrame.getSelfDestructs().forEach(worldState::deleteAccount); + if (clearEmptyAccounts) { + worldState.clearAccountsThatAreEmpty(); + } + + if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) { + return TransactionProcessingResult.successful( + initialFrame.getLogs(), + gasUsedByTransaction, + refundedGas, + initialFrame.getOutputData(), + validationResult); + } else { + return TransactionProcessingResult.failed( + gasUsedByTransaction, refundedGas, validationResult, initialFrame.getRevertReason()); + } + } + final Wei refundedWei = transactionGasPrice.multiply(refundedGas); final Wei balancePriorToRefund = sender.getBalance(); sender.incrementBalance(refundedWei); @@ -500,7 +626,6 @@ .addArgument(refundedWei) .addArgument(balancePriorToRefund) .addArgument(sender.getBalance()) .log(); - final long gasUsedByTransaction = transaction.getGasLimit() - initialFrame.getRemainingGas();   // update the coinbase final long usedGas = transaction.getGasLimit() - refundedGas; @@ -546,6 +671,34 @@ if (clearEmptyAccounts) { evmWorldUpdater.clearAccountsThatAreEmpty(); }   + // Check that we are post bedrock to enable op-geth to be able to create pseudo pre-bedrock + // blocks (these are pre-bedrock, but don't follow l2 geth rules) + // Note optimismConfig will not be nil if rules.IsOptimismBedrock is true + genesisConfigOptions.ifPresent( + options -> { + if (!options.isBedrockBlock(blockHeader.getNumber())) { + return; + } + if (initialFrame.isDepositTx()) { + return; + } + MutableAccount opBaseFeeRecipient = + evmWorldUpdater.getOrCreate( + Address.fromHexString("0x4200000000000000000000000000000000000019")); + opBaseFeeRecipient.incrementBalance( + blockHeader.getBaseFee().get().multiply(gasUsedByTransaction)); + + if (l1CostCalculator.isEmpty()) { + return; + } + var l1Cost = + l1CostCalculator.get().l1Cost(options, blockHeader, transaction, worldState); + MutableAccount opL1FeeRecipient = + evmWorldUpdater.getOrCreate( + Address.fromHexString("0x420000000000000000000000000000000000001A")); + opL1FeeRecipient.incrementBalance(l1Cost); + }); + if (initialFrame.getState() == MessageFrame.State.COMPLETED_SUCCESS) { return TransactionProcessingResult.successful( initialFrame.getLogs(), @@ -583,6 +736,22 @@ // need to throw to trigger the heal throw re; } catch (final RuntimeException re) { + if (TransactionType.OPTIMISM_DEPOSIT.equals(transaction.getType())) { + evmWorldUpdater.revert(); + evmWorldUpdater.getAccount(transaction.getSender()).incrementNonce(); + var gasUsed = transaction.getGasLimit(); + if (transaction.getIsSystemTx().get() + && genesisConfigOptions.get().isRegolith(blockHeader.getTimestamp())) { + gasUsed = 0L; + } + final String msg = String.format("failed deposit: %s", re); + return TransactionProcessingResult.failed( + gasUsed, + 0L, + ValidationResult.valid(), + Optional.of(Bytes.wrap(msg.getBytes(StandardCharsets.UTF_8)))); + } + operationTracer.traceEndTransaction( evmWorldUpdater.updater(), transaction, @@ -592,6 +761,9 @@ List.of(), 0, EMPTY_ADDRESS_SET, 0L); + if (TransactionType.OPTIMISM_DEPOSIT.equals(transaction.getType())) { + return opDepositTxFailed(worldState, blockHeader, transaction, re.getMessage()); + }   LOG.error("Critical Exception Processing Transaction", re); return TransactionProcessingResult.invalid( @@ -601,6 +773,30 @@ "Internal Error in Besu - " + re + "\n" + printableStackTraceFromThrowable(re))); } }   + private TransactionProcessingResult opDepositTxFailed( + final WorldUpdater worldState, + final ProcessableBlockHeader blockHeader, + final Transaction transaction, + final String reason) { + worldState.revert(); + worldState.getOrCreate(transaction.getSender()).incrementNonce(); + if (clearEmptyAccounts) { + worldState.clearAccountsThatAreEmpty(); + } + worldState.commit(); + var gasUsed = transaction.getGasLimit(); + if (transaction.getIsSystemTx().get() + && genesisConfigOptions.get().isRegolith(blockHeader.getTimestamp())) { + gasUsed = 0L; + } + final String msg = String.format("failed deposit: %s", reason); + return TransactionProcessingResult.failed( + gasUsed, + 0L, + ValidationResult.valid(), + Optional.of(Bytes.wrap(msg.getBytes(StandardCharsets.UTF_8)))); + } + public void process(final MessageFrame frame, final OperationTracer operationTracer) { final AbstractMessageProcessor executor = getMessageProcessor(frame.getType());   @@ -612,6 +808,17 @@ return switch (type) { case MESSAGE_CALL -> messageCallProcessor; case CONTRACT_CREATION -> contractCreationProcessor; }; + } + + protected long refunded( + final Transaction transaction, final MessageFrame initialFrame, final long gasRefund) { + final long gasRemaining = initialFrame.getRemainingGas(); + // Integer truncation takes care of the floor calculation needed after the divide. + final long maxRefundAllowance = + (transaction.getGasLimit() - gasRemaining) / gasCalculator.getMaxRefundQuotient(); + final long refundAllowance = Math.min(maxRefundAllowance, gasRefund); + initialFrame.incrementRemainingGas(refundAllowance); + return initialFrame.getRemainingGas(); }   protected long refunded(

diff --git hyperledger/besu/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/transactions/layered/BaseFeePrioritizedTransactions.java optimism-java/op-besu/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/transactions/layered/BaseFeePrioritizedTransactions.java index b3dec34b7724d4141d5c59b48a3d55edcd6d0976..f9e5844240d402339cc227a848469ceea4a3d0d1 100644 --- hyperledger/besu/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/transactions/layered/BaseFeePrioritizedTransactions.java +++ optimism-java/op-besu/ethereum/eth/src/main/java/org/hyperledger/besu/ethereum/eth/transactions/layered/BaseFeePrioritizedTransactions.java @@ -29,6 +29,7 @@ import org.hyperledger.besu.ethereum.mainnet.feemarket.FeeMarket;   import java.util.Comparator; import java.util.Optional; +import java.util.OptionalLong; import java.util.function.BiFunction; import java.util.function.Supplier;   @@ -150,7 +151,8 @@ return baseFeeMarket.computeBaseFee( blockHeader.getNumber() + 1, blockHeader.getBaseFee().orElse(Wei.ZERO), blockHeader.getGasUsed(), - baseFeeMarket.targetGasUsed(blockHeader)); + baseFeeMarket.targetGasUsed(blockHeader), + OptionalLong.of(blockHeader.getTimestamp())); } return Wei.ZERO; }

diff --git hyperledger/besu/evm/src/main/java/org/hyperledger/besu/evm/frame/MessageFrame.java optimism-java/op-besu/evm/src/main/java/org/hyperledger/besu/evm/frame/MessageFrame.java index 16551876d2433ffa108de0796aae81c6d4f8a0c2..1cf214bf9f4db1bc7fa804a2c8decc265f9ead09 100644 --- hyperledger/besu/evm/src/main/java/org/hyperledger/besu/evm/frame/MessageFrame.java +++ optimism-java/op-besu/evm/src/main/java/org/hyperledger/besu/evm/frame/MessageFrame.java @@ -230,6 +230,9 @@ private final Address sender; private final Wei value; private final Wei apparentValue; private final Code code; + private final boolean isSystemTx; + private final boolean isDepositTx; + private final Optional<Wei> mint;   private Optional<Bytes> revertReason;   @@ -266,6 +269,9 @@ final Address sender, final Wei value, final Wei apparentValue, final Code code, + final boolean isSystemTx, + final boolean isDepositTx, + final Optional<Wei> mint, final boolean isStatic, final Consumer<MessageFrame> completer, final Map<String, Object> contextVariables, @@ -286,6 +292,9 @@ this.sender = sender; this.value = value; this.apparentValue = apparentValue; this.code = code; + this.isSystemTx = isSystemTx; + this.isDepositTx = isDepositTx; + this.mint = mint; this.isStatic = isStatic; this.completer = completer; this.contextVariables = contextVariables; @@ -1020,6 +1029,33 @@ return code; }   /** + * Is deposit tx boolean. + * + * @return the boolean + */ + public boolean isDepositTx() { + return isDepositTx; + } + + /** + * Is system tx boolean. + * + * @return the boolean + */ + public boolean isSystemTx() { + return isSystemTx; + } + + /** + * Gets mint. + * + * @return the mint + */ + public Optional<Wei> getMint() { + return mint; + } + + /** * Returns the current input data. * * @return the current input data @@ -1336,6 +1372,9 @@ private Bytes inputData; private Address sender; private Wei value; private Wei apparentValue; + private boolean isSystemTx; + private boolean isDepositTx; + private Optional<Wei> mint; private Code code; private BlockValues blockValues; private int maxStackSize = DEFAULT_MAX_STACK_SIZE; @@ -1511,6 +1550,39 @@ return this; }   /** + * Is system tx builder. + * + * @param isSystemTx the is system tx + * @return the builder + */ + public Builder isSystemTx(final boolean isSystemTx) { + this.isSystemTx = isSystemTx; + return this; + } + + /** + * Is deposit tx builder. + * + * @param isDepositTx the is deposit tx + * @return the builder + */ + public Builder isDepositTx(final boolean isDepositTx) { + this.isDepositTx = isDepositTx; + return this; + } + + /** + * Mint builder. + * + * @param mint the mint + * @return the builder + */ + public Builder mint(final Optional<Wei> mint) { + this.mint = mint; + return this; + } + + /** * Sets Block values. * * @param blockValues the block values @@ -1704,6 +1776,9 @@ sender, value, apparentValue, code, + isSystemTx, + isDepositTx, + mint, newStatic, completer, contextVariables == null ? Map.of() : contextVariables,