// Copyright 2015 The go-ethereum Authors
// (original work)
// Copyright 2024 The Erigon Authors
// (modifications)
// This file is part of Erigon.
//
// Erigon is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Erigon is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with Erigon. If not, see <http://www.gnu.org/licenses/>.

package params

import (
	"github.com/holiman/uint256"

	"github.com/erigontech/erigon/common"
	"github.com/erigontech/erigon/execution/types/accounts"
)

const (
	GasLimitBoundDivisor uint64 = 1024               // The bound divisor of the gas limit, used in update calculations.
	MinBlockGasLimit     uint64 = 5000               // Minimum the block gas limit may ever be.
	MaxBlockGasLimit     uint64 = 0x7fffffffffffffff // Maximum the block gas limit may ever be.
	MaxTxnGasLimit       uint64 = 16_777_216         // See EIP-7825: Transaction Gas Limit Cap.
	GenesisGasLimit      uint64 = 4712388            // Gas limit of the Genesis block.

	MaximumExtraDataSize  uint64 = 32    // Maximum size extra data may be after Genesis.
	CallValueTransferGas  uint64 = 9000  // Paid for CALL when the value transfer is non-zero.
	CallNewAccountGas     uint64 = 25000 // Paid for CALL when the destination address didn't exist prior.
	TxGas                 uint64 = 21000 // Per transaction not creating a contract. NOTE: Not payable on data of calls between transactions.
	TxGasContractCreation uint64 = 53000 // Per transaction that creates a contract. NOTE: Not payable on data of calls between transactions.
	TxAAGas               uint64 = 15000 // Per account abstraction transaction
	TxDataZeroGas         uint64 = 4     // Per byte of data attached to a transaction that equals zero. NOTE: Not payable on data of calls between transactions.

	QuadCoeffDiv uint64 = 512  // Divisor for the quadratic particle of the memory cost equation.
	LogDataGas   uint64 = 8    // Per byte in a LOG* operation's data.
	CallStipend  uint64 = 2300 // Free gas given at beginning of call.

	Keccak256Gas     uint64 = 30 // Once per KECCAK256 operation.
	Keccak256WordGas uint64 = 6  // Once per word of the KECCAK256 operation's data.
	InitCodeWordGas  uint64 = 2  // Once per word of the init code when creating a contract.

	SstoreSetGas    uint64 = 20000 // Once per SLOAD operation.
	SstoreResetGas  uint64 = 5000  // Once per SSTORE operation if the zeroness changes from zero.
	SstoreClearGas  uint64 = 5000  // Once per SSTORE operation if the zeroness doesn't change.
	SstoreRefundGas uint64 = 15000 // Once per SSTORE operation if the zeroness changes to zero.

	NetSstoreNoopGas  uint64 = 200   // Once per SSTORE operation if the value doesn't change.
	NetSstoreInitGas  uint64 = 20000 // Once per SSTORE operation from clean zero.
	NetSstoreCleanGas uint64 = 5000  // Once per SSTORE operation from clean non-zero.
	NetSstoreDirtyGas uint64 = 200   // Once per SSTORE operation from dirty.

	NetSstoreClearRefund      uint64 = 15000 // Once per SSTORE operation for clearing an originally existing storage slot
	NetSstoreResetRefund      uint64 = 4800  // Once per SSTORE operation for resetting to the original non-zero value
	NetSstoreResetClearRefund uint64 = 19800 // Once per SSTORE operation for resetting to the original zero value

	SstoreSentryGasEIP2200            uint64 = 2300  // Minimum gas required to be present for an SSTORE call, not consumed
	SstoreSetGasEIP2200               uint64 = 20000 // Once per SSTORE operation from clean zero to non-zero
	SstoreResetGasEIP2200             uint64 = 5000  // Once per SSTORE operation from clean non-zero to something else
	SstoreClearsScheduleRefundEIP2200 uint64 = 15000 // Once per SSTORE operation for clearing an originally existing storage slot

	ColdAccountAccessCostEIP2929 = uint64(2600) // COLD_ACCOUNT_ACCESS_COST
	ColdSloadCostEIP2929         = uint64(2100) // COLD_SLOAD_COST
	WarmStorageReadCostEIP2929   = uint64(100)  // WARM_STORAGE_READ_COST

	// In EIP-2200: SstoreResetGas was 5000.
	// In EIP-2929: SstoreResetGas was changed to '5000 - COLD_SLOAD_COST'.
	// In EIP-3529: SSTORE_CLEARS_SCHEDULE is defined as SSTORE_RESET_GAS + ACCESS_LIST_STORAGE_KEY_COST
	// Which becomes: 5000 - 2100 + 1900 = 4800
	SstoreClearsScheduleRefundEIP3529 = SstoreResetGasEIP2200 - ColdSloadCostEIP2929 + TxAccessListStorageKeyGas

	// EIP-2929/3529 SSTORE schedule as "access cost + write cost": the access
	// carries the warm SLOAD, so the write costs are net of it.
	SstoreColdAccessEIP2929    = ColdSloadCostEIP2929 + WarmStorageReadCostEIP2929                         // 2200
	SstoreWriteCreateEIP2929   = SstoreSetGasEIP2200 - WarmStorageReadCostEIP2929                          // 19900
	SstoreWriteExistingEIP2929 = SstoreResetGasEIP2200 - ColdSloadCostEIP2929 - WarmStorageReadCostEIP2929 // 2800

	JumpdestGas   uint64 = 1     // Once per JUMPDEST operation.
	EpochDuration uint64 = 30000 // Duration between proof-of-work epochs.

	CreateDataGas         uint64 = 200   //
	CallCreateDepth       uint64 = 1024  // Maximum depth of call/create stack.
	ExpGas                uint64 = 10    // Once per EXP instruction
	LogGas                uint64 = 375   // Per LOG* operation.
	CopyGas               uint64 = 3     //
	StackLimit            uint64 = 1024  // Maximum size of VM stack allowed.
	TierStepGas           uint64 = 0     // Once per operation, for a selection of them.
	LogTopicGas           uint64 = 375   // Multiplied by the * of the LOG*, per LOG transaction. e.g. LOG0 incurs 0 * c_txLogTopicGas, LOG4 incurs 4 * c_txLogTopicGas.
	CreateGas             uint64 = 32000 // Once per CREATE operation & contract-creation transaction.
	Create2Gas            uint64 = 32000 // Once per CREATE2 operation
	SelfdestructRefundGas uint64 = 24000 // Refunded following a selfdestruct operation.
	MemoryGas             uint64 = 3     // Times the address of the (highest referenced byte in memory + 1). NOTE: referencing happens on read, write and in instructions such as RETURN and CALL.

	TxDataNonZeroGasFrontier        uint64 = 68   // Per byte of data attached to a transaction that is not equal to zero. NOTE: Not payable on data of calls between transactions.
	TxDataNonZeroGasEIP2028         uint64 = 16   // Per byte of non zero data attached to a transaction after EIP 2028 (part in Istanbul)
	TxAccessListAddressGas          uint64 = 2400 // Per address specified in EIP 2930 access list
	TxAccessListStorageKeyGas       uint64 = 1900 // Per storage key specified in EIP 2930 access list
	TxTotalCostFloorPerToken        uint64 = 10   // Per token of calldata in a transaction, as a minimum the txn must pay (EIP-7623)
	TxTotalCostFloorPerTokenEIP7976 uint64 = 16   // Per token of calldata floor cost (EIP-7976, reused by EIP-7981)
	TxAccessListAddressBytes        uint64 = 20   // Byte length of an access list address (EIP-7981)
	TxAccessListStorageKeyBytes     uint64 = 32   // Byte length of an access list storage key (EIP-7981)
	TxStandardTokensPerByte         uint64 = 4    // Tokens per byte for EIP-7976 / EIP-7981 floor calculation

	// These have been changed during the course of the chain
	CallGasFrontier              uint64 = 40  // Once per CALL operation & message call transaction.
	CallGasEIP150                uint64 = 700 // Static portion of gas for CALL-derivatives after EIP 150 (Tangerine)
	BalanceGasFrontier           uint64 = 20  // The cost of a BALANCE operation
	BalanceGasEIP150             uint64 = 400 // The cost of a BALANCE operation after Tangerine
	BalanceGasEIP1884            uint64 = 700 // The cost of a BALANCE operation after EIP 1884 (part of Istanbul)
	ExtcodeSizeGasFrontier       uint64 = 20  // Cost of EXTCODESIZE before EIP 150 (Tangerine)
	ExtcodeSizeGasEIP150         uint64 = 700 // Cost of EXTCODESIZE after EIP 150 (Tangerine)
	SloadGasFrontier             uint64 = 50
	SloadGasEIP150               uint64 = 200
	SloadGasEIP1884              uint64 = 800  // Cost of SLOAD after EIP 1884 (part of Istanbul)
	SloadGasEIP2200              uint64 = 800  // Cost of SLOAD after EIP 2200 (part of Istanbul)
	ExtcodeHashGasConstantinople uint64 = 400  // Cost of EXTCODEHASH (introduced in Constantinople)
	ExtcodeHashGasEIP1884        uint64 = 700  // Cost of EXTCODEHASH after EIP 1884 (part in Istanbul)
	SelfdestructGasEIP150        uint64 = 5000 // Cost of SELFDESTRUCT post EIP 150 (Tangerine)

	// EXP has a dynamic portion depending on the size of the exponent
	ExpByteFrontier uint64 = 10 // was set to 10 in Frontier
	ExpByteEIP160   uint64 = 50 // was raised to 50 during EIP 160 (Spurious Dragon)

	// Extcodecopy has a dynamic AND a static cost. This represents only the
	// static portion of the gas. It was changed during EIP 150 (Tangerine)
	ExtcodeCopyBaseFrontier uint64 = 20
	ExtcodeCopyBaseEIP150   uint64 = 700

	// CreateBySelfdestructGas is used when the refunded account is one that does
	// not exist. This logic is similar to call.
	// Introduced in Tangerine Whistle (Eip 150)
	CreateBySelfdestructGas uint64 = 25000

	BaseFeeChangeDenominator           = 8          // Bounds the amount the base fee can change between blocks.
	BaseFeeChangeDenominatorPostDelhi  = 16         // Bounds the amount the base fee can change between blocks post delhi hard fork for polygon networks.
	BaseFeeChangeDenominatorPostBhilai = 64         // Bounds the amount the base fee can change between blocks post bhilai hard fork for polygon networks.
	ElasticityMultiplier               = 2          // Bounds the maximum gas limit an EIP-1559 block may have.
	InitialBaseFee                     = 1000000000 // Initial base fee for EIP-1559 blocks.

	MaxCodeSize              = 24 * 1024                // Maximum bytecode to permit for a contract
	MaxCodeSizeAhmedabad     = 32 * 1024                // Maximum bytecode to permit for a contract post Ahmedabad hard fork (bor / polygon pos) (32KB)
	MaxInitCodeSize          = 2 * MaxCodeSize          // Maximum initcode to permit in a creation transaction and create instructions
	MaxCodeSizeAmsterdam     = 64 * 1024                // EIP-7954: Increase Maximum Contract Size
	MaxInitCodeSizeAmsterdam = 2 * MaxCodeSizeAmsterdam // EIP-7954: Increase Maximum Contract Size

	// Precompiled contract gas prices

	EcrecoverGas        uint64 = 3000 // Elliptic curve sender recovery gas price
	Sha256BaseGas       uint64 = 60   // Base price for a SHA256 operation
	Sha256PerWordGas    uint64 = 12   // Per-word price for a SHA256 operation
	Ripemd160BaseGas    uint64 = 600  // Base price for a RIPEMD160 operation
	Ripemd160PerWordGas uint64 = 120  // Per-word price for a RIPEMD160 operation
	IdentityBaseGas     uint64 = 15   // Base price for a data copy operation
	IdentityPerWordGas  uint64 = 3    // Per-work price for a data copy operation

	Bn254AddGasByzantium             uint64 = 500    // Byzantium gas needed for an elliptic curve addition
	Bn254AddGasIstanbul              uint64 = 150    // Gas needed for an elliptic curve addition
	Bn254ScalarMulGasByzantium       uint64 = 40000  // Byzantium gas needed for an elliptic curve scalar multiplication
	Bn254ScalarMulGasIstanbul        uint64 = 6000   // Gas needed for an elliptic curve scalar multiplication
	Bn254PairingBaseGasByzantium     uint64 = 100000 // Byzantium base price for an elliptic curve pairing check
	Bn254PairingBaseGasIstanbul      uint64 = 45000  // Base price for an elliptic curve pairing check
	Bn254PairingPerPointGasByzantium uint64 = 80000  // Byzantium per-point price for an elliptic curve pairing check
	Bn254PairingPerPointGasIstanbul  uint64 = 34000  // Per-point price for an elliptic curve pairing check

	Bls12381G1AddGas          uint64 = 375   // Price for BLS12-381 elliptic curve G1 point addition
	Bls12381G1MulGas          uint64 = 12000 // Price for BLS12-381 elliptic curve G1 point scalar multiplication
	Bls12381G2AddGas          uint64 = 600   // Price for BLS12-381 elliptic curve G2 point addition
	Bls12381G2MulGas          uint64 = 22500 // Price for BLS12-381 elliptic curve G2 point scalar multiplication
	Bls12381PairingBaseGas    uint64 = 37700 // Base gas price for BLS12-381 elliptic curve pairing check
	Bls12381PairingPerPairGas uint64 = 32600 // Per-point pair gas price for BLS12-381 elliptic curve pairing check
	Bls12381MapFpToG1Gas      uint64 = 5500  // Gas price for BLS12-381 mapping field element to G1 operation
	Bls12381MapFp2ToG2Gas     uint64 = 23800 // Gas price for BLS12-381 mapping field element to G2 operation

	// The Refund Quotient is the cap on how much of the used gas can be refunded. Before EIP-3529,
	// up to half the consumed gas could be refunded.
	RefundQuotient        uint64 = 2
	RefundQuotientEIP3529 uint64 = 5 // After EIP-3529: refunds are capped to gasUsed / 5

	// EIP-4844: Shard Blob Transactions
	PointEvaluationGas   uint64 = 50000
	FieldElementsPerBlob        = 4096 // each field element is 32 bytes
	BlobSize                    = FieldElementsPerBlob * 32
	GasPerBlob           uint64 = 1 << 17
	BlobBaseCost         uint64 = 1 << 13 // EIP-7918: Blob base fee bounded by execution cost

	// EIP-7594: PeerDAS - Peer Data Availability Sampling
	// See https://github.com/ethereum/consensus-specs/blob/dev/specs/fulu/polynomial-commitments-sampling.md
	FieldElementsPerExtBlob        = 2 * FieldElementsPerBlob                       // Number of field elements in a Reed-Solomon extended blob
	FieldElementsPerCell    uint64 = 64                                             // Number of Field elements in a cell
	BytesPerCell                   = FieldElementsPerCell * 32                      // The number of bytes in a cell
	CellsPerExtBlob                = FieldElementsPerExtBlob / FieldElementsPerCell // The number of cells in an extended blob
	MaxBlobsPerTxn                 = 6                                              // https://github.com/ethereum/EIPs/pull/9981

	// PIP-27: secp256r1 elliptic curve signature verifier gas price
	P256VerifyGas        uint64 = 3450
	P256VerifyGasEIP7951 uint64 = 6900

	// EIP-2935: Historical block hashes in state
	BlockHashHistoryServeWindow uint64 = 8191
	BlockHashOldWindow          uint64 = 256

	// EIP-7702: Set EOA account code
	SetCodeMagicPrefix  = byte(0x05)
	PerEmptyAccountCost = 25000
	PerAuthBaseCost     = 12500

	// EIP-7934: RLP Execution Block Size Limit
	MaxBlockSize             = 10_485_760 // 10 MiB
	MaxBlockSizeSafetyMargin = 2_097_152  // 2 MiB
	MaxRlpBlockSize          = MaxBlockSize - MaxBlockSizeSafetyMargin

	// EIP-8037: State Creation Gas Cost Increase
	CreateGasEIP8037        = CallValueTransferGas // spec: "9000, assuming same as GAS_CALL_VALUE"
	Create2GasEIP8037       = CallValueTransferGas
	StateBytesNewAccount    = 120 // bytes per new account creation
	StateBytesPerStorageSet = 64  // bytes per new storage slot
	StateBytesAuthBase      = 23  // bytes per authorization base cost
	SystemMaxSstoresPerCall = 16  // upper bound on new SSTOREs per system call (matches MAX_WITHDRAWAL_REQUESTS_PER_BLOCK)
	CostPerStateByte        = 1530

	// Pre-multiplied state-gas costs (StateBytesX * CostPerStateByte) for hot paths.
	StateGasNewAccount        = StateBytesNewAccount * CostPerStateByte
	StateGasPerStorageSet     = StateBytesPerStorageSet * CostPerStateByte
	StateGasAuthBase          = StateBytesAuthBase * CostPerStateByte
	StateGasNewAccountAndAuth = (StateBytesNewAccount + StateBytesAuthBase) * CostPerStateByte
	StateGasSystemMaxSstores  = StateBytesPerStorageSet * CostPerStateByte * SystemMaxSstoresPerCall

	// EIP-8038: State-access gas cost update. Reprices the EIP-2929 state-access
	// costs and adds the regular-gas write components (ACCOUNT_WRITE, STORAGE_WRITE)
	// that the EIP-8037 state-gas model is charged alongside.
	ColdAccountAccessCostEIP8038      = uint64(3000)                                           // COLD_ACCOUNT_ACCESS (EIP-2929: 2600)
	ColdStorageAccessCostEIP8038      = uint64(3000)                                           // COLD_STORAGE_ACCESS (EIP-2929 cold SLOAD: 2100)
	AccountWriteCostEIP8038           = uint64(8000)                                           // ACCOUNT_WRITE: account balance-leaf write
	StorageWriteCostEIP8038           = uint64(10000)                                          // STORAGE_WRITE: first write to a slot in the txn
	CallValueTransferGasEIP8038       = AccountWriteCostEIP8038 + CallStipend                  // CALL_VALUE = 10300
	CreateAccessEIP8038               = AccountWriteCostEIP8038 + ColdStorageAccessCostEIP8038 // CREATE_ACCESS = 11000
	SstoreClearsScheduleRefundEIP8038 = uint64(12480)                                          // REFUND_STORAGE_CLEAR = (STORAGE_WRITE+COLD_STORAGE_ACCESS)*4800/5000
	TxAccessListAddressGasEIP8038     = ColdAccountAccessCostEIP8038                           // ACCESS_LIST_ADDRESS_COST
	TxAccessListStorageKeyGasEIP8038  = ColdStorageAccessCostEIP8038                           // ACCESS_LIST_STORAGE_KEY_COST
	ExtCodeWarmAccessGasEIP8038       = 2 * WarmStorageReadCostEIP2929                         // EXTCODESIZE/EXTCODECOPY: account access + second read for the code
	// REGULAR_PER_AUTH_BASE_COST = 101 auth-tuple bytes * 16 + ECRECOVER + COLD_ACCOUNT_ACCESS + 2*WARM_ACCESS = 7816
	RegularPerAuthBaseCostEIP8038 = 101*TxDataNonZeroGasEIP2028 + EcrecoverGas + ColdAccountAccessCostEIP8038 + 2*WarmStorageReadCostEIP2929
	// PER_AUTH regular intrinsic = ACCOUNT_WRITE + REGULAR_PER_AUTH_BASE_COST = 15816
	PerAuthRegularCostEIP8038 = AccountWriteCostEIP8038 + RegularPerAuthBaseCostEIP8038

	// EIP-2780: Reduce intrinsic transaction gas (resource-based decomposition).
	// COLD_ACCOUNT_ACCESS and CREATE_ACCESS take their values from EIP-8038.
	TxBaseEIP2780            uint64 = 12_000 // TX_BASE: sender ECDSA recovery plus access and write
	TxValueCostEIP2780       uint64 = 4_244  // TX_VALUE_COST: recipient balance write for value transfers
	TransferLogCostEIP2780   uint64 = 1_756  // TRANSFER_LOG_COST: EIP-7708 transfer log
	ColdAccountAccessEIP2780 uint64 = 3_000  // COLD_ACCOUNT_ACCESS: recipient account touch
	CreateAccessEIP2780      uint64 = 11_000 // CREATE_ACCESS: ACCOUNT_WRITE(8000) + COLD_STORAGE_ACCESS(3000)
)

// EIP-7702: Set EOA account code
var DelegatedDesignationPrefix = []byte{0xef, 0x01, 0x00}
var DelegatedCodeHash = common.HexToHash("0xeadcdba66a79ab5dce91622d1d75c8cff5cff0b96944c3bf1072cd08ce018329")

// SystemAddress is where the system-transaction is sent from as per EIP-4788
var SystemAddress = accounts.InternAddress(common.HexToAddress("0xfffffffffffffffffffffffffffffffffffffffe"))

// EIP-4788: Beacon block root in the EVM
var BeaconRootsAddress = accounts.InternAddress(common.HexToAddress("0x000F3df6D732807Ef1319fB7B8bB8522d0Beac02"))

// EIP-2935: Historical block hashes in state
var HistoryStorageAddress = accounts.InternAddress(common.HexToAddress("0x0000F90827F1C53a10cb7A02335B175320002935"))

// EIP-7002: Execution layer triggerable withdrawals
var WithdrawalRequestAddress = accounts.InternAddress(common.HexToAddress("0x00000961Ef480Eb55e80D19ad83579A64c007002"))

// EIP-7251: Increase the MAX_EFFECTIVE_BALANCE
var ConsolidationRequestAddress = accounts.InternAddress(common.HexToAddress("0x0000BBdDc7CE488642fb579F8B00f3a590007251"))

// Gas discount table for BLS12-381 G1 and G2 multi exponentiation operations
var Bls12381MSMDiscountTableG1 = [128]uint64{1000, 949, 848, 797, 764, 750, 738, 728, 719, 712, 705, 698, 692, 687, 682, 677, 673, 669, 665, 661, 658, 654, 651, 648, 645, 642, 640, 637, 635, 632, 630, 627, 625, 623, 621, 619, 617, 615, 613, 611, 609, 608, 606, 604, 603, 601, 599, 598, 596, 595, 593, 592, 591, 589, 588, 586, 585, 584, 582, 581, 580, 579, 577, 576, 575, 574, 573, 572, 570, 569, 568, 567, 566, 565, 564, 563, 562, 561, 560, 559, 558, 557, 556, 555, 554, 553, 552, 551, 550, 549, 548, 547, 547, 546, 545, 544, 543, 542, 541, 540, 540, 539, 538, 537, 536, 536, 535, 534, 533, 532, 532, 531, 530, 529, 528, 528, 527, 526, 525, 525, 524, 523, 522, 522, 521, 520, 520, 519}

var Bls12381MSMDiscountTableG2 = [128]uint64{1000, 1000, 923, 884, 855, 832, 812, 796, 782, 770, 759, 749, 740, 732, 724, 717, 711, 704, 699, 693, 688, 683, 679, 674, 670, 666, 663, 659, 655, 652, 649, 646, 643, 640, 637, 634, 632, 629, 627, 624, 622, 620, 618, 615, 613, 611, 609, 607, 606, 604, 602, 600, 598, 597, 595, 593, 592, 590, 589, 587, 586, 584, 583, 582, 580, 579, 578, 576, 575, 574, 573, 571, 570, 569, 568, 567, 566, 565, 563, 562, 561, 560, 559, 558, 557, 556, 555, 554, 553, 552, 552, 551, 550, 549, 548, 547, 546, 545, 545, 544, 543, 542, 541, 541, 540, 539, 538, 537, 537, 536, 535, 535, 534, 533, 532, 532, 531, 530, 530, 529, 528, 528, 527, 526, 526, 525, 524, 524}

var (
	GenesisDifficulty = uint256.NewInt(131072) // Difficulty of the Genesis block.
)

// EIP-8282 - The Builder Deposit Addresses
// Nick's-method derived address from the builder deposit contract deployment transaction.
var BuilderDepositAddress = accounts.InternAddress(common.HexToAddress("0x0000884d2AA32eAa155F59A2f24eFa73D9008282"))

// EIP-8282 - The Builder Exit Addresses
// Nick's-method derived address from the builder exit contract deployment transaction.
var BuilderExitAddress = accounts.InternAddress(common.HexToAddress("0x000014574A74c805590AFF9499fc7A690f008282"))

// See EIP-7840: Add blob schedule to EL config files
type BlobConfig struct {
	BaseFeeUpdateFraction uint64 `json:"baseFeeUpdateFraction"`
	Max                   uint64 `json:"max"`
	Target                uint64 `json:"target"`
}

var DefaultCancunBlobConfig = BlobConfig{
	Target:                3,
	Max:                   6,
	BaseFeeUpdateFraction: 3338477,
}

var DefaultPragueBlobConfig = BlobConfig{
	Target:                6,
	Max:                   9,
	BaseFeeUpdateFraction: 5007716,
}
