{"id":4158,"date":"2026-10-20T14:24:23","date_gmt":"2026-10-20T14:24:23","guid":{"rendered":"https:\/\/nownodes.io\/blog\/?p=4158"},"modified":"2026-10-20T14:24:24","modified_gmt":"2026-10-20T14:24:24","slug":"what-is-the-diamond-proxy-pattern-eip-2535","status":"publish","type":"post","link":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/","title":{"rendered":"What Is the Diamond Proxy Pattern (EIP-2535)?"},"content":{"rendered":"\n<p class=\"wp-block-paragraph\">A diamond is a single smart contract whose external functions are supplied by several other contracts, called facets. To a wallet, a block explorer, or another contract, it looks like one ordinary contract at one Ethereum address. Behind that address, the diamond forwards each call to the facet that implements it using <code>delegatecall<\/code>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">That design is the core of the diamond proxy pattern, standardized as <a href=\"https:\/\/eips.ethereum.org\/EIPS\/eip-2535\" rel=\"nofollow noopener noreferrer\">EIP-2535<\/a> by Nick Mudge. It solves two problems at once: it lets a contract system grow past Ethereum&#8217;s 24 KB code-size limit, and it lets you upgrade one function at a time instead of redeploying everything.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">EIP-2535 has been a Final Ethereum standard since October 2022, and several production protocols run on it. This guide covers what an Ethereum diamond is, how calls and storage actually work, how upgrades are recorded, and where the pattern&#8217;s real risks sit.<\/p>\n\n\n<h2 class=\"wp-block-heading\" id=\"what-is-an-ethereum-diamond\">What Is an Ethereum Diamond?<\/h2>\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"535\" src=\"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-115-1024x535.png\" alt=\"\" class=\"wp-image-4159\" srcset=\"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-115-1024x535.png 1024w, https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-115-300x157.png 300w, https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-115-768x401.png 768w, https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-115-1536x802.png 1536w, https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-115.png 1735w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">An Ethereum diamond is a proxy contract that routes function calls to multiple logic contracts. The <a href=\"https:\/\/eips.ethereum.org\/EIPS\/eip-2535\" rel=\"nofollow noopener noreferrer\">EIP-2535 specification<\/a> gives three terms worth learning before anything else.<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li>A <strong>diamond<\/strong> is the facade contract. It holds all the state (storage) and delegates execution to its facets.<\/li>\n\n\n\n<li>A <strong>facet<\/strong> is a stateless contract (or deployed Solidity library) that holds external functions. It stores no data of its own but can read and write the diamond&#8217;s storage.<\/li>\n\n\n\n<li>A <strong>loupe facet<\/strong> provides introspection: functions that report which facets and functions a diamond currently has.<\/li>\n<\/ul>\n\n\n\n<p class=\"wp-block-paragraph\">The names come from the gem trade. A facet is a flat cut surface of a diamond, and a loupe is the small magnifying glass a jeweler uses to inspect one. In EIP-2535 you &#8220;cut&#8221; a diamond by adding, replacing, or removing functions, and you use the loupe functions to look inside it.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">One detail matters for everything that follows: a deployed facet is not tied to a single diamond. The same facet can be shared by many diamonds, which keeps deployment costs down and makes common logic reusable.<\/p>\n\n\n<h2 class=\"wp-block-heading\" id=\"why-diamonds-exist-size-limits-and-upgrades\">Why Diamonds Exist: Size Limits and Upgrades<\/h2>\n\n\n<p class=\"wp-block-paragraph\">Two practical problems pushed this pattern into existence: the contract size ceiling and the need to change live code.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Since the Spurious Dragon hard fork in 2016, Ethereum has enforced a maximum contract size of 24,576 bytes \u2014 roughly 24 KB \u2014 under <a href=\"https:\/\/ethereum.org\/en\/developers\/tutorials\/downsizing-contracts-to-fight-the-contract-size-limit\/\" rel=\"nofollow noopener noreferrer\">EIP-170<\/a>. Push a contract past that and it simply won&#8217;t deploy. A diamond sidesteps the limit because its logic lives in separate facets. The diamond itself has no size cap, so a system can hold far more functionality than any single contract could.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The second problem is change. A normal contract is immutable once deployed. Diamond proxies make a contract upgradeable at the granularity of individual functions \u2014 you can add a new function, replace a buggy one, or remove an obsolete one, all in a single transaction, without touching the parts that already work.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Nick Mudge, the standard&#8217;s author, <a href=\"https:\/\/eip2535diamonds.substack.com\/p\/introduction-to-the-diamond-standard\" rel=\"nofollow noopener noreferrer\">argues<\/a> the organizational benefit outlasts the original motivation:<\/p>\n\n\n\n<blockquote class=\"wp-block-quote is-layout-flow wp-block-quote-is-layout-flow\">\n<p class=\"wp-block-paragraph\">&#8220;Even if the 24KB max size contract limitation was removed I would still use EIP-2535 Diamonds because it provides a systematic way to organize, upgrade and extend a smart contract system.&#8221;<\/p>\n<\/blockquote>\n\n\n\n<p class=\"wp-block-paragraph\">That is the honest pitch. Diamonds are less about squeezing under a byte limit and more about running a large contract system you can reason about and change over years.<\/p>\n\n\n<h2 class=\"wp-block-heading\" id=\"how-a-diamond-routes-a-function-call\">How a Diamond Routes a Function Call<\/h2>\n\n\n<p class=\"wp-block-paragraph\">When you call a function on a diamond, the diamond&#8217;s fallback function decides which facet runs it.<\/p>\n\n\n<h3 class=\"wp-block-heading\" id=\"the-fallback-function-and-delegatecall\">The Fallback Function and delegatecall<\/h3>\n\n\n<p class=\"wp-block-paragraph\">The diamond keeps an internal mapping from a function selector \u2014 the first four bytes of the call data \u2014 to a facet address. On any incoming call, the fallback looks up the selector, finds the facet, and executes the function there with <code>delegatecall<\/code>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\"><code>delegatecall<\/code> is the key. It runs the facet&#8217;s code in the diamond&#8217;s context, so <code>msg.sender<\/code> and <code>msg.value<\/code> stay the same and only the diamond&#8217;s storage is read and written. The facet supplies the logic; the diamond owns the data. A simplified call looks like this:<\/p>\n\n\n\n<ol class=\"wp-block-list\">\n<li>A user sends a transaction to the diamond&#8217;s address.<\/li>\n\n\n\n<li>The fallback reads the function selector from the call data.<\/li>\n\n\n\n<li>It finds the facet mapped to that selector, and reverts if none exists.<\/li>\n\n\n\n<li>It <code>delegatecall<\/code>s the function on that facet.<\/li>\n\n\n\n<li>Any return value or revert passes straight back to the caller.<\/li>\n<\/ol>\n\n\n<h3 class=\"wp-block-heading\" id=\"shared-storage-diamond-storage-and-appstorage\">Shared Storage: Diamond Storage and AppStorage<\/h3>\n\n\n<p class=\"wp-block-paragraph\">There&#8217;s a catch with proxies. Solidity&#8217;s default storage layout wasn&#8217;t built for them, so facets can&#8217;t just declare state variables and expect them to line up. EIP-2535 doesn&#8217;t mandate one storage layout, but two patterns have become standard: Diamond Storage and AppStorage.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Both work by placing a struct at a fixed, known storage position. Facets that use the same struct at the same position read and write the same data, which is how independent facets safely share state inside one diamond. Get this wrong and two facets can collide on the same slot, so storage layout is where diamond bugs tend to hide.<\/p>\n\n\n<h2 class=\"wp-block-heading\" id=\"changing-a-diamond-diamondcut-and-the-diamondcut-event\">Changing a Diamond: diamondCut and the DiamondCut Event<\/h2>\n\n\n<p class=\"wp-block-paragraph\">Upgrades happen through one function, <code>diamondCut<\/code>, and every change is recorded by one event, <code>DiamondCut<\/code>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">A cut is described by an array of <code>FacetCut<\/code> structs. Each struct names a facet address, an action, and the function selectors affected:<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">solidity<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>enum FacetCutAction { Add, Replace, Remove }\n\nstruct FacetCut {\n    address facetAddress;\n    FacetCutAction action;\n    bytes4&#91;] functionSelectors;\n}\n\nfunction diamondCut(\n    FacetCut&#91;] calldata _diamondCut,\n    address _init,\n    bytes calldata _calldata\n) external;<\/code><\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">The three actions are what they sound like: <code>Add<\/code> wires new selectors to a facet, <code>Replace<\/code> points existing selectors at a new facet, and <code>Remove<\/code> deletes them. Doing all of this in a single transaction is deliberate \u2014 splitting an upgrade across several transactions is how diamonds get left in a half-updated, corrupt state.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The <code>_init<\/code> and <code>_calldata<\/code> arguments handle setup. After the selectors change, the diamond <code>delegatecall<\/code>s <code>_calldata<\/code> on <code>_init<\/code> to initialize any new storage the upgrade needs. If <code>_init<\/code> is the zero address, that step is skipped.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Every add, replace, or remove must emit a <code>DiamondCut<\/code> event. That event is the diamond&#8217;s public upgrade history. Anyone can replay it to see exactly how a contract&#8217;s functions changed over time, which is a real transparency advantage over a private, mutable backend.<\/p>\n\n\n<h2 class=\"wp-block-heading\" id=\"how-to-inspect-a-diamond\">How to Inspect a Diamond<\/h2>\n\n\n<p class=\"wp-block-paragraph\">Because a diamond&#8217;s verified source code doesn&#8217;t list the functions its facets provide, EIP-2535 standardizes four read-only &#8220;loupe&#8221; functions so software can discover them:<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">solidity<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>function facets() external view returns (Facet&#91;] memory);\nfunction facetFunctionSelectors(address _facet) external view returns (bytes4&#91;] memory);\nfunction facetAddresses() external view returns (address&#91;] memory);\nfunction facetAddress(bytes4 _functionSelector) external view returns (address);<\/code><\/pre>\n\n\n\n<p class=\"wp-block-paragraph\">Together they answer every structural question about a diamond: which facets it has, which selectors each facet serves, and which facet handles a given function. Wallets and dashboards call them to build an accurate picture of a contract they didn&#8217;t deploy.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">You don&#8217;t have to call them by hand. <a href=\"https:\/\/louper.dev\" rel=\"nofollow noopener noreferrer\">Louper<\/a>, the Ethereum Diamond Inspector, is an open-source web tool that reads a diamond&#8217;s facets and lets you interact with its functions. <a href=\"https:\/\/pypi.org\/project\/inspector-facet\/\" rel=\"nofollow noopener noreferrer\">Inspector Facet<\/a> does the same from the command line and can build an audit log of a diamond&#8217;s cuts. Both lean on the loupe functions and the <code>DiamondCut<\/code> event underneath.<\/p>\n\n\n<h2 class=\"wp-block-heading\" id=\"who-uses-ethereum-diamonds-and-when-they-fit\">Who Uses Ethereum Diamonds, and When They Fit<\/h2>\n\n\n<p class=\"wp-block-paragraph\">Diamonds suit large, long-lived systems that need to keep changing. The cross-chain bridge aggregator <a href=\"https:\/\/docs.li.fi\/introduction\/lifi-architecture\/smart-contract-overview\" rel=\"nofollow noopener noreferrer\">LI.FI<\/a> routes its logic through facets behind a single diamond, and the Beanstalk stablecoin protocol is built on the pattern too. Both are cases where functionality keeps expanding and a single 24 KB contract was never realistic.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">They are overkill for small, single-purpose contracts. A token or a simple vault gains little from facets and inherits real complexity: more moving parts, trickier storage, and a hard dependency on tooling to see what&#8217;s deployed.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">If all you need is upgradeability, diamond proxies aren&#8217;t the only option. Here&#8217;s how the pattern compares with the single-implementation proxies many teams reach for first.<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th><\/th><th>Diamond (EIP-2535)<\/th><th>Single-implementation proxy (Transparent \/ UUPS)<\/th><\/tr><\/thead><tbody><tr><td>Logic behind the address<\/td><td>Many facets<\/td><td>One implementation contract<\/td><\/tr><tr><td>Code size limit<\/td><td>Effectively none<\/td><td>~24 KB per implementation<\/td><\/tr><tr><td>Upgrade granularity<\/td><td>Per function (add \/ replace \/ remove)<\/td><td>Swap the whole implementation<\/td><\/tr><tr><td>Built-in introspection<\/td><td>Standard loupe functions<\/td><td>None standardized<\/td><\/tr><tr><td>Complexity<\/td><td>Higher<\/td><td>Lower<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">The decision usually comes down to size and granularity. If your system fits in one implementation and you upgrade it wholesale, a standard proxy is simpler. If it&#8217;s outgrowing 24 KB or you want to upgrade pieces independently, a diamond earns its complexity.<\/p>\n\n\n<h2 class=\"wp-block-heading\" id=\"the-risks-access-control-is-your-job\">The Risks: Access Control Is Your Job<\/h2>\n\n\n<figure class=\"wp-block-image size-large\"><img loading=\"lazy\" decoding=\"async\" width=\"1024\" height=\"535\" src=\"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-116-1024x535.png\" alt=\"\" class=\"wp-image-4160\" srcset=\"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-116-1024x535.png 1024w, https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-116-300x157.png 300w, https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-116-1536x802.png 1536w, https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-116-768x401.png 768w, https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/image-116.png 1735w\" sizes=\"auto, (max-width: 1024px) 100vw, 1024px\" \/><\/figure>\n\n\n\n<p class=\"wp-block-paragraph\">The most important thing EIP-2535 does not do is handle security for you. The standard is explicit that ownership and authentication are not part of it \u2014 that&#8217;s left entirely to the implementer.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">That matters because <code>diamondCut<\/code> allows arbitrary execution with full access to the diamond&#8217;s storage through <code>delegatecall<\/code>. Whoever can call it can rewrite the contract. If that permission is weak, the diamond is only as safe as the weakest path to <code>diamondCut<\/code>.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">Beanstalk is the cautionary tale. In April 2022 an attacker drained about $182 million from the protocol, and Beanstalk was built on the diamond pattern \u2014 but the <a href=\"https:\/\/immunefi.com\/blog\/bug-fix-reviews\/hack-analysis-beanstalk-governance-attack-april-2022\/\" rel=\"nofollow noopener noreferrer\">exploit was a governance flaw, not a flaw in EIP-2535<\/a>. A flash loan let the attacker buy a temporary supermajority of votes and push through a malicious proposal that moved funds out. The diamond did exactly what it was told; the access control around it was the problem.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">A few other risks are worth keeping in view:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Function selector clashes.<\/strong> Two different signatures can hash to the same four-byte selector. A correct <code>diamondCut<\/code> implementation rejects selectors that already exist, which prevents accidental overwrites.<\/li>\n\n\n\n<li><strong><code>selfdestruct<\/code>.<\/strong> The standard warns against it in facets \u2014 misused, it can delete a facet or the diamond.<\/li>\n\n\n\n<li><strong>Opacity by default.<\/strong> A block explorer shows only the diamond&#8217;s own source, not its facets&#8217; functions. Without the loupe functions or a tool like Louper, a diamond is hard to audit, so inspect before you trust one.<\/li>\n<\/ul>\n\n\n<h2 class=\"wp-block-heading\" id=\"reading-and-interacting-with-diamonds-via-nownodes\">Reading and Interacting With Diamonds via NOWNodes<\/h2>\n\n\n<p class=\"wp-block-paragraph\">Everything you do with a diamond \u2014 calling a loupe function, reading its <code>DiamondCut<\/code> history, sending a transaction to one of its facets \u2014 is a request to the Ethereum network at the diamond&#8217;s single address.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">At NOWNodes, we run the Ethereum infrastructure that sits behind those requests. You point your application at one of our <a href=\"https:\/\/nownodes.io\/nodes\/ethereum-eth\">Ethereum endpoints<\/a> and query any diamond directly. An <code>eth_call<\/code> to <code>facets()<\/code> or <code>facetAddress(selector)<\/code> returns a diamond&#8217;s current structure, and an <code>eth_getLogs<\/code> query filtered to the <code>DiamondCut<\/code> event rebuilds its full upgrade history. Pulling that history from a contract&#8217;s first block needs archive-level data, which is available on supported Ethereum access.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The point is practical: inspecting or integrating with a diamond doesn&#8217;t require you to maintain your own Ethereum infrastructure. <a href=\"https:\/\/nownodes.io\">NOWNodes<\/a> provides the connection; your code handles the diamond logic. Our products and limits can change, so check the current Ethereum pages before you build against specific features.<\/p>\n\n\n<h2 class=\"wp-block-heading\" id=\"when-diamonds-make-sense\">When Diamonds Make Sense<\/h2>\n\n\n<p class=\"wp-block-paragraph\">An Ethereum diamond gives you one stable address, a contract system with no size ceiling, and upgrades you can apply function by function with a public, event-backed history. That&#8217;s a strong fit for protocols that will keep growing and changing, and a poor fit for small contracts that won&#8217;t.<\/p>\n\n\n\n<p class=\"wp-block-paragraph\">The trade-off is responsibility. EIP-2535 hands you the architecture but not the guardrails \u2014 access control, storage layout, and upgrade discipline are all on you, and that&#8217;s where diamonds succeed or fail. Learn the loupe functions, restrict <code>diamondCut<\/code> carefully, and inspect any diamond before you interact with it.<\/p>\n\n\n<h2 class=\"wp-block-heading\" id=\"faq\">FAQ<\/h2>\n\n<h3 class=\"wp-block-heading\" id=\"can-a-diamond-be-made-immutable\">Can a diamond be made immutable?<\/h3>\n\n\n<p class=\"wp-block-paragraph\">Yes. A diamond is only upgradeable while it keeps a working <code>diamondCut<\/code> function. Omit it, or remove the ability to call it, and the diamond becomes immutable \u2014 its functions can no longer be added, replaced, or removed. Some projects launch upgradeable and then lock the diamond down once the code is stable.<\/p>\n\n\n<h3 class=\"wp-block-heading\" id=\"whats-the-difference-between-eip2535-and-eip1538\">What&#8217;s the difference between EIP-2535 and EIP-1538?<\/h3>\n\n\n<p class=\"wp-block-paragraph\">EIP-1538, the Transparent Contract Standard, was the earlier version of the same idea, also by Nick Mudge. EIP-2535 is its successor: it keeps the multi-facet proxy concept but uses function selectors and adds the standardized loupe functions and <code>DiamondCut<\/code> event that make diamonds work cleanly with tooling.<\/p>\n\n\n<h3 class=\"wp-block-heading\" id=\"do-diamonds-add-gas-overhead\">Do diamonds add gas overhead?<\/h3>\n\n\n<p class=\"wp-block-paragraph\">Routing a call through the fallback and <code>delegatecall<\/code> adds a small amount of gas versus calling a plain contract directly. In practice it&#8217;s often offset. A diamond can bundle multiple operations into one transaction and read storage directly instead of calling across separate contracts, which can save more gas than the routing costs.<\/p>\n\n\n<h3 class=\"wp-block-heading\" id=\"if-a-block-explorer-only-shows-the-proxy-where-is-a-diamonds-real-code\">If a block explorer only shows the proxy, where is a diamond&#8217;s real code?<\/h3>\n\n\n<p class=\"wp-block-paragraph\">Each facet is its own deployed, independently verifiable contract. The diamond&#8217;s verified source won&#8217;t list them, so you use the loupe functions \u2014 or a tool like Louper that calls them for you \u2014 to map selectors to facet addresses and read each facet&#8217;s verified code.<\/p>\n\n\n<h3 class=\"wp-block-heading\" id=\"is-eip2535-productionready\">Is EIP-2535 production-ready?<\/h3>\n\n\n<p class=\"wp-block-paragraph\">EIP-2535 is a Final Ethereum standard with <a href=\"https:\/\/github.com\/mudgen\/diamond-3-hardhat\" rel=\"nofollow noopener noreferrer\">multiple reference implementations<\/a> and several independent security audits of diamond code. It&#8217;s used in production today. As with any upgradeable contract, its safety in a given project depends on that project&#8217;s access control and audits, not on the standard alone.<\/p>\n","protected":false},"excerpt":{"rendered":"<p>A diamond is a single smart contract whose external functions are supplied by several other contracts, called facets. To a wallet, a block explorer, or another contract, it looks like one ordinary contract at one Ethereum address. Behind that address, the diamond forwards each call to the facet that implements it using delegatecall. That design [&hellip;]<\/p>\n","protected":false},"author":3,"featured_media":4161,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_eb_attr":"","_lmt_disableupdate":"","_lmt_disable":"","_monsterinsights_skip_tracking":false,"footnotes":""},"categories":[102],"tags":[],"class_list":["post-4158","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-dev-report"],"blocksy_meta":[],"yoast_head":"<!-- This site is optimized with the Yoast SEO plugin v22.0 - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>Ethereum Diamonds (EIP-2535): The Multi-Facet Proxy<\/title>\n<meta name=\"description\" content=\"EIP-2535 defines diamonds: modular smart contracts that route calls to facets via delegatecall, upgrade function by function, and skip the 24 KB size limit.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Ethereum Diamonds (EIP-2535): The Multi-Facet Proxy\" \/>\n<meta property=\"og:description\" content=\"EIP-2535 defines diamonds: modular smart contracts that route calls to facets via delegatecall, upgrade function by function, and skip the 24 KB size limit.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/\" \/>\n<meta property=\"og:site_name\" content=\"NOWNodes Blog\" \/>\n<meta property=\"article:published_time\" content=\"2026-10-20T14:24:23+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-10-20T14:24:24+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/text_2-23.jpg\" \/>\n\t<meta property=\"og:image:width\" content=\"1800\" \/>\n\t<meta property=\"og:image:height\" content=\"900\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\n<meta name=\"author\" content=\"\u0410nastasia\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:creator\" content=\"@nownodes\" \/>\n<meta name=\"twitter:site\" content=\"@nownodes\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"\u0410nastasia\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"10 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/\"},\"author\":{\"name\":\"\u0410nastasia\",\"@id\":\"https:\/\/nownodes.io\/blog\/#\/schema\/person\/0890ec68e813adecb93c18ee00e1e7a8\"},\"headline\":\"What Is the Diamond Proxy Pattern (EIP-2535)?\",\"datePublished\":\"2026-10-20T14:24:23+00:00\",\"dateModified\":\"2026-10-20T14:24:24+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/\"},\"wordCount\":2126,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\/\/nownodes.io\/blog\/#organization\"},\"articleSection\":[\"Dev Report\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/\",\"url\":\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/\",\"name\":\"Ethereum Diamonds (EIP-2535): The Multi-Facet Proxy\",\"isPartOf\":{\"@id\":\"https:\/\/nownodes.io\/blog\/#website\"},\"datePublished\":\"2026-10-20T14:24:23+00:00\",\"dateModified\":\"2026-10-20T14:24:24+00:00\",\"description\":\"EIP-2535 defines diamonds: modular smart contracts that route calls to facets via delegatecall, upgrade function by function, and skip the 24 KB size limit.\",\"breadcrumb\":{\"@id\":\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/\"]}]},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Blog\",\"item\":\"https:\/\/nownodes.io\/blog\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Dev Report\",\"item\":\"https:\/\/nownodes.io\/blog\/category\/dev-report\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"What Is the Diamond Proxy Pattern (EIP-2535)?\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\/\/nownodes.io\/blog\/#website\",\"url\":\"https:\/\/nownodes.io\/blog\/\",\"name\":\"NOWNodes Blog\",\"description\":\"Your first-to-go source of development guides, web3 analytics and most recent news about NOWNodes\",\"publisher\":{\"@id\":\"https:\/\/nownodes.io\/blog\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\/\/nownodes.io\/blog\/?s={search_term_string}\"},\"query-input\":\"required name=search_term_string\"}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"https:\/\/nownodes.io\/blog\/#organization\",\"name\":\"NOWNodes Blog\",\"url\":\"https:\/\/nownodes.io\/blog\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/nownodes.io\/blog\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2024\/02\/cropped-New-Logo-NN.png\",\"contentUrl\":\"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2024\/02\/cropped-New-Logo-NN.png\",\"width\":1164,\"height\":1164,\"caption\":\"NOWNodes Blog\"},\"image\":{\"@id\":\"https:\/\/nownodes.io\/blog\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/twitter.com\/nownodes\"]},{\"@type\":\"Person\",\"@id\":\"https:\/\/nownodes.io\/blog\/#\/schema\/person\/0890ec68e813adecb93c18ee00e1e7a8\",\"name\":\"\u0410nastasia\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/nownodes.io\/blog\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/1de24ab8dcdd7ec30f6adaf78b56bc1eda421f87575b7e103c8fc3fc4420e833?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/1de24ab8dcdd7ec30f6adaf78b56bc1eda421f87575b7e103c8fc3fc4420e833?s=96&d=mm&r=g\",\"caption\":\"\u0410nastasia\"},\"url\":\"https:\/\/nownodes.io\/blog\/author\/nasty-nownodes\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Ethereum Diamonds (EIP-2535): The Multi-Facet Proxy","description":"EIP-2535 defines diamonds: modular smart contracts that route calls to facets via delegatecall, upgrade function by function, and skip the 24 KB size limit.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/","og_locale":"en_US","og_type":"article","og_title":"Ethereum Diamonds (EIP-2535): The Multi-Facet Proxy","og_description":"EIP-2535 defines diamonds: modular smart contracts that route calls to facets via delegatecall, upgrade function by function, and skip the 24 KB size limit.","og_url":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/","og_site_name":"NOWNodes Blog","article_published_time":"2026-10-20T14:24:23+00:00","article_modified_time":"2026-10-20T14:24:24+00:00","og_image":[{"width":1800,"height":900,"url":"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2026\/10\/text_2-23.jpg","type":"image\/jpeg"}],"author":"\u0410nastasia","twitter_card":"summary_large_image","twitter_creator":"@nownodes","twitter_site":"@nownodes","twitter_misc":{"Written by":"\u0410nastasia","Est. reading time":"10 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/#article","isPartOf":{"@id":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/"},"author":{"name":"\u0410nastasia","@id":"https:\/\/nownodes.io\/blog\/#\/schema\/person\/0890ec68e813adecb93c18ee00e1e7a8"},"headline":"What Is the Diamond Proxy Pattern (EIP-2535)?","datePublished":"2026-10-20T14:24:23+00:00","dateModified":"2026-10-20T14:24:24+00:00","mainEntityOfPage":{"@id":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/"},"wordCount":2126,"commentCount":0,"publisher":{"@id":"https:\/\/nownodes.io\/blog\/#organization"},"articleSection":["Dev Report"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/","url":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/","name":"Ethereum Diamonds (EIP-2535): The Multi-Facet Proxy","isPartOf":{"@id":"https:\/\/nownodes.io\/blog\/#website"},"datePublished":"2026-10-20T14:24:23+00:00","dateModified":"2026-10-20T14:24:24+00:00","description":"EIP-2535 defines diamonds: modular smart contracts that route calls to facets via delegatecall, upgrade function by function, and skip the 24 KB size limit.","breadcrumb":{"@id":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/"]}]},{"@type":"BreadcrumbList","@id":"https:\/\/nownodes.io\/blog\/what-is-the-diamond-proxy-pattern-eip-2535\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Blog","item":"https:\/\/nownodes.io\/blog"},{"@type":"ListItem","position":2,"name":"Dev Report","item":"https:\/\/nownodes.io\/blog\/category\/dev-report"},{"@type":"ListItem","position":3,"name":"What Is the Diamond Proxy Pattern (EIP-2535)?"}]},{"@type":"WebSite","@id":"https:\/\/nownodes.io\/blog\/#website","url":"https:\/\/nownodes.io\/blog\/","name":"NOWNodes Blog","description":"Your first-to-go source of development guides, web3 analytics and most recent news about NOWNodes","publisher":{"@id":"https:\/\/nownodes.io\/blog\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/nownodes.io\/blog\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Organization","@id":"https:\/\/nownodes.io\/blog\/#organization","name":"NOWNodes Blog","url":"https:\/\/nownodes.io\/blog\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/nownodes.io\/blog\/#\/schema\/logo\/image\/","url":"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2024\/02\/cropped-New-Logo-NN.png","contentUrl":"https:\/\/nownodes.io\/blog\/wp-content\/uploads\/2024\/02\/cropped-New-Logo-NN.png","width":1164,"height":1164,"caption":"NOWNodes Blog"},"image":{"@id":"https:\/\/nownodes.io\/blog\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/twitter.com\/nownodes"]},{"@type":"Person","@id":"https:\/\/nownodes.io\/blog\/#\/schema\/person\/0890ec68e813adecb93c18ee00e1e7a8","name":"\u0410nastasia","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/nownodes.io\/blog\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/1de24ab8dcdd7ec30f6adaf78b56bc1eda421f87575b7e103c8fc3fc4420e833?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1de24ab8dcdd7ec30f6adaf78b56bc1eda421f87575b7e103c8fc3fc4420e833?s=96&d=mm&r=g","caption":"\u0410nastasia"},"url":"https:\/\/nownodes.io\/blog\/author\/nasty-nownodes"}]}},"modified_by":"\u0410nastasia","_links":{"self":[{"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/posts\/4158","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/users\/3"}],"replies":[{"embeddable":true,"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/comments?post=4158"}],"version-history":[{"count":1,"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/posts\/4158\/revisions"}],"predecessor-version":[{"id":4162,"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/posts\/4158\/revisions\/4162"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/media\/4161"}],"wp:attachment":[{"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/media?parent=4158"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/categories?post=4158"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/nownodes.io\/blog\/wp-json\/wp\/v2\/tags?post=4158"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}