ການ , ການຄາດຄະເນດິນຟ້າອິນເຕີເນັດ , ແມ່ນການປັບປຸງເຄືອຂ່າຍຂະຫນາດໃຫຍ່ທີ່ຜ່ານມາຂອງ Ethereum ຫຼັງຈາກ Pectra, ແລະມັນເປັນຕົວແທນຂອງການປັບປຸງຂະຫນາດໃຫຍ່ເພີ່ມເຕີມຂອງຜູ້ໃຫຍ່ crypto ໄດ້. Fusaka hard fork ປະເພດ December 3, 2025 Fusaka hard fork ປະເພດ ການປັບປຸງ Pectra EIPs ການປັບປຸງຄວາມສາມາດ, ຄວາມປອດໄພແລະເຄື່ອງມືຜູ້ພັດທະນາ. PeerDAS ( ) makes data availability more efficient by letting nodes verify blobs without downloading everything. Several upgrades tighten execution safety, including limits on ModExp ( ), ຄ່າໃຊ້ຈ່າຍອາຍແກັສໃນອຸດສາຫະກໍາອຸດສາຫະກໍາ ( ), ແລະການປັບປຸງຄ່າໃຊ້ຈ່າຍໄຟຟ້າ ModExp ( ). fork ຍັງປັບປຸງການຜະລິດ block ກັບ propositor deterministic lookahead ( ) ແລະປົກປັກຮັກສາຄ່າໃຊ້ຈ່າຍ blob ສະຖຽນລະພາບກັບຄ່າໃຊ້ຈ່າຍການປະຕິບັດ ( ). ການປັບປຸງເພີ່ມເຕີມປະກອບດ້ວຍການປັບປຸງຂະຫນາດ block ໃນ format RLP ( ), adding a new CLZ opcode ສໍາລັບການປະຕິບັດ bit ທີ່ດີທີ່ສຸດ ( ), and introducing a secp256r1 precompile ( ) ສໍາລັບການເຊື່ອມຕໍ່ທີ່ດີກວ່າກັບການເຂົ້າລະຫັດສະດວກແລະຄຸນນະສົມບັດຄວາມປອດໄພອຸປະກອນ. EIP-7594 EIP-7823 EIP-7825 EIP-7883 EIP-7917 EIP-7918 EIP-7934 EIP-7939 EIP-7951 ເຊັ່ນດຽວກັນກັບ Pectra ການເຊື່ອມຕໍ່ "Prague" ແລະ "Electra", Fusaka ແມ່ນຊື່ການເຊື່ອມຕໍ່ຂອງ ແລະ ມັນເປັນປະໂຫຍດທີ່ຜ່ານມາຂອງ Ethereum ກັບຄວາມເປັນໄປໄດ້ສູງ, ການຄາດຄະເນດິນດີຕ້ອນຮັບ, ໃນຂະນະທີ່ rollups Layer 2 ສາມາດເຮັດວຽກຢ່າງງ່າຍດາຍແລະໄວ. Fulu (execution layer) Osaka (consensus layer) ໃນເວັບໄຊນີ້, ພວກເຮົາມີຄວາມຊ່ຽວຊານທີ່ສໍາຄັນຂອງ hard fork Fusaka, ສະແດງໃຫ້ເຫັນວິທີການເຮັດວຽກ PeerDAS ໃນປັດຈຸບັນ, ແລະເບິ່ງຄວາມຕ້ອງການເຄືອຂ່າຍທີ່ແທ້ຈິງສໍາລັບ stakers ຫນ້າທໍາອິດ, supernodes, ແລະ nodes full - ການສະຫນັບສະຫນູນໂດຍ data devnet. Key Changes Introduced In Fusaka Hard Fork ການປ່ຽນແປງທີ່ສໍາຄັນໃນ Fusaka Hard Fork : PeerDAS - Peer Data Availability Sampling EIP-7594 ລະຫັດ QR Ethereum needed this proposal because the network wants to provide more data availability for users and especially for rollups. ການອອກແບບ, ທັງຫມົດ nodes still have to download too much blob data just to check that it was actually published. This creates a scaling problem because if all nodes must download everything, network’s bandwidth and hardware requirements go up, and decentralization can suffer. To fix this, Ethereum needs a way for nodes to confirm that data is available without downloading all of it. Data Availability Sampling (DAS) solves this by letting nodes check only small random pieces of the data. But Ethereum also needs a DAS method that fits well with the existing gossip network and doesn’t add heavy computation to block producers. PeerDAS ໄດ້ຖືກສ້າງຂຶ້ນເພື່ອສະຫນອງຄວາມຕ້ອງການນີ້ແລະປອດໄພເພີ່ມ blobput through while keeping nodes requirements low. EIP-4844 PeerDAS ເປັນລະບົບການເຄືອຂ່າຍທີ່ອະນຸຍາດໃຫ້ nodes ດາວໂຫລດພຽງແຕ່ແຜ່ນຂະຫນາດນ້ອຍຂອງຂໍ້ມູນ blob ເພື່ອກວດສອບວ່າຂໍ້ມູນທັງຫມົດໄດ້ຖືກດາວໂຫລດໄດ້. ໃນຂະນະທີ່ການດາວໂຫລດທັງຫມົດ, nodes ໄດ້ນໍາໃຊ້ເຄືອຂ່າຍການດາວໂຫລດປົກກະຕິເພື່ອບັນລຸຂໍ້ມູນ, ດາວນ໌ໂຫລດຜູ້ຊ່ຽວຊານທີ່ມີສ່ວນຫນຶ່ງ, ແລະຊອກຫາພຽງແຕ່ຕົວຢ່າງຂະຫນາດນ້ອຍທີ່ພວກເຂົາຕ້ອງການ. ຄວາມຄິດສ້າງສັນຕົ້ນຕໍແມ່ນວ່າໂດຍດາວໂຫລດພຽງແຕ່ແຜ່ນຂະຫນາດນ້ອຍ, ແຜ່ນຂະຫນາດນ້ອຍຂອງ blob, nodes ສາມາດຍັງຮັບປະກັນວ່າ blob ທັງຫມົດແມ່ນມີ. ໂດຍສະເພາະ, ໃນຂະນະທີ່ການດາວໂຫລດ 256 KB blob ຂະຫນາດໃຫຍ່, ສໍາລັບການເຮັດວຽກ sampling, PeerDAS ສະຫນັບສະຫນູນແຕ່ລະ blob ຈາກ ການນໍາໃຊ້ປະເພດຕົ້ນຕໍຂອງ coding erasure. —similar to how you can complete a puzzle even if a few pieces are lost. The blob becomes a “row” that contains the original data plus some extra coded data that allows it to be rebuilt later. This row is then split into many small pieces called cells, which are the smallest verified units tied to a KZG commitment. All rows are then reorganized into “columns,” where each column contains the cell at the same position from every row. Each column is assigned to a specific gossip subnet. Nodes are responsible for storing certain columns based on their node ID and for sampling a few columns from peers every slot. If a node collects at least 50% of all columns, it can fully rebuild the data. If it has less than 50%, it simply requests the missing columns from peers. This ensures that if the data was actually published, it can always be reconstructed. In short, if there are 64 columns in total, a node only needs about 32 of them to rebuild the full blob. It keeps some columns itself and downloads a few from peers. As long as half the columns exist in the network, the node can reconstruct everything—even if some columns are missing. EIP-4844 Erasure coding is a technique that adds extra redundant data so that the original data can be recovered even if some pieces are missing ນອກເຫນືອໄປຈາກນີ້, EIP ສະແດງໃຫ້ເຫັນຄໍາແນະນໍາທີ່ສໍາຄັນ: ການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງ blob no transaction can contain more than 6 blobs PeerDAS adds something ຊື່ຫຍໍ້ຂອງ ການຢັ້ງຢືນ CELL KZG ສະແດງໃຫ້ເຫັນວ່າການຢັ້ງຢືນ KZG ແມ່ນມີປະສິດທິພາບຫຼາຍທີ່ສຸດ ສໍາ ລັບໂທລະສັບມືຖືຂອງ blob. This allows a node to download only the cells it wants to sample, instead of the full blob, while still guaranteeing data integrity. This is essential for data availability sampling. cell KZG proofs But generating all these cell proofs is expensive. A block producer would need to compute them again and again for many blobs, which is too slow. Proof verification, however, is very cheap. So the EIP requires ການຜະລິດທັງຫມົດຂອງ proofs cell ໃນເວລາທີ່ຜ່ານມາແລະລວມເອົາພວກເຂົາໃນ wrapper transaction. the blob transaction sender ເນື່ອງຈາກວ່ານີ້, transaction gossip (PooledTransactions) ໃນປັດຈຸບັນນໍາໃຊ້ wrapper ອັດຕະໂນມັດ: rlp([tx_payload_body, wrapper_version, blobs, commitments, cell_proofs]) ໃນປັດຈຸບັນໃນ Wrapper ໃຫມ່ ແມ່ນພຽງແຕ່ບັນຊີລາຍລະອຽດທີ່ມີປະໂຫຍດທັງຫມົດສໍາລັບແຕ່ລະແຜ່ນຂອງແຕ່ລະ blob (ລັກສະນະ: ) ພື້ນທີ່ອື່ນໆ - ຂໍຂອບໃຈ , and — ແມ່ນປະສິດທິພາບທີ່ແທ້ຈິງເຊັ່ນດຽວກັນກັບພວກເຂົາໃນ EIP-4844. ລະບົບທີ່ແຕກຕ່າງກັນແມ່ນວ່າຊັ້ນຫນຶ່ງ "proofs" ອາຍຸໄດ້ຖືກຫຼຸດຜ່ອນແລະປ່ຽນແປງກັບໃຫມ່ນີ້ ຊື່ຫຍໍ້ຂອງ : A new field called is added to show which wrapper format is being used. cell_proofs [cell_proof_0, cell_proof_1, ...] tx_payload_body blobs commitments cell_proofs wrapper_version ການ ນີ້ແມ່ນຫນຶ່ງ byte, ແລະໃນຄໍາຮ້ອງສະຫມັກນີ້ມັນແມ່ນປົກກະຕິ ປະເພດ ລະຫັດ QR ທີ່ຖືກເຂົ້າລະຫັດໂດຍບໍ່ມີການເຂົ້າລະຫັດ QR ໂດຍບໍ່ມີການເຂົ້າລະຫັດ QR ໂດຍບໍ່ມີການເຂົ້າລະຫັດ QR ໂດຍບໍ່ມີການເຂົ້າລະຫັດ QR ໂດຍບໍ່ມີການເຂົ້າລະຫັດ QR ການຢັ້ງຢືນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແ wrapper_version 1 cell_proofs CELLS_PER_EXT_BLOB ວິທີການເພີ່ມເຕີມ ແມ່ນການຢັ້ງຢືນສໍາລັບ j-cell ຂອງ blob i-th ຫຼັງຈາກການເຮັດວຽກ , which produces both the original and extension cells. cell_proofs[i * CELLS_PER_EXT_BLOB + j] compute_cells(blobs[i]) ຖ້າຫາກວ່າທ່ານກໍາລັງຊອກຫາຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບເວັບໄຊທ໌ຂອງພວກເຮົາ, ກະລຸນາຈອກຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບເວັບໄຊທ໌ນີ້. ການຄົ້ນຄວ້າ ການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນ ). Finally, the node must check that each commitment actually matches the blob and its proofs. To do this, it computes the extension cells locally using , and then verifies all the cell proofs—batch verification is allowed to make this faster. cell_proofs CELLS_PER_EXT_BLOB * number_of_blobs kzg_to_versioned_hash(commitments[i]) == tx_payload_body.blob_versioned_hashes[i] compute_cells ຮູບພາບ ສໍາ ລັບ Imagine a blob is split into ລະຫັດ QR ) blob ອັດຕະໂນມັດມີ , ແລະ node receiving ຈະຄອມພິວເຕີທີ່ບໍ່ມີ ຊື່ຫຍໍ້ຂອງ : The sender must include ປະເພດ . Example 8 cells CELLS_PER_EXT_BLOB = 8 4 cells 4 extension cells all 8 proofs cell_proofs ດັ່ງນັ້ນສໍາລັບ 1 blob, transaction wrapper ມີ: blobs = [blob_0] (ພຽງແຕ່ 4 cells ທີ່ແທ້ຈິງ) commitments = [commitment_0] cell_proofs = [proof_0, proof_1, ..., proof_7] ຖ້າຫາກວ່າທ່ານກໍາລັງຊອກຫາໂທລະສັບມືຖືຂອງທ່ານ, ທ່ານສາມາດຊອກຫາໂທລະສັບມືຖືຂອງທ່ານໂດຍບໍ່ມີການຊອກຫາໂທລະສັບມືຖືຂອງທ່ານ. PeerDAS ສະຫນັບສະຫນູນ Ethereum ການເພີ່ມການຮັບປະກັນຂໍ້ມູນໂດຍບໍ່ມີການເຮັດວຽກ nodes ຫຼາຍ. ໃນມື້ນີ້, nodes ມີພຽງແຕ່ຕ້ອງທົດລອງກ່ຽວກັບ . In the future, this might even go down to , ທີ່ຈະໃຫ້ Ethereum ຂະຫນາດໃຫຍ່ຫຼາຍ. ລະບົບໄດ້ເຮັດວຽກຢ່າງງ່າຍດາຍ, ເນື່ອງຈາກວ່າທຸກ nodes ມີຫຼາຍ peers. ດັ່ງນັ້ນ, ຖ້າຫາກວ່າຫນຶ່ງ peer ບໍ່ໃຫ້ຂໍ້ມູນທີ່ຈໍາເປັນ, node ສາມາດພຽງແຕ່ໃຫ້ peer ອື່ນໆ. ນີ້ສ້າງ redundancy ອື່ນໆແລະປັບປຸງຄວາມປອດໄພ. nodes ສາມາດເລືອກເອົາການເກັບຮັກສາ ຂໍ້ມູນຫຼາຍກ່ວາຄຸນນະສົມບັດ, ເຊິ່ງໃຫ້ຄວາມເຂັ້ມແຂງເພີ່ມເຕີມຂອງເຄືອຂ່າຍ - ເຊັ່ນດຽວກັນກັບບໍ່ມີການປ່ຽນແປງ protocol. 1/8 of the total blob data 1/16 or 1/32 more ການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢືນການຢັ້ງຢືນການຢືນການຢັ້ງຢືນການຢັ້ງຢືນການຢືນການຢັ້ງຢືນການຢັ້ງຢ ຄູ່ມືການນໍາໃຊ້ ໃນຖານະເປັນບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ ສະແດງໃຫ້ເຫັນວ່າ blob ແມ່ນ 4x4 grid ຂອງແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແຜ່ນແ column sampling Example: ເຮັດວຽກຢ່າງເຕັມສ່ວນກັບ ການທົດສອບທັງຫມົດແລະຄໍາຮ້ອງສະຫມັກຂະຫນາດໃຫຍ່ແມ່ນຢູ່ໃນຄໍາຮ້ອງສະຫມັກຂອງ consensus ແລະ execution. EIP-7594 EIP-4844 PeerDAS ປິ່ນປົວຄວາມປອດໄພຕົ້ນຕໍໃນລະບົບ DAS ທັງຫມົດແມ່ນ "ການປອດໄພຂອງຂໍ້ມູນ" ໃນຂະນະທີ່ຜູ້ຜະລິດ block ໄດ້ສະແດງໃຫ້ເຫັນວ່າຂໍ້ມູນແມ່ນສາມາດເຂົ້າເຖິງແມ່ນວ່າພວກເຂົາເຈົ້າບໍ່ສາມາດເຂົ້າເຖິງແມ່ນວ່າພວກເຂົາເຈົ້າບໍ່ສາມາດເຂົ້າເຖິງ. PeerDAS ປິ່ນປົວຄວາມປອດໄພຂອງມັນໂດຍໃຊ້ການປະມວນຜົນປະໂຫຍດ: nodes ດໍາ ເນີນການກວດສອບພາກສ່ວນຂອງຂໍ້ມູນທີ່ໄດ້ຮັບການປະມວນຜົນ. ຫຼາຍ nodes ທີ່ໄດ້ຮັບການປະມວນຜົນ, ຫຼາຍກວ້າງຂວາງມັນເປັນສໍາລັບຜູ້ປອດໄພເພື່ອຊອກຫາ. EIP ເຖິງແມ່ນວ່າຍັງສະຫນອງການປະມວນຜົນເພື່ອຄາດຄະເນການປະມວນຜົນປະມວນຜົນປະໂຫຍດທີ່ສາມາດໄດ້ຮັບການປະມວນຜົນປະໂຫຍດ, ໃນຖານະເປັນຈໍານວນທັງຫມົດຂອງ nodes ( ຮູບພາບ ສໍາ ລັບ PeerDAS: The table shows that the chances of a successful attack drop to a negligible level, which is why PeerDAS is considered secure against data-keeping attacks. . ພາສາລາວ : Set upper bounds for MODEXP EIP-7823 ລະຫັດ QR ການຄາດຄະເນດິນຟ້າອິນເຕີເນັດ (MODEXP) ແມ່ນການຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອິນເຕີເນັດທີ່ຄາດຄະເນດິນຟ້າອ EIP-7823 ສະແດງໃຫ້ເຫັນການປົກກະຕິຢ່າງງ່າຍດາຍ: ທັງຫມົດສາມ fields length ທີ່ຖືກນໍາໃຊ້ໂດຍ MODEXP - ຂະຫນາດຂອງ BASE, EXPONENT, ແລະ MODULUS - must be , ທີ່ແມ່ນ 1024 bytes. INPUTS MODEXP ຄົ້ນຫາຮູບແບບ ໃນຂະນະທີ່ໄດ້ຖືກຄັດເລືອກໃນ , so this EIP only restricts the length values. If any length exceeds 1024 bytes, the precompile immediately stops, returns an error, and burns all gas. For example, if someone tries to provide a BASE that is 2000 bytes long, the call will fail before any work happens. These limits still support all real use cases. RSA verification typically uses key sizes like 1024, 2048, or 4096 bits, all well within the new limit. Elliptic curve operations use even smaller sizes, often under 384 bits, so they are also unaffected. 8192 bits or less <len(BASE)> <len(EXPONENT)> <len(MODULUS)> <BASE> <EXPONENT> <MODULUS> EIP-198 ຖ້າຫາກວ່າ MODEXP ແມ່ນ rewritten ໃນລະຫັດ EVM ໂດຍໃຊ້ EVMMAX, ຜູ້ພັດທະນາສາມາດເພີ່ມເສັ້ນທາງທີ່ດີເລີດສໍາລັບຂະຫນາດການເຂົ້າລະຫັດປົກກະຕິເຊັ່ນ 256 ບິດ, 381 ບິດ, ຫຼື 2048 ບິດ, ແລະນໍາໃຊ້ການປັບປຸງຢ່າງງ່າຍດາຍສໍາລັບກໍລະນີທີ່ນິຍົມຫຼາຍ. ມີຂະຫນາດໃຫຍ່ທີ່ຍິ່ງໃຫຍ່ fixed, ຜູ້ພັດທະນາສາມາດເພີ່ມການປິ່ນປົວສ່ວນບຸກຄົນສໍາລັບຂະຫນາດຂະຫນາດຂອງ module ທີ່ປົກກະຕິຫຼາຍ. ບໍ່ມີສິ່ງທີ່ໄດ້ເຮັດໄດ້ຢ່າງງ່າຍດາຍທີ່ຜ່ານມາ, ໃນຂະນະທີ່ຂະຫນາດການເຂົ້າລະຫັດບໍ່ຈໍາກັດໄດ້ເຮັດໃຫ້ສະຖານທີ່ການອອກແບບຂະຫນາດໃຫຍ່ຫຼາຍເພື່ອປິ່ນປົວຄວາມປອດໄພ. ເພື່ອຮັບປະກັນວ່າການປ່ຽນແປງນີ້ຈະບໍ່ຕັດສິນໃຈກັບການປະຕິບັດທີ່ຜ່ານມາ, ຜູ້ຂຽນໄດ້ກວດສອບການນໍາໃຊ້ທັງຫມົດຂອງ MODEXP ຈາກ block 5,472,266 (20 ເມສາ 2018) ເພື່ອຕັດສິນໃຈ 21,550,926 (4 ມັງກອນ 2025). ຜົນໄດ້ຮັບສະແດງໃຫ້ເຫັນວ່າບໍ່ມີໂທລະສັບມືຖື MODEXP ທີ່ດີເລີດໄດ້ນໍາໃຊ້ input ຫຼາຍກ່ວາ ຂ້າພະເຈົ້າສືບຕໍ່ໄດ້ຮັບການປະທັບໃຈກໍໂດຍການບໍລິການລູກຄ້າຂອງພວກເຮົາສໍາລັບການບໍລິການລູກຄ້າຂອງພວກເຮົາ. ພວກເຮົາ ກໍາ ລັງເຮັດທຸລະກິດໃນ 2012. ພວກເຮົາແມ່ນບໍລິສັດທີ່ໃຫຍ່ທີ່ສຸດ ສໍາ ລັບຜູ້ໃຫ້ບໍລິການຂອງພວກເຮົາ. ພວກເຮົາແມ່ນບໍລິສັດທີ່ໃຫຍ່ທີ່ສຸດ ສໍາ ລັບຜູ້ໃຫ້ບໍລິການຂອງພວກເຮົາ. 513 bytes 0x9e5faafc ໃນຖານະເປັນຄວາມປອດໄພ, ການຫຼຸດຜ່ອນຂະຫນາດການເຂົ້າລະຫັດທີ່ຖືກຕ້ອງບໍ່ສ້າງຄວາມປອດໄພໃຫມ່. ໃນປັດຈຸບັນ, ມັນໄດ້ຫຼຸດຜ່ອນກໍລະນີທີ່ບໍ່ຈໍາເປັນທີ່ບໍ່ຈໍາເປັນທີ່ຄ້າຍຄືກັນທີ່ບໍ່ຈໍາເປັນທີ່ເຮັດໃຫ້ bugs ແລະຄວາມບໍ່ຈໍາກັດໃນໄລຍະລູກຄ້າ. ໂດຍກວດສອບການເຂົ້າລະຫັດ MODEXP ກັບຂະຫນາດທີ່ແທ້ຈິງ, ນີ້ EIP ເຮັດໃຫ້ລະບົບສາມາດຄາດຄະເນດິນດີເລີດຫຼາຍ, ການຫຼຸດຜ່ອນກໍລະນີທີ່ບໍ່ຈໍາກັດ, ແລະຫຼຸດຜ່ອນຄວາມອາດສາມາດຂອງຄວາມປອດໄພລະຫວ່າງການປະຕິບັດທີ່ແຕກຕ່າງກັນ. ຄວາມປອດໄພເຫຼົ່ານີ້ຍັງຊ່ວຍໃຫ້ລະບົບໄດ້ຮັບການປັບປຸງຢ່າງງ່າຍດາຍ, ຖ້າຫາກວ່າການປັບປຸງທີ່ຜ່ານມາເຊັ່ນ EVMMA : Transaction Gas Limit Cap EIP-7825 ລະຫັດ QR Ethereum needed this proposal because today a single transaction can use almost the entire block gas limit. This creates several problems: one transaction could consume most of the block’s resources and cause a DoS-style slowdown, large gas-heavy operations can increase Ethereum’s state too quickly, and block validation becomes slower and harder for nodes to keep up with. If one user submits a huge transaction that uses nearly all the gas (for example, a transaction that consumes 38 million gas in a 40 million–gas block), then other normal transactions cannot fit into the block, and every node must spend extra time verifying that block. This threatens network stability and decentralization because slower verification means weaker nodes fall behind. To solve this, Ethereum needs a safe upper limit on how much gas a single transaction can use, so block load becomes more predictable, DoS risk is reduced, and nodes have a more even workload. EIP-7825 ສະແດງໃຫ້ເຫັນວ່າການຂົນສົ່ງບໍ່ສາມາດນໍາໃຊ້ຫຼາຍກ່ວາ . ນີ້ຈະເປັນການກັ່ນຕອງໃນລະດັບ protocol, ເຊິ່ງເປັນການນໍາໃຊ້ໃນທົ່ວໂລກ: ໃນເວລາທີ່ຜູ້ໃຊ້ໄດ້ຂຽນການຄ້າ, ໃນເວລາທີ່ txpool ໄດ້ຮັບການຄວບຄຸມມັນ, ແລະໃນເວລາທີ່ຜູ້ຮັບປະກັນໄດ້ນໍາໃຊ້ມັນໃນ block. If someone sends a transaction with a gasLimit higher than this number, the client must reject it immediately with an error such as: . This cap is completely independent of the block gas limit. For example, even if the block gas limit is 40 million, no single transaction is allowed to use above 16.7 million gas. The goal is to make sure that many transactions can fit inside each block instead of letting one transaction dominate the entire block. 16,777,216 gas (2²⁴) Max_GAS_LIMIT_EXCEED MAX_GAS_LIMIT_EXCEEDED ຖ້າຫາກວ່າທ່ານກໍາລັງຊອກຫາຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບການບໍລິການຂອງພວກເຮົາ, ຖ້າຫາກວ່າທ່ານກໍາລັງຊອກຫາຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບການບໍລິການຂອງພວກເຮົາ, ຖ້າຫາກວ່າທ່ານກໍາລັງຊອກຫາຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບການບໍລິການຂອງພວກເຮົາ, ຖ້າຫາກວ່າທ່ານກໍາລັງຊອກຫາຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບການບໍລິການຂອງພວກເຮົາ, ຖ້າຫາກວ່າທ່ານກໍາລັງຊອກຫາຂໍ້ມູນເພີ່ມເຕີມ. The proposal also adds specific requirements to how clients validate transactions. The txpool must refuse a transaction if its gasLimit is above 16,777,216, meaning such a transaction never even enters the queue. During block validation, if a block contains a transaction that exceeds the cap, the block itself must be rejected. Internally, client implementations will cap the GAS_LIMIT parameter for all transactions at this value. ປະເພດ ມັນໄດ້ຖືກເລືອກໂດຍສະເພາະວ່າມັນເປັນຄວາມເຂັ້ມແຂງຄວາມເຂັ້ມແຂງຂອງສອງ, ເຮັດໃຫ້ມັນງ່າຍທີ່ຈະປະຕິບັດ, ແລະມັນຍັງມີຂະຫນາດໃຫຍ່ທີ່ສຸດເພື່ອປິ່ນປົວການຂົນສົ່ງໃນໂລກທີ່ແທ້ຈິງ, ເຊັ່ນດຽວກັນກັບການນໍາໃຊ້ທຸລະກິດ smart, ການເຊື່ອມຕໍ່ DeFi ທີ່ສົມບູນແບບ, ຫຼືການໂທຫາທຸລະກິດ multi-step. 16,777,216 (2²⁴) This EIP also maintains compatibility with current gas mechanics. Most users will never notice the change because nearly all existing transactions already consume far less than 16 million gas. Validators and block builders can still create blocks that exceed 16.7 million total gas, as long as each individual transaction respects the new cap. The only transactions affected are extremely large ones that previously attempted to use more than the new limit. Those transactions must now be split into multiple smaller operations—similar to breaking a very large file upload into two smaller ones. This change is technically not backward-compatible for those rare extreme transactions, but the number of users affected is expected to be very small. ໃນຖານະເປັນຄວາມປອດໄພ, ການກັ່ນຕອງອາຍແກັສເຮັດໃຫ້ Ethereum ມີຄວາມປອດໄພຫຼາຍກັບການກັ່ນຕອງ DoS ໂດຍອາຍແກັສ, ເນື່ອງຈາກວ່າຜູ້ປອດໄພບໍ່ສາມາດດໍາເນີນການ validators ເພື່ອປິ່ນປົວການຂົນສົ່ງຂະຫນາດໃຫຍ່ຫຼາຍກວ່າ. ມັນຍັງຊ່ວຍໃຫ້ການກັ່ນຕອງເວລາການກັ່ນຕອງ block ທີ່ຖືກຄັດເລືອກເພື່ອໃຫ້ nodes ສາມາດຕິດຕໍ່ຢ່າງງ່າຍດາຍຫຼາຍ. ປະຫວັດສາດຕົ້ນຕໍແມ່ນວ່າການຕິດຕັ້ງບັນລຸ້ນຂະຫນາດໃຫຍ່ຫຼາຍອາດຈະບໍ່ເຂົ້າໄປພາຍໃຕ້ການກັ່ນຕອງແລະສາມາດໄດ້ຮັບການອອກແບບໃຫມ່ຫຼືແຜ່ນການຕິດຕັ້ງຫຼາຍ. ໂດຍທົ່ວໄປ, EIP-7825 ໄດ້ຖືກອອກແບບມາເພື່ອຄວາມເຂັ້ມແຂງຂອງເຄືອຂ່າຍກັບການຫຸ້ມຫໍ່, ເຮັດໃຫ້ຄວາມຕ້ອງການຂອງ nodes ທີ່ຖືກຕ້ອງ, ການປັບປຸງຄວາມເຫມາະສົມໃນການນໍາໃຊ້ສະຖານທີ່ block, ແລະຮັບປະກັນຊຸດແມ່ນຍໍາແລະ stabilized ໃນຂະນະທີ່ຄວາມກົດດັນອາຍແກັສໄດ້ເພີ່ມຂຶ້ນໃນໄລຍະເວລາ. : ModExp Gas Cost Increase EIP-7883 ລະຫັດ QR ຂໍຂອບໃຈທີ່ Ethereum ຕ້ອງການສະເຫນີນີ້ແມ່ນວ່າ Precompile ModExp (ການນໍາໃຊ້ສໍາລັບ exponentiation modular) ໄດ້ຖືກນໍາໃຊ້ ການປະຕິບັດ ModExp ມີຄວາມຕ້ອງການຫຼາຍກວ່າການຄອມພິວເຕີທີ່ຜູ້ໃຊ້ກໍາລັງຊອກຫາໃນປັດຈຸບັນ. ການຄອມພິວເຕີທີ່ແຕກຕ່າງກັນນີ້ສ້າງຄວາມປອດໄພ: ຖ້າຫາກວ່າການໂທລະສັບ ModExp ທີ່ມີຄຸນນະສົມບັດທີ່ແຕກຕ່າງກັນບໍ່ມີຄ່າໃຊ້ຈ່າຍຫຼາຍ, ພວກເຮົາສາມາດສ້າງຄວາມປອດໄພ ຫຼັງຈາກນັ້ນ, Ethereum ຕ້ອງການທີ່ຈະປັບປຸງຮູບເງົາການຊໍາລະເງິນ ModExp ເພື່ອເຮັດໃຫ້ອາຍແກັສທີ່ຖືກນໍາໃຊ້ຢ່າງງ່າຍດາຍກ່ວາການເຮັດວຽກທີ່ແທ້ຈິງຂອງລູກຄ້າ. ມັນເປັນສິ່ງທີ່ EIP-7883 ໄດ້ນໍາສະເຫນີຄໍາຮ້ອງສະຫມັກໃຫມ່ທີ່ເພີ່ມຄ່າໃຊ້ຈ່າຍຕ່ໍາສຸດ, ເຮັດໃຫ້ຄ່າໃຊ້ຈ່າຍທົ່ວໄປ, ແລະເຮັດໃຫ້ການເຮັດວຽກທີ່ມີ input ຂະຫນາດໃຫຍ່ (ລວມທັງ exponents, base, ຫຼື module ຫຼາຍກ່ວາ 32 bytes) ມີຄ່າໃຊ້ຈ່າຍເພີ່ມເຕີມ, ດັ່ງນັ້ນການຊໍາລະເງິນອາຍແກັສແມ່ນມີຄຸນນະສົມບັດທີ່ຕ້ອງການ. underpriced bottleneck This proposal modifies the ModExp pricing algorithm originally defined in EIP-2565 by increasing the cost in several important ways. First, the is raised from 200 to 500, and the general formula no longer divides by 3, meaning the total cost effectively becomes . For example, if a ModExp call previously cost 1,200 gas, it will now cost around 3,600 gas under the new formula. Second, the cost of operations with ໃນຖານະເປັນເອກະສານທີ່ກ່ຽວຂ້ອງກັບການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວຂອງການປິ່ນປົວ. ໃນປັດຈຸບັນ EIP-7883 ໄດ້ນໍາໃຊ້ , ເຮັດໃຫ້ມັນເປັນປະໂຫຍດຫຼາຍກ່ວາສອງ. Third, pricing now assumes a ລະບົບການຄອມພິວເຕີທີ່ແຕກຕ່າງກັນແມ່ນການຄອມພິວເຕີທີ່ແຕກຕ່າງກັນໂດຍໃຊ້ການຄອມພິວເຕີທີ່ແຕກຕ່າງກັນໂດຍໃຊ້ການຄອມພິວເຕີທີ່ແຕກຕ່າງກັນ ( ) instead of the old simpler formula, reflecting the real cost of large-number arithmetic. Together, these changes ensure that small ModExp operations pay a fair minimum fee and large, heavy operations scale their cost properly with size. minimum gas cost three times higher exponents larger than 32 bytes 8 × (40 − 32) = 64 16 × (40 − 32) = 128 minimum base/modulus size of 32 bytes 2 × words² ການຄາດຄະເນດິນດີຕ້ອນຮັບຂອງພວກເຮົາແມ່ນການຄາດຄະເນດິນດີຕ້ອນຮັບຂອງພວກເຮົາ. ການຄາດຄະເນດິນດີຕ້ອນຮັບແມ່ນການຄາດຄະເນດິນດີຕ້ອນຮັບຂອງພວກເຮົາ. ໃນຖານະເປັນບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມໃຫ້ບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອົບຮົມບຸກຄົນ, ບໍລິສັດທີ່ໃຫ້ການຝຶກອ 2 × words² ການຊ່ວຍເຫຼືອຫຼັງຈາກການເພີ່ມຄ່າໃຊ້ຈ່າຍນີ້ໄດ້ຖືກນໍາໃຊ້ໂດຍ benchmarks ທີ່ສະແດງໃຫ້ເຫັນວ່າໃນຫຼາຍສະຖານທີ່ precompile ຂອງ ModExp ໄດ້ຖືກຂັບເຄື່ອນໄຫວຢ່າງກວ້າງຂວາງ. ຮູບເງົາການປັບປຸງເພີ່ມການປະຕິບັດຂະຫນາດນ້ອຍໂດຍ ປະເພດຂອງການເຮັດວຽກທີ່ຜ່ານມາ , and very large or unbalanced operations by much larger factors—sometimes more than ການຝຶກອົບຮົມການຝຶກອົບຮົມການຝຶກອົບຮົມການຝຶກອົບຮົມການຝຶກອົບຮົມການຝຶກອົບຮົມການຝຶກອົບຮົມການຝຶກອົບຮົມ , ແຕ່ repricing ອາຍແກັສໄດ້ເລີ່ມຕົ້ນຫຼາຍກ່ວາໃນ Ethereum ແລະໄດ້ຖືກຮູ້ຈັກຢ່າງງ່າຍດາຍ. 150% 200% 80× backward-incompatible ຜົນປະໂຫຍດການທົດສອບສະແດງໃຫ້ເຫັນວ່າການຂະຫຍາຍຕົວສາມາດເປັນສິ່ງທີ່ສໍາຄັນ. ກ່ຽວກັບ will now cost either 500 gas (up from 200) or three times their earlier price. But certain heavy test cases see huge increases. For example, in one “exp-heavy” test, the cost jumps from 215 gas to 16,624 gas—about ໃນກໍລະນີທີ່ແຕກຕ່າງກັນທີ່ກ່ຽວຂ້ອງກັບການເຮັດວຽກພື້ນຖານ, ຄ່າໃຊ້ຈ່າຍແມ່ນຈາກ 1,026 ກັບ 94,448 ອາຍແກັສ, ເຊິ່ງອະນຸຍາດໃຫ້ວິທີການ multiplication ປະລິມານຂະຫນາດໃຫຍ່ແມ່ນໄດ້ຢ່າງວ່ອງໄວ. ຜະລິດຕະພັນນີ້ສະແດງໃຫ້ເຫັນວ່າຄຸນນະສົມບັດຄຸນນະສົມບັດຄຸນນະສົມບັດທີ່ຜ່ານມາບໍ່ແມ່ນ realistic ແລະຄຸນນະສົມບັດໃຫມ່ແມ່ນຄຸນນະສົມບັດທີ່ດີທີ່ສຸດສໍາລັບສະຖານທີ່ຄຸນສົມບັດ. 99.69% of historical ModExp calls 76× more ໃນຖານະເປັນຄວາມປອດໄພ, ຄໍາຮ້ອງສະຫມັກນີ້ບໍ່ສ້າງ vectors attack ໃຫມ່ຫຼືເຮັດໃຫ້ການເຮັດວຽກໃດໆທີ່ດີກວ່າ. ໃນຂະນະທີ່, ມັນຄົ້ນຄ້ວາກ່ຽວກັບການປ້ອງກັນຄວາມປອດໄພທີ່ສໍາຄັນ: ການເຮັດວຽກ ModExp underpriced ສາມາດເຮັດໃຫ້ມັນສາມາດໃຫ້ຜູ້ປອດໄພທີ່ຈະກາຍ block ກັບການຄອມພິວເຕີທີ່ເຂັ້ມແຂງຢ່າງງ່າຍດາຍທີ່ມີຄ່າໃຊ້ຈ່າຍຕ່ໍາທີ່ສຸດ. ຄວາມປອດໄພທີ່ພຽງແຕ່ສາມາດໄດ້ຮັບແມ່ນວ່າການເຮັດວຽກ ModExp ຫນຶ່ງສາມາດໄດ້ຮັບການ overpriced ໃນປັດຈຸບັນ, ແຕ່ການເຮັດວຽກນີ້ຖືກຄາດວ່າເປັນຜົນປະໂຫຍດທີ່ດີທີ່ສຸດຫຼາຍກ່ວາຄວາມປອດໄພໃນປັດຈຸບັນ. ບໍ່ມີການປ່ຽນແປງ interface ຫຼືຄຸນນະສົມບັດໃຫມ່ຖືກນໍາໃຊ້, ດັ່ງນັ້ນການເຮັດວຽກ arithmetic ທີ່ມີແລະ vectors Test Case EIP-2565 Pricing EIP-7883 Pricing Increase modexp_nagydani_1_square 200 500 150% modexp_nagydani_1_qube 200 500 150% modexp_nagydani_1_pow0x10001 341 2048 501% modexp_nagydani_2_square 200 512 156% modexp_nagydani_2_qube 200 512 156% modexp_nagydani_2_pow0x10001 1365 8192 501% modexp_nagydani_3_square 341 2048 501% modexp_nagydani_3_qube 341 2048 501% modexp_nagydani_3_pow0x10001 5461 32768 500% modexp_nagydani_4_square 1365 8192 501% modexp_nagydani_4_qube 1365 8192 501% modexp_nagydani_4_pow0x10001 21845 131072 500% modexp_nagydani_5_square 5461 32768 500% modexp_nagydani_5_qube 5461 32768 500% modexp_nagydani_5_pow0x10001 87381 524288 500% modexp_marius_1_even 2057 45296 2102% modexp_guido_1_even 2298 51136 2125% modexp_guido_2_even 2300 51152 2124% modexp_guido_3_even 5400 32400 500% modexp_guido_4_even 1026 94448 9105% modexp_marcin_1_base_heavy 200 1152 476% modexp_marcin_1_exp_heavy 215 16624 7632% modexp_marcin_1_balanced 200 1200 500% modexp_marcin_2_base_heavy 867 5202 500% modexp_marcin_2_exp_heavy 852 16368 1821% modexp_marcin_2_balanced 996 5978 500% modexp_marcin_3_base_heavy 677 2032 200% modexp_marcin_3_exp_heavy 765 4080 433% modexp_marcin_3_balanced 1360 4080 200% ລະຫັດ QR 200 500 150% ລະຫັດ QR 200 500 ປະມານ 150% modexp_nagydani_1_pow0x10001 341 2048 ປະເພດ: 501% ລະຫັດ QR 200 512 ປະເພດ 156% ລະຫັດ QR 200 512 156% modexp_nagydani_2_pow0x10001 1365 8192 501% modexp_nagydani_3_square 341 2048 ປະເພດ: 501% ລະຫັດ QR 341 2048 501% modexp_nagydani_3_pow0x10001 5461 32768 500% ລະຫັດ QR 1365 8192 ປະເພດ: 501% modexp_nagydani_4_qube 1365 8192 501% modexp_nagydani_4_pow0x10001 21845 131072 ປະເພດ modexp_nagydani_5_square 5461 32768 ປະເພດ modexp_nagydani_5_qube 5461 32768 500% modexp_nagydani_5_pow0x10001 87381 524288 500% ລະຫັດ QR 2057 45296 ອັດຕະໂນມັດ modexp_guido_1_even 2298 51136 2125% modexp_guido_2_even 2300 51152 2124% ລະຫັດ QR 5400 32400 500% modexp_guido_4_even 1026 94448 ລະຫັດ QR modexp_marcin_1_base_heavy 200 1152 476% ລະຫັດ QR 215 16624 ປະເພດ: 7632% ລະຫັດ QR 200 1200 ປະເພດ ປະເພດ Modexp_marcin_2_base_heavy 867 5202 500% modexp_marcin_2_exp_heavy 852 16368 ພາສາລາວ ລະຫັດ QR 996 5978 500% modexp_marcin_3_base_heavy 677 2032 200% modexp_marcin_3_exp_heavy 765 4080 433% ລະຫັດ QR 1360 4080 200% *source: https://eips.ethereum.org/EIPS/eip-7883#test-cases* : Determine proposer lookahead EIP-7917 EIP-7917 Ethereum needed this proposal because the network’s proposer schedule for the next epoch was not fully predictable. Even though the RANDAO seed for epoch is known during epoch , the actual proposer list could still change due to effective balance (EB) updates happening inside epoch . These EB changes can come from slashings, penalties, rewards above 1 ETH, validator consolidations, or new deposits—especially after EIP-7251 raised the maximum effective balance beyond 32 ETH. This uncertainty creates issues for systems that rely on knowing the next proposer in advance, such as based preconfirmation protocols, which need a stable and predictable schedule to operate smoothly. A validator could even try to “grind” or manipulate their effective balance to influence who becomes the proposer next epoch. Because of these problems, Ethereum needed a way to make the proposer schedule fully deterministic several epochs ahead so it cannot be changed by last-minute EB updates and can be easily accessed by the application layer. N+1 N N ສໍາລັບການປະຕິບັດນີ້, EIP ໄດ້ນໍາສະເຫນີຕົວແທນ deterministic lookahead ໂດຍ pre-calculating ແລະເກັບຮັກສາໂຄງການຕົວແທນສໍາລັບທີ່ຜ່ານມາ MIN_SEED_LOOKAHEAD + 1 epochs ໃນຕອນເລີ່ມຕົ້ນຂອງແຕ່ລະ epoch. ໃນເວລາທີ່ Epoch N ໄດ້ເລີ່ມຕົ້ນ, ຊື່ນີ້ຍັງປະກອບມີຜູ້ສະເຫນີສໍາລັບທຸກສະຖານທີ່ໃນ Epoch N ແລະ Epoch N+1. ຫຼັງຈາກນັ້ນ, ໃນເວລາທີ່ເຄືອຂ່າຍຂົນສົ່ງໄປ Epoch N+1, ຊື່ນີ້ຖືກປ່ຽນແປງຕໍ່ໄປ: ການສະຖານທີ່ຜູ້ສະເຫນີສໍາລັບ Epoch N ແມ່ນຫຼຸດຜ່ອນ, ການສະຖານທີ່ສໍາລັບ Epoch N+1 ແມ່ນປ່ຽນແປງຕໍ່ໄປ, ແລະການສະຖານທີ່ຜູ້ສະເຫນີໃຫມ່ສໍາລັບ Epoch N+2 ແມ່ນເພີ່ມຂຶ້ນໃນຕອນທ້າຍ. ນີ້ເຮັດໃຫ້ການສະຖານທີ່ໄດ້ຖືກກໍານົດ, ການຄາດຄະແນນ, ແລະໄດ້ງ່າຍສໍາລັບລູກຄ້າທີ່ຈະອ່ານໂດຍຜ່ານມາ, ໃນຂະນະທີ່ການຄາດຄະແນນຜູ້ສະເຫນີທຸກສະຖານທີ່. proposer_lookahead To keep this updated, the list shifts forward at every epoch boundary: the data for the past epoch is removed, and a new set of proposer indices for the next future epoch is computed and appended. The process uses the same seed and effective balance rules as before, but now the schedule is calculated earlier, removing the possibility of EB changes affecting it after the seed is known. The very first block after the fork also fills this entire lookahead range so that all future epochs have properly initialized schedules. ສະ ຫນັບ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ຂອງ Epoch 5, Ethereum pre-calculates ທັງຫມົດ proposers ສໍາລັບ Epoch 5, 6, ແລະ 7 ແລະເກັບຮັກສາພວກເຂົາໃນລະດັບພາຍໃນ ໃນປັດຈຸບັນ, ເຊັ່ນດຽວກັນກັບການປ່ຽນແປງສະຖາບັນຫຼັງຈາກ Epoch 5, ຊື່ຂອງຜູ້ສະເຫນີສໍາລັບ Epoch 6 ແມ່ນ fixed ແລະ predictable. start proposer_lookahead This EIP fixes a long-standing oversight in the beacon chain design. It guarantees that once the RANDAO from earlier epochs becomes available, the validator selection for future epochs cannot be altered. This also prevents “effective balance grinding,” where a validator tries to adjust their balance after seeing the RANDAO to influence the next epoch’s proposer list. With deterministic lookahead, that entire attack vector is eliminated, making the security analysis much simpler. It also gives consensus clients early visibility into who will propose upcoming blocks, which helps implementations and allows the proposer schedule to be easily verified by the application layer via a Merkle proof from the beacon root. ພວກເຮົາ ກໍາ ລັງເຮັດທຸລະກິດໃນ 2012. ພວກເຮົາ ກໍາ ລັງເຮັດທຸລະກິດໃນ 2012. ພວກເຮົາ ກໍາ ລັງເຮັດທຸລະກິດໃນ 2012. ພວກເຮົາ ກໍາ ລັງເຮັດທຸລະກິດໃນ 2012. ພວກເຮົາ ກໍາ ລັງເຮັດທຸລະກິດໃນ 2012. ພວກເຮົາ ກໍາ ລັງເຮັດທຸລະກິດໃນ 2012. Before this proposal, clients only calculated the proposer for the current slot. With EIP-7917, they now compute the proposer list for all slots in the next epoch at once during every epoch transition. This adds a small amount of work, but computing proposer indices is very light and mainly involves sampling validator lists using the seed. However, clients will need benchmarking to make sure this extra computation does not cause performance issues. This EIP does not change how the RANDAO delay works. The proposer lookahead for epoch ທີ່ຢູ່ ສະ ຫນັບ ສະ ຫນັບ ສະ ຫນັບ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ ສະ ຫນູນ . The only change is that effective balances are now aligned with the same delay, so validators cannot modify their EB after seeing the RANDAO result. This removes a potential manipulation strategy, even though no attack had been discovered yet. The deterministic lookahead therefore, strengthens security and prevents malicious alteration of proposer schedules. N N − MIN_SEED_LOOKAHEAD − 1 : Blob base fee bounded by execution cost EIP-7918 EIP-7918 Ethereum needs this proposal because the current blob fee system (from ) breaks down when execution gas becomes the main cost for rollups. Right now, most rollups pay much more for execution gas (the cost of including their blob transaction in the block) than they pay for the actual blob fee. This creates a problem: even if Ethereum keeps lowering the blob base fee again and again, the rollup’s total cost does not really change, because the expensive part is still the execution gas. Because of this, the blob base fee keeps falling until it reaches the absolute minimum (1 wei), and the protocol can no longer use the blob fee to control demand. Then, when blob usage suddenly goes up, the blob fee needs many blocks to climb back to a normal level. This makes prices unstable and unpredictable for users. EIP-4844 For example, imagine a rollup wants to post its data: it pays about 25,000,000 gwei in execution gas (25 gwei per gas for roughly 1,000,000 gas), while the blob fee is only around 200 gwei. This means the total cost is roughly 25,000,200 gwei, where almost the entire cost comes from execution gas, not the blob fee. If Ethereum keeps lowering the blob fee—say from 200 gwei to 50 gwei, then to 10 gwei, and eventually down to 1 wei—the total cost barely changes at all, staying almost exactly 25,000,000 gwei. Because users don’t feel any difference, they don’t change their behavior, so the protocol keeps pushing blob fees down until they hit the minimum possible value. Then, when blob demand suddenly increases again, the blob base fee has to climb all the way up from 1 wei, causing sharp, unpredictable fee spikes. fixes this by introducing a minimum “reserve price” for blob fees that depends on the execution base fee, preventing blob prices from falling unrealistically low and keeping blob pricing much more stable and predictable for rollups. ລະຫັດ QR The core idea of EIP-7918 is simple: the price of a blob should never be cheaper than the cost of a certain amount of execution gas (called ). In the EIP, this constant is set to ເຄື່ອງມືເຮັດວຽກໂດຍຜ່ານການປ່ຽນແປງຂະຫນາດນ້ອຍໃນ function. Usually, this function increases or decreases the blob base fee depending on whether blocks are using more or less blob gas than the target. With this proposal, if a blob becomes “too cheap” compared to execution gas, the function stops subtracting the target blob gas. This makes the excess blob gas grow faster, which prevents the blob base fee from falling further. As a result, the blob base fee now has a minimum value equal to . BLOB_BASE_COST 2¹³ calc_excess_blob_gas() BLOB_BASE_COST × base_fee_per_gas ÷ GAS_PER_BLOB To understand why this is needed, it helps to look at blob demand. A rollup cares about the total price it pays: execution cost plus blob cost. If execution gas fee is very high—for example, 20 gwei—then even if the blob fee drops from 2 gwei to 0.2 gwei, the total cost barely changes. This means reducing the blob base fee has almost no impact on demand. In economics, this is called “ .” ມັນສ້າງສະຖານທີ່ໃນເວລາທີ່ຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບຂອງຄຸນນະພາບ fee inelasticity ວິທີການອື່ນໆສໍາລັບການເພີ່ມຄ່າໃຊ້ຈ່າຍການຂົນສົ່ງນີ້ແມ່ນວ່າ nodes ຕ້ອງການເຮັດວຽກເພີ່ມເຕີມຫຼາຍເພື່ອຢັ້ງຢືນ KZG ສໍາລັບຂໍ້ມູນ blob. ການຢັ້ງຢືນເຫຼົ່ານີ້ແມ່ນສິ່ງທີ່ຮັບປະກັນວ່າຂໍ້ມູນໃນ blob ແມ່ນປະສິດທິພາບກັບຄວາມຕ້ອງການຂອງຕົນ. , a node only had to verify one proof per blob, which was cheap. But with (PeerDAS), blobs are broken into many small pieces called cells, and every cell has its own proof. This makes verification much heavier. For example, the execution layer now has to batch-verify 128 proofs for every single blob before a transaction can even enter the mempool—this is about fifteen times more expensive than the normal KZG proof verification that smart contracts pay for. On top of that, full nodes, supernodes, and validators must verify even more proofs depending on how many columns they store or sample. A typical full node must verify proofs for all blobs in the mempool, plus eight sampled columns every slot, plus four columns it permanently custodies. All of this uses real CPU time, and it isn’t free for node operators. If blob fees drop too low, users would get this expensive compute work from the network essentially for free. By linking the blob reserve price to execution gas fees, EIP-7918 makes sure blob users always pay at least a fair minimum amount for the load they put on nodes. ລະຫັດ QR ລະຫັດ QR In the long run, EIP-7918 also helps prepare Ethereum for the future. As technology improves, the cost of storing and sharing data naturally gets cheaper, and Ethereum is expected to allow more blob data over time. When blob capacity increases, blob fees (in ETH) should naturally go down. This proposal supports that because the reserve price is tied to execution gas prices, not a fixed number, so it can adjust as the network grows. As both blobspace and execution blockspace expand, their price relationship stays balanced. The only time the reserve price might become too high is in a very unlikely future where Ethereum increases blob capacity a lot but does not increase execution gas capacity. In that case, blob fees might end up higher than needed. But Ethereum is not planning to scale in that way—both blobspace and execution blockspace are expected to grow together. Because of this, the chosen value ( ) is considered safe and well-balanced. BLOB_BASE_COST = 2¹³ ໃນເວລາທີ່ຄ່າໃຊ້ຈ່າຍອາຍແກັສການປະຕິບັດໄດ້ເລີ່ມຕົ້ນ, ຄ່າໃຊ້ຈ່າຍອາຍແກັສໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້. ໃນເວລາທີ່ຄ່າໃຊ້ຈ່າຍອາຍແກັສໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້, ຄ່າໃຊ້ຈ່າຍອາຍແກັສໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້. ໃນເວລາທີ່ຄ່າໃຊ້ຈ່າຍອາຍແກັສໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້ເລີ່ມຕົ້ນ. ໃນເວລາທີ່ຄ່າໃຊ້ຈ່າຍອາຍແກັສໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້, ຄ່າໃຊ້ຈ່າຍອາຍແກັສໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້ເລີ່ມຕົ້ນຈາກການປະຕິບັດໄດ້ເລີ່ມຕົ້ນໄປຈາກການປະຕິບັດໄດ້ The authors also performed empirical analysis by applying the reserve price rule to real blob activity from ແລະ . During high-execution-fee periods (around ), the reserve threshold significantly increased the blob base fee compared to the old mechanism. During low-execution-fee periods (around ), the blob fee remained almost unchanged except when the calculated blob base fee dropped below the reserve price. By comparing thousands of blocks, the authors show that the new mechanism creates more stable pricing while still responding naturally to demand. A histogram of four months of blob fees shows that the reserve price prevents blob fees from collapsing toward 1 wei, which reduces extreme volatility. November 2024 March 2025 16 gwei average 1.3 gwei average In terms of security, the change does not introduce any risks. The blob base fee will always settle at or above the cost of ຊຸດຂອງການປະຕິບັດຂອງອາຍແກັສ. ນີ້ແມ່ນຄວາມປອດໄພ, ເນື່ອງຈາກວ່າສະຖາບັນພຽງແຕ່ເພີ່ມຄ່າໃຊ້ຈ່າຍຕ່ໍາ, ແລະການຕັ້ງຄ່າຄວາມປອດໄພຕ່ໍາກ່ຽວກັບການຊື້ຄ່ໍາບໍ່ໄດ້ປິ່ນປົວກັບຄວາມປອດໄພຂອງໂຄງການ. ມັນພຽງແຕ່ປະກັນຄວາມປອດໄພຂອງເສດຖະກິດ. BLOB_BASE_COST : RLP Execution Block Size Limit EIP-7934 EIP-7934 ຫຼັງຈາກ EIP-7934, Ethereum ໄດ້ have a strict upper limit on how large an RLP-encoded execution block could be. In theory, a block could become extremely large if it contained many transactions or very complex data. This created two major problems: ແລະ . If a block was too large, it would take longer for nodes to download and verify it, which slowed block propagation and increased the chance of temporary blockchain forks. Worse, an attacker could deliberately create a very large block to overload nodes, causing delays or even knocking them offline — a classic denial-of-service scenario. At the same time, Ethereum’s consensus layer (CL) gossip protocol already refused to propagate any block over ຂ້າພະເຈົ້າສືບຕໍ່ໄດ້ຮັບການປະທັບໃຈກໍໂດຍການບໍລິການລູກຄ້າຂອງພວກເຮົາ, ຂ້າພະເຈົ້າຫວັງວ່າຈະໄດ້ເຮັດວຽກຮ່ວມກັບທ່ານອີກເທື່ອຫນຶ່ງ! not network instability DoS attack risks 10 MB EIP-7934 solves this by introducing a ຂະຫນາດຂອງ block ທີ່ຖືກເຂົ້າລະຫັດໂດຍ RLP. ຂະຫນາດ block ທີ່ຖືກເຂົ້າລະຫັດໂດຍ RLP ( ) is set to , but because beacon blocks also consume some space ( ), Ethereum ສະຫນອງ A . ນີ້หมายความວ່າຂະຫນາດ block execution ສູງສຸດທີ່ອະນຸຍາດແມ່ນ RLP-coded ຖ້າຫາກວ່າ block coded ແມ່ນຂະຫນາດໃຫຍ່ກວ່າ limits ນີ້, block ໄດ້ຖືກນໍາໃຊ້ ໃນຖານະເປັນວິທີການນີ້, block producers must check the encoded size of each block they build, ແລະ validators must verify this limit during block validation. of gas limits -meaning even if a block is “ ມັນຍັງສາມາດໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບໂດຍບໍ່ໄດ້ຮັບການກວດສອບ. protocol-level cap MAX_BLOCK_SIZE 10 MiB (10,485,760 bytes) SAFETY_MARGIN 2 MiB (2,097,152 bytes) MAX_RLP_BLOCK_SIZE = MAX_BLOCK_SIZE - SAFETY_MARGIN invalid independently under the gas limit, Choosing a was intentional because it matches the existing constraint in the consensus layer gossip protocol. Anything larger than 10 MiB would not be broadcast across the network anyway, so this EIP brings the execution layer into alignment with the consensus layer’s limits. This creates consistency across all components and prevents situations where a valid execution block becomes “invisible” because the CL refuses to gossip it. 10 MiB cap ການປ່ຽນແປງນີ້ແມ່ນ with blocks larger than the new limit, meaning miners and validators must update their clients to respect the rule. However, since oversized blocks were already problematic and not normal in real operation, the impact is minimal. In terms of security, this EIP significantly strengthens Ethereum against targeted block-size DoS attacks by ensuring no participant can create blocks that overwhelm the network. Overall, EIP-7934 adds an important safety boundary, improves stability, aligns EL and CL behavior, and prevents several classes of attacks related to oversized block creation and propagation. not backward-compatible : Count leading zeros (CLZ) opcode EIP-7939 EIP-7939 ຫຼັງຈາກ EIP ນີ້, Ethereum ມີ ການຄາດຄະເນດິນດີຕ້ອນຮັບສໍາລັບການຄາດຄະເນດິນດີຕ້ອນຮັບສໍາລັບການຄາດຄະເນດິນດີຕ້ອນຮັບສໍາລັບການຄາດຄະເນດິນດີຕ້ອນຮັບສໍາລັບການຄາດຄະເນດິນດີຕ້ອນຮັບສໍາລັບການຄາດຄະເນດິນດີຕ້ອນຮັບ , and , which increased gas usage. For zero-knowledge proving systems, the cost was even higher — right-shifts are extremely expensive to prove, so operations like CLZ slowed down ZK circuits significantly. Since CLZ is a very common low-level function used in math libraries, compression algorithms, bitmaps, signature schemes, and many cryptographic or data-processing tasks, Ethereum needed a faster and cheaper way to compute it. no built-in opcode slow, expensive used a lot of bytecode EIP-7939 ເຮັດໃຫ້ການປິ່ນປົວນີ້ໂດຍ introducing a . This opcode takes a 256-bit value from the stack and returns the number of leading zero bits. If the input number is zero, the opcode returns , because a 256-bit zero has 256 leading zero bits. This matches how CLZ works in many CPU architectures like ARM and x86, where this operation is native. Adding CLZ makes many algorithms significantly cheaper: operations like , , , various math functions, byte-string comparisons, bitmap scanning, calldata compression/decompression, and post-quantum signature schemes all benefit from faster leading-zero detection. new opcode called CLZ (0x1e) 256 lnWad powWad LambertW , similar to an , ແລະຂະຫນາດນ້ອຍເພີ່ມຂຶ້ນຈາກຄ່າໃຊ້ຈ່າຍ MUL ທີ່ຜ່ານມາເພື່ອປິ່ນປົວຜົນປະໂຫຍດ opcode ແລະເຮັດໃຫ້ການປະໂຫຍດ DoS. Benchmarks ສະແດງໃຫ້ເຫັນວ່າ CLZ ໃຊ້ປະມານຄວາມເຂັ້ມແຂງຄອມພິວເຕີເຊັ່ນ ADD, ແລະໃນສະພາບແວດລ້ອມການຢັ້ງຢືນ SP1 rv32im, CLZ ແມ່ນຢ່າງວ່ອງໄວ , reducing ZK proving costs. The EIP also explains why they chose CLZ instead of : you can compute CTZ from CLZ using , but you reliably implement CLZ using CTZ, so CLZ is more fundamental. The gas cost for CLZ is set to 5 ADD cheaper to prove than ADD CTZ (count trailing zeros) x & -x cannot This EIP is fully backwards-compatible because it introduces a opcode and does not modify any existing behavior. It also covers edge cases clearly: for example, the opcode returns 256 when the input is zero, and several test cases show inputs like all-zero, top-bit-set, and fully-nonzero values. Since CLZ has predictable and low gas cost, no memory growth, and no state changes, it is safe from denial-of-service issues. new Overall, EIP-7939 makes Ethereum faster, cheaper, and more developer-friendly by adding a simple, efficient primitive that modern CPUs already support — cutting gas, reducing bytecode size, and lowering ZK proving costs for many common operations. : Precompile for secp256r1 Curve Support EIP-7951 EIP-7951 Before this EIP, Ethereum did have a safe, native way to verify digital signatures created using the . This curve is the standard used in modern devices like ເນື່ອງຈາກການສະຫນັບສະຫນູນທີ່ບໍ່ມີນີ້, Apps ແລະ wallets ບໍ່ສາມາດນໍາໃຊ້ຄວາມປອດໄພຂອງອຸປະກອນໃນລະດັບອຸປະກອນໄດ້ຢ່າງງ່າຍດາຍສໍາລັບການລົງທະບຽນ. ມີການທົດສອບທີ່ຜ່ານມາ (RIP-7212), ແຕ່ມັນໄດ້ related to point-at-infinity handling and incorrect signature comparison. These issues could cause incorrect verification or even risk consensus failures. not secp256r1 (P-256) curve Apple Secure Enclave, Android Keystore, HSMs, TEEs, and FIDO2/WebAuthn security keys two serious security vulnerabilities EIP-7951 fixes those security problems and introduces a safe, native precompile so Ethereum can finally support signatures from modern hardware securely and efficiently. EIP-7951 adds a new at address called , which performs ECDSA signature verification using the secp256r1 curve. This makes signature verification fast and cheap compared to implementing the algorithm directly in Solidity. The precompile uses the official curve parameters defined by NIST, including the field modulus, curve equation, base point, and subgroup order, ensuring strong cryptographic security. Points and scalars are encoded in strict 32-byte big-endian format, and a 64-byte all-zero value is used to represent the point at infinity. The precompile expects exactly —hash, signature (r, s) ແລະ coordinates public key (qx, qy) — ແລະມັນ returns for success or for failure. precompiled contract 0x100 P256VERIFY 160 bytes of input 32 bytes of 1 empty output EIP ຍັງຄັດເລືອກຄວາມເຂັ້ມແຂງ ມັນກວດສອບວ່າ r ແລະ s ແມ່ນໃນໄລຍະທີ່ຖືກຕ້ອງ, ທີ່ key public ແມ່ນຢູ່ໃນ curve, ແລະວ່າມັນບໍ່ແມ່ນທັນສະໄຫມໃນ infinity. ຖ້າຫາກວ່າສິ່ງທຸກຢ່າງແມ່ນບໍ່ມີຄຸນນະສົມບັດ, precompile ເຮັດໃຫ້ຄວາມຜິດພາດໂດຍບໍ່ມີການປ່ຽນແປງແລະນໍາໃຊ້ອາຍແກັສທີ່ເຫມາະສົມກັບການໂທທີ່ດີເລີດ. algorithm ການກວດສອບແມ່ນລວມກັບ ECDSA standard: ມັນກວດສອບ s−1 mod n, rebuilds point signing R’, rejects if R’ is infinity, ແລະຫຼັງຈາກນັ້ນກວດສອບວ່າ coordinate x ຂອງ R’ matches r (mod n). ນີ້ກວດສອບຄວາມຜິດພາດໃນ RIP-7212, ເຊິ່ງກວດສອບກັບ r’ ຄຸນນະສົມບັດໂດຍທົ່ວໄປໃນຂະນະທີ່ input validation rules curve secp256r1 ແມ່ນໄດ້ຖືກຄັດເລືອກຢ່າງເຕັມທີ່ໂດຍກຸ່ມຂອງມະນຸດທີ່ຜ່ານມາ: Base field modulus = p = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff Curve equation: y^2 = x^3 + ax + b (mod p) Curve coefficient a = 0xffffffff00000001000000000000000000000000fffffffffffffffffffffffc Curve coefficient b = 0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b Base point G: Gx = 0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296 Gy = 0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5 Subgroup order = n = 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551 Cofactor = h = 0x1 ຄຸນນະສົມບັດເຫຼົ່ານີ້ໄດ້ຖືກມາດຕະຖານໂດຍ NIST ໃນ SP 800-1861. The gas cost for the operation is set to , which is higher than the RIP-7212 version, but matches actual performance benchmarks for secp256r1 verification. Importantly, the interface remains fully compatible with Layer 2 networks that already deployed RIP-7212—same address, same input/output format—so existing smart contracts will continue to work with no changes. The only difference is the corrected behavior and higher gas cost. 6900 gas Input: P256VERIFY call excepts 160 Bytes as input that is interpreted as byte concatenation of: 32 bytes ----> message hash (h) 32 bytes ----> signature component (r) 32 bytes ----> signature component (s) 32 bytes ----> public key x-coordinate (qx) 32 bytes ----> public key y-coordinate (qy) Output: will be 32 bytes on successfull verification and 0 bytes on failure Input Validation: The precompile MUST perform the following validation checks and return `` (failure) if any check fails: 1. Input length: Input MUST be exactly 160 bytes 2. Signature component bounds: Both r and s MUST satisfy 0 < r < n and 0 < s < n 3. Public key bounds: Both qx and qy MUST satisfy 0 ≤ qx < p and 0 ≤ qy < p 4. Point validity: The point (qx, qy) MUST satisfy the curve equation qy^2 ≡ qx^3 + a*qx + b (mod p) 5. Point not at infinity: The point (qx, qy) MUST NOT be the point at infinity (represented as (0, 0)) From a security standpoint, the EIP restores proper ECDSA behavior, eliminates malleability concerns at the precompile level (leaving optional checks to applications), and clarifies that constant-time execution is not required for the precompile. The secp256r1 curve provides 128-bit security and is widely trusted and analyzed, making it safe for Ethereum adoption. ຂໍຂອບໃຈຫຼາຍ ການປິ່ນປົວບັນຫາຄວາມປອດໄພຂອງຄໍາຮ້ອງສະຫມັກທີ່ຜ່ານມາ, ແລະສະຫນອງວິທີທີ່ຮັບປະກັນ, ທີ່ຖືກມາດຕະຖານສໍາລັບການຢັ້ງຢືນໃບຢັ້ງຢືນ P-256 ໃນສະພາບແວດລ້ອມທັງຫມົດ. EIP-7951 is needed to safely bring modern hardware-backed authentication to Ethereum ຮູບພາບ ສໍາ ລັບ ສັດ ລ້ຽງ ສັດ ລ້ຽງ ລ້ຽງ indicates that the EIP requires updates to consensus-layer clients, while a check mark under shows that the change affects execution-layer clients. Some EIPs require updates in both layers, while others are specific to just one. Consensus Client Execution Client EIP Number EIP Name Consensus Client Execution Client EIP-7594 PeerDAS - Peer Data Availability Sampling ✅ ✅ EIP-7823 Set upper bounds for MODEXP ✅ EIP-7825 Transaction Gas Limit Cap ✅ EIP-7883 ModExp Gas Cost Increase ✅ EIP-7917 Deterministic proposer lookahead ✅ EIP-7918 Blob base fee bounded by execution cost ✅ EIP-7934 RLP Execution Block Size Limit ✅ EIP-7939 Count leading zeros (CLZ) opcode ✅ EIP-7951 Precompile for secp256r1 Curve Support ✅ ລະຫັດ QR PeerDAS - Peer Data Availability Sampling ✅ ✅ ລະຫັດ QR ການຕັ້ງຄ່າຜູ້ນໍາຂະຫນາດໃຫຍ່ສໍາລັບ MODEXP ✅ EIP-7825 ການທົດສອບ Gas Limit Cap ✅ EIP-7883 ModExp Gas Cost Increase ✅ ລະຫັດ QR Deterministic proposer lookahead ✅ ລະຫັດ QR ຄ່າໃຊ້ຈ່າຍ Blob Basic Limited by Execution Cost ✅ EIP-7934 RLP Execution Block Size Limit ✅ EIP-7939 ລະຫັດ opcode Count leading zeros (CLZ) ✅ EIP-7951 Precompile for secp256r1 Curve Support ✅ ໃນຂະນະທີ່ການປັບປຸງຫຼາຍກ່ວາລູກຄ້າຂອງ consensus ແລະ execution - ຈາກການປັບປຸງ gas ແລະການປັບປຸງ opcode ກັບ precompiles ໃຫມ່ - ການ , which introduces peer-to-peer data availability sampling, enabling more efficient and decentralized handling of blob data across the network. major change of this upgrade is PeerDAS
