slotdiff 0.0.0-stage → 0.1.0-alpha.1

package/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+## 0.1.0-alpha.1
+
+First release.
+
+- `resolveProxyLayout` / `resolveLayout`: the storage layout of the code a proxy (ERC-1967 or
+  beacon) runs now, rebuilt from verified standard-json source on any Etherscan-compatible explorer
+  and proven against the deployed code.
+- `proveLocalBuild`: a layout record from your own build, only when it is the deployed build.
+- `diffLayouts`: OpenZeppelin's storage comparison, including ERC-7201 namespaced storage.
+- `LayoutRecord`s are plain JSON that slotdiff never writes. Load them back with `verifyRecord`
+  (checked against the chain id and deployed code) or `parseRecord` (offline).
+- A match proves a layout only when the build embeds solc's metadata hash. Builds with
+  `bytecodeHash: "none"` or `appendCBOR: false` are reported as `code-only` and refused.
+- `getSolc`: native solc from a cache (Hardhat's included) or a checksum-verified download.
+  Accepts release versions such as `0.8.24`, as Foundry's build info records them.
+- `layoutFromSource` accepts build-info input from Foundry and Hardhat.
+- Loads from ESM and CommonJS. Node 22.12+.

package/LICENSE

@@ -0,0 +1,10 @@
+MIT License
+
+Copyright (c) 2026 Rohit Solia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

package/README.md

@@ -1,3 +1,214 @@
-# Temporary Holding Version
+# slotdiff
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Storage layout diff for upgradeable Solidity contracts, where either side can be a local build or
+the code a proxy actually runs on chain.
+
+```ts
+const live = await resolveProxyLayout(provider, proxy, { explorer: { apiKey } });
+const report = diffLayouts(
+  live.record.layout,
+  await layoutFromSource(input, solc, "src/Vault.sol:Vault"),
+);
+if (!report.ok) console.log(report.explain());
+```
+
+## Why
+
+An upgrade is only safe relative to what the proxy runs **now**. Under lazy or multisig-queued
+upgrades that is often not your latest build, and the tools you have compare the wrong thing:
+
+- OpenZeppelin's `validate` compares two local builds. It has no way to know what is live.
+- `cast storage <address>` prints a live layout but does not compare it with anything.
+- Deployment artifacts describe the last build you deployed, not necessarily what the proxy runs.
+
+slotdiff reads the implementation behind the proxy, rebuilds its layout from verified source, and
+**proves** that source compiles to the deployed code before trusting it. It then compares with
+OpenZeppelin's own rules, including ERC-7201 namespaced storage. Framework-agnostic: Foundry,
+Hardhat 2 and 3, or a plain script.
+
+## Install
+
+```sh
+npm install slotdiff
+```
+
+Node 22.12+. Works from ESM and CommonJS.
+
+## Usage
+
+### Live proxy vs a local build
+
+```ts
+import { readFileSync } from "node:fs";
+import { JsonRpcProvider } from "ethers";
+import { diffLayouts, getSolc, layoutFromSource, resolveProxyLayout } from "slotdiff";
+
+// Any object with send(method, params): an ethers JsonRpcProvider or Hardhat's network provider.
+const provider = new JsonRpcProvider(process.env.RPC_URL);
+const apiKey = process.env.ETHERSCAN_API_KEY;
+
+// 1. The layout of whatever the proxy runs now, proven against its deployed code.
+const live = await resolveProxyLayout(provider, "0xProxy", { explorer: { apiKey } });
+
+// 2. The layout of the new version, from your build info (see below for each tool).
+const buildInfo = JSON.parse(readFileSync("out/build-info/<id>.json", "utf8"));
+const solc = await getSolc(buildInfo.solcLongVersion);
+const next = await layoutFromSource(buildInfo.input, solc, "src/Vault.sol:Vault");
+
+// 3. Compare.
+const report = diffLayouts(live.record.layout, next);
+if (!report.ok) {
+  console.error(report.explain());
+  process.exit(1);
+}
+```
+
+Where the build info lives:
+
+| Tool      | Build info                                                                                             | Contract name                       |
+| --------- | ------------------------------------------------------------------------------------------------------ | ----------------------------------- |
+| Foundry   | `out/build-info/*.json`, only with `build_info = true` in `foundry.toml` or `forge build --build-info` | `src/Vault.sol:Vault`               |
+| Hardhat 2 | `artifacts/build-info/*.json`                                                                          | `contracts/Vault.sol:Vault`         |
+| Hardhat 3 | `artifacts/build-info/<id>.json`; the compiler output is in `<id>.output.json` next to it              | `project/contracts/Vault.sol:Vault` |
+
+Each holds `input` and `solcLongVersion`. Use the source name exactly as it appears in `input.sources`.
+
+`explain()` gives OpenZeppelin's report, for example:
+
+```
+src/Vault.sol:7: Inserted `inserted`
+  > New variables should be placed after all existing inherited variables
+```
+
+The explorer defaults to Etherscan's v2 API, where one key covers every chain it indexes. For another
+Etherscan-compatible explorer, such as Blockscout, pass `{ apiUrl }` (a key is optional there).
+
+### Keep records, skip the rebuild next time
+
+Rebuilding means fetching source and compiling. A `LayoutRecord` is plain JSON: store it wherever
+suits you (committed next to your deployments, a CI cache) and load it back with `verifyRecord`,
+which refuses it unless this chain still runs the exact code it was proven against.
+
+```ts
+import { readFileSync, writeFileSync } from "node:fs";
+import { readImplementation, resolveLayout, verifyRecord } from "slotdiff";
+
+const impl = await readImplementation(provider, "0xProxy"); // what the proxy runs now
+const path = `layouts/${impl}.json`;
+
+let record;
+try {
+  record = await verifyRecord(provider, impl, JSON.parse(readFileSync(path, "utf8")));
+} catch {
+  record = await resolveLayout(provider, impl, { explorer: { apiKey } });
+  writeFileSync(path, JSON.stringify(record, null, 2));
+}
+```
+
+Key records by **implementation**, and read the implementation from the proxy every time. A record
+for an old implementation still verifies after the proxy is upgraded, because that code is still
+deployed at its own address.
+
+Without an RPC, `parseRecord(value, address)` checks a record's shape and proof offline. It cannot
+tell whether the proxy has moved on, so prefer `verifyRecord` whenever you can reach the chain.
+
+A record is bound to the deployed code, not to its own `layout` field: an edited layout in a saved
+record still verifies. Treat saved records as trusted input and review changes to them like code.
+
+### No explorer: prove your own build
+
+If you deployed it yourself, your build can serve as the source. `proveLocalBuild` compares the
+deployed code with your compiler output and returns a record only when they prove to be the same
+build.
+
+```ts
+import { proveLocalBuild } from "slotdiff";
+
+// Hardhat 3: read `output` from `<id>.output.json` instead.
+const compiled = buildInfo.output.contracts["src/Vault.sol"].Vault.evm.deployedBytecode;
+const { bytecodeMatch, record } = await proveLocalBuild(provider, impl, {
+  contract: "src/Vault.sol:Vault",
+  compiler: solc.longVersion,
+  layout: await layoutFromSource(buildInfo.input, solc, "src/Vault.sol:Vault"),
+  deployedBytecode: compiled.object,
+  immutableReferences: compiled.immutableReferences,
+});
+if (record === undefined) throw new Error(`Not the deployed build (${bytecodeMatch})`);
+```
+
+## What counts as proof
+
+A layout is only trusted when the compiled code matches the deployed code as `exact` or
+`immutables-only` (identical once immutables and library addresses are masked), **and** the build
+embeds solc's metadata hash. That hash covers every source file and setting, so matching code then
+means matching source.
+
+Anything weaker is refused, because variables no code reads, retyped fields and gap sizes never
+reach the bytecode, so a different layout can compile to the same code:
+
+| Match             | Meaning                                                                 | Proof? |
+| ----------------- | ----------------------------------------------------------------------- | ------ |
+| `exact`           | Byte-identical                                                          | Yes    |
+| `immutables-only` | Identical once immutables and library links are masked                  | Yes    |
+| `metadata-only`   | Identical only after stripping metadata: the source differed            | No     |
+| `code-only`       | Identical, but built with `bytecodeHash: "none"` or `appendCBOR: false` | No     |
+| `none`            | Different code                                                          | No     |
+
+Contracts built without a metadata hash (common for deterministic CREATE2 deployments) therefore
+cannot be proven. For explorer source, the verified compiler settings are checked as well, so a
+build without a hash is refused even if its code happens to end in bytes shaped like one. With
+`proveLocalBuild`, the hash is read from your own compiler output.
+
+## Errors
+
+slotdiff fails closed: it never treats "could not check" as "safe".
+
+- `LayoutUnavailableError`: no answer. Not a proxy, unverified source, explorer outage or rate
+  limit, no compiler for the platform. Falling back to another source is reasonable.
+- `LayoutIntegrityError`: an answer that cannot be trusted. Source that does not compile to the
+  deployed code, a weak match, a record from another chain or for other code. Never fall back on
+  this one.
+
+A few problems that are yours to fix throw a plain `Error`: a rejected explorer API key, a compiler
+binary that fails to run (for example the wrong architecture), and a record in a format from a
+newer slotdiff.
+
+## API
+
+| Export                                                       | Purpose                                                                  |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------ |
+| `diffLayouts(before, after, { unsafeAllowRenames? })`        | OpenZeppelin's storage comparison. `ok` and `explain()`                  |
+| `resolveProxyLayout(provider, proxy, options)`               | Proven layout of what a proxy (ERC-1967 or beacon) runs now              |
+| `resolveLayout(provider, address, options)`                  | Proven layout of the code at an implementation address                   |
+| `proveLocalBuild(provider, address, build)`                  | A record from your own build, only when it is the deployed build         |
+| `verifyRecord(provider, address, value)`                     | Load a saved record, checked against the chain                           |
+| `parseRecord(value, address?)`                               | Load a saved record, checked offline                                     |
+| `layoutFromSource(input, solc, "file.sol:Name")`             | Layout from standard-json input, including ERC-7201 namespaces. No proof |
+| `getSolc(version)`                                           | Native solc, from a cache or downloaded and checksum-verified            |
+| `readProxy`, `readImplementation`, `readCode`, `readChainId` | Chain reads                                                              |
+| `fetchVerifiedSource(chainId, address, explorer)`            | Verified standard-json source from an Etherscan-compatible explorer      |
+| `compareDeployedBytecode`, `isProvingMatch`                  | The match classification above                                           |
+
+`getSolc` takes a long (`0.8.24+commit.e11b9ed9`) or release (`0.8.24`) version. Compilers are
+cached under your OS cache directory (`slotdiff/compilers`, or `cacheDir`), and Hardhat's compiler
+cache is reused when present.
+
+Renames and retypes follow OpenZeppelin's NatSpec tags, `@custom:oz-renamed-from` and
+`@custom:oz-retyped-from`.
+
+## Limitations
+
+- Explorer source must be verified as standard-json. Flattened and multi-file verifications do not
+  record every compiler setting, so they are refused.
+- Solidity only.
+- Struct members cannot be renamed or retyped: Solidity has no NatSpec on struct members, so
+  OpenZeppelin's tags cannot reach them.
+- ERC-7201 namespaces are located by their `@custom:storage-location erc7201:<id>` annotation, as
+  OpenZeppelin does. The `bytes32` slot constant your code actually uses is not checked against
+  it, so moving the constant while leaving the annotation unchanged is not detected. Keep the two in
+  sync, for example by deriving the constant with the ERC-7201 formula in a test.
+- Library only for now. A CLI is planned.
+
+## License
+
+MIT

package/dist/bytecode.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Bytecode comparison utilities.
+ *
+ * Solidity appends a CBOR-encoded metadata hash to the end of every compiled
+ * contract's bytecode. The last two bytes encode the length of that metadata
+ * section. Stripping it allows comparing contracts that are logically identical
+ * but were compiled in different environments (different metadata).
+ */
+export declare function stripBytecodeMetadata(bytecode: string): string;
+/**
+ * solc's `evm.deployedBytecode.immutableReferences`: AST id to the byte spans
+ * (relative to the deployed bytecode) that the constructor fills in.
+ */
+export type ImmutableReferences = Record<string, ReadonlyArray<{
+    start: number;
+    length: number;
+}>>;
+/**
+ * - `exact`: byte-identical.
+ * - `immutables-only`: identical once immutable (and library-link) spans are
+ *   masked. Same code, deployment-specific values. Every UUPS implementation
+ *   lands here because `UUPSUpgradeable.__self` is immutable.
+ * - `metadata-only`: identical after masking and stripping the CBOR metadata,
+ *   so the compiler input was not byte-identical (source hashes or settings).
+ *   NOT proof of storage layout: variables no code reads, gap sizes and field
+ *   names do not reach the bytecode, so different layouts can share code.
+ * - `code-only`: identical (exactly or once masked), but the build embeds no
+ *   source hash (`bytecodeHash: "none"` or `appendCBOR: false`), so nothing
+ *   ties the code to its source. NOT proof of layout, for the same reason.
+ * - `none`: different code.
+ *
+ * `exact` and `immutables-only` therefore always mean the source is proven too.
+ */
+export type DeployedBytecodeMatch = "exact" | "immutables-only" | "metadata-only" | "code-only" | "none";
+/** The matches that prove a source is the deployed code, and so prove its layout. */
+export type ProvingMatch = "exact" | "immutables-only";
+export declare function isProvingMatch(match: DeployedBytecodeMatch): match is ProvingMatch;
+/**
+ * Compares runtime code read with `eth_getCode` against compiler output.
+ *
+ * On-chain code has immutables filled in while compiler output has them
+ * zeroed, and the difference sits in the code body where metadata stripping
+ * cannot reach, so the spans are zeroed on both sides before comparing.
+ */
+export declare function compareDeployedBytecode(onchain: string, compiled: string, immutableReferences?: ImmutableReferences): DeployedBytecodeMatch;
+//# sourceMappingURL=bytecode.d.ts.map

package/dist/bytecode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytecode.d.ts","sourceRoot":"","sources":["../src/bytecode.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAK9D;AA8CD;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC;AAEnG;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,qBAAqB,GAC/B,OAAO,GAAG,iBAAiB,GAAG,eAAe,GAAG,WAAW,GAAG,MAAM,CAAC;AAEvE,qFAAqF;AACrF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,iBAAiB,CAAC;AAEvD,wBAAgB,cAAc,CAAC,KAAK,EAAE,qBAAqB,GAAG,KAAK,IAAI,YAAY,CAElF;AAKD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,mBAAmB,GAAE,mBAAwB,GAC5C,qBAAqB,CAoBvB"}

package/dist/bytecode.js

@@ -0,0 +1,101 @@
+/**
+ * Bytecode comparison utilities.
+ *
+ * Solidity appends a CBOR-encoded metadata hash to the end of every compiled
+ * contract's bytecode. The last two bytes encode the length of that metadata
+ * section. Stripping it allows comparing contracts that are logically identical
+ * but were compiled in different environments (different metadata).
+ */
+export function stripBytecodeMetadata(bytecode) {
+    const buf = toBuffer(bytecode);
+    const start = cborStart(buf);
+    if (start === undefined)
+        return bytecode;
+    return "0x" + buf.subarray(0, start).toString("hex");
+}
+function toBuffer(bytecode) {
+    return Buffer.from(bytecode.startsWith("0x") ? bytecode.slice(2) : bytecode, "hex");
+}
+// Where solc's CBOR metadata starts, or undefined when the tail is not CBOR.
+function cborStart(buf) {
+    if (buf.length < 2)
+        return undefined;
+    const metadataLength = buf.readUInt16BE(buf.length - 2);
+    if (metadataLength === 0 || metadataLength + 2 > buf.length)
+        return undefined;
+    // solc's metadata is a CBOR map (major type 5). Without that marker the
+    // tail is code (e.g. compiled with appendCBOR: false), and stripping it
+    // would hide real differences.
+    const start = buf.length - 2 - metadataLength;
+    return buf[start] >> 5 === 5 ? start : undefined;
+}
+// The CBOR keys solc uses for the metadata hash, each with its byte-string header.
+const SOURCE_HASH_KEYS = [
+    Buffer.from("6469706673" + "5822", "hex"), // "ipfs", 34 bytes
+    Buffer.from("65627a7a7230" + "5820", "hex"), // "bzzr0", 32 bytes
+    Buffer.from("65627a7a7231" + "5820", "hex"), // "bzzr1", 32 bytes
+];
+/**
+ * Whether compiled code embeds the hash of its metadata, which covers every
+ * source file and the settings. Only then does matching code also mean
+ * matching source. `bytecodeHash: "none"` and `appendCBOR: false` drop it.
+ */
+function hasSourceHash(bytecode) {
+    const buf = toBuffer(bytecode);
+    const start = cborStart(buf);
+    if (start === undefined)
+        return false;
+    const cbor = buf.subarray(start, buf.length - 2);
+    return SOURCE_HASH_KEYS.some((key) => cbor.includes(key));
+}
+function normalize(s) {
+    return s.toLowerCase().replace(/^0x/, "");
+}
+export function isProvingMatch(match) {
+    return match === "exact" || match === "immutables-only";
+}
+// solc leaves `__$<34 hex>$__` (20 bytes) where an external library address is linked.
+const LINK_PLACEHOLDER = /__\$[0-9a-fA-F]{34}\$__/g;
+/**
+ * Compares runtime code read with `eth_getCode` against compiler output.
+ *
+ * On-chain code has immutables filled in while compiler output has them
+ * zeroed, and the difference sits in the code body where metadata stripping
+ * cannot reach, so the spans are zeroed on both sides before comparing.
+ */
+export function compareDeployedBytecode(onchain, compiled, immutableReferences = {}) {
+    const live = normalize(onchain);
+    const built = normalize(compiled);
+    if (live === "" || built === "")
+        return "none";
+    if (live === built)
+        return hasSourceHash(built) ? "exact" : "code-only";
+    const spans = Object.values(immutableReferences).flat();
+    for (const m of built.matchAll(LINK_PLACEHOLDER)) {
+        spans.push({ start: m.index / 2, length: 20 });
+    }
+    const builtHex = built.replace(LINK_PLACEHOLDER, "0".repeat(40));
+    const liveMasked = maskSpans(live, spans);
+    const builtMasked = maskSpans(builtHex, spans);
+    if (liveMasked === undefined || builtMasked === undefined)
+        return "none";
+    if (liveMasked === builtMasked)
+        return hasSourceHash(builtHex) ? "immutables-only" : "code-only";
+    if (stripBytecodeMetadata(liveMasked) === stripBytecodeMetadata(builtMasked)) {
+        return "metadata-only";
+    }
+    return "none";
+}
+// Returns undefined when the hex is malformed or a span falls outside the code.
+function maskSpans(hex, spans) {
+    const buf = Buffer.from(hex, "hex");
+    if (buf.length * 2 !== hex.length)
+        return undefined;
+    for (const { start, length } of spans) {
+        if (start + length > buf.length)
+            return undefined;
+        buf.fill(0, start, start + length);
+    }
+    return buf.toString("hex");
+}
+//# sourceMappingURL=bytecode.js.map

package/dist/bytecode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytecode.js","sourceRoot":"","sources":["../src/bytecode.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,UAAU,qBAAqB,CAAC,QAAgB;IACpD,MAAM,GAAG,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,QAAQ,CAAC;IACzC,OAAO,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AACvD,CAAC;AAED,SAAS,QAAQ,CAAC,QAAgB;IAChC,OAAO,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;AACtF,CAAC;AAED,6EAA6E;AAC7E,SAAS,SAAS,CAAC,GAAW;IAC5B,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC;QAAE,OAAO,SAAS,CAAC;IACrC,MAAM,cAAc,GAAG,GAAG,CAAC,YAAY,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACxD,IAAI,cAAc,KAAK,CAAC,IAAI,cAAc,GAAG,CAAC,GAAG,GAAG,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IAC9E,wEAAwE;IACxE,wEAAwE;IACxE,+BAA+B;IAC/B,MAAM,KAAK,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,GAAG,cAAc,CAAC;IAC9C,OAAO,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;AACnD,CAAC;AAED,mFAAmF;AACnF,MAAM,gBAAgB,GAAG;IACvB,MAAM,CAAC,IAAI,CAAC,YAAY,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,mBAAmB;IAC9D,MAAM,CAAC,IAAI,CAAC,cAAc,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,oBAAoB;IACjE,MAAM,CAAC,IAAI,CAAC,cAAc,GAAG,MAAM,EAAE,KAAK,CAAC,EAAE,oBAAoB;CAClE,CAAC;AAEF;;;;GAIG;AACH,SAAS,aAAa,CAAC,QAAgB;IACrC,MAAM,GAAG,GAAG,QAAQ,CAAC,QAAQ,CAAC,CAAC;IAC/B,MAAM,KAAK,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;IAC7B,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACtC,MAAM,IAAI,GAAG,GAAG,CAAC,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACjD,OAAO,gBAAgB,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;AAC5D,CAAC;AAED,SAAS,SAAS,CAAC,CAAS;IAC1B,OAAO,CAAC,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AAC5C,CAAC;AAkCD,MAAM,UAAU,cAAc,CAAC,KAA4B;IACzD,OAAO,KAAK,KAAK,OAAO,IAAI,KAAK,KAAK,iBAAiB,CAAC;AAC1D,CAAC;AAED,uFAAuF;AACvF,MAAM,gBAAgB,GAAG,0BAA0B,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACrC,OAAe,EACf,QAAgB,EAChB,sBAA2C,EAAE;IAE7C,MAAM,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;IAChC,MAAM,KAAK,GAAG,SAAS,CAAC,QAAQ,CAAC,CAAC;IAClC,IAAI,IAAI,KAAK,EAAE,IAAI,KAAK,KAAK,EAAE;QAAE,OAAO,MAAM,CAAC;IAC/C,IAAI,IAAI,KAAK,KAAK;QAAE,OAAO,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,WAAW,CAAC;IAExE,MAAM,KAAK,GAA6C,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC,IAAI,EAAE,CAAC;IAClG,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE,CAAC;QACjD,KAAK,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,KAAK,GAAG,CAAC,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;IACjD,CAAC;IACD,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;IAEjE,MAAM,UAAU,GAAG,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;IAC1C,MAAM,WAAW,GAAG,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC/C,IAAI,UAAU,KAAK,SAAS,IAAI,WAAW,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACzE,IAAI,UAAU,KAAK,WAAW;QAAE,OAAO,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAC,CAAC,WAAW,CAAC;IACjG,IAAI,qBAAqB,CAAC,UAAU,CAAC,KAAK,qBAAqB,CAAC,WAAW,CAAC,EAAE,CAAC;QAC7E,OAAO,eAAe,CAAC;IACzB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,gFAAgF;AAChF,SAAS,SAAS,CAChB,GAAW,EACX,KAAuD;IAEvD,MAAM,GAAG,GAAG,MAAM,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;IACpC,IAAI,GAAG,CAAC,MAAM,GAAG,CAAC,KAAK,GAAG,CAAC,MAAM;QAAE,OAAO,SAAS,CAAC;IACpD,KAAK,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,KAAK,EAAE,CAAC;QACtC,IAAI,KAAK,GAAG,MAAM,GAAG,GAAG,CAAC,MAAM;YAAE,OAAO,SAAS,CAAC;QAClD,GAAG,CAAC,IAAI,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,GAAG,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC7B,CAAC"}

package/dist/chain.d.ts

@@ -0,0 +1,20 @@
+/** The one JSON-RPC method used; Hardhat's network provider and ethers' JsonRpcProvider both fit. */
+export interface EthProvider {
+    send(method: string, params: unknown[]): Promise<unknown>;
+}
+export interface ProxyState {
+    implementation: string;
+    /** Set for a beacon proxy; `implementation` is then the beacon's. */
+    beacon?: string;
+}
+/**
+ * Reads what a proxy runs right now: the ERC-1967 implementation slot, or the
+ * beacon's implementation for a beacon proxy. Undefined when neither slot is
+ * set, i.e. the address is not a proxy this tool understands.
+ */
+export declare function readProxy(provider: EthProvider, address: string): Promise<ProxyState | undefined>;
+export declare function readImplementation(provider: EthProvider, proxy: string): Promise<string>;
+export declare function readCode(provider: EthProvider, address: string): Promise<string>;
+export declare function readChainId(provider: EthProvider): Promise<number>;
+export declare function codeSha256(code: string): string;
+//# sourceMappingURL=chain.d.ts.map

package/dist/chain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.d.ts","sourceRoot":"","sources":["../src/chain.ts"],"names":[],"mappings":"AAWA,qGAAqG;AACrG,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC3D;AAED,MAAM,WAAW,UAAU;IACzB,cAAc,EAAE,MAAM,CAAC;IACvB,qEAAqE;IACrE,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,WAAW,EACrB,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAgBjC;AAED,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAQ9F;AAED,wBAAsB,QAAQ,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAMtF;AAED,wBAAsB,WAAW,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAExE;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAI/C"}

package/dist/chain.js

@@ -0,0 +1,52 @@
+import { EIP1967BeaconNotFound, EIP1967ImplementationNotFound, getBeaconAddress, getImplementationAddress, getImplementationAddressFromBeacon, } from "@openzeppelin/upgrades-core";
+import { createHash } from "node:crypto";
+import { LayoutUnavailableError } from "./errors.js";
+/**
+ * Reads what a proxy runs right now: the ERC-1967 implementation slot, or the
+ * beacon's implementation for a beacon proxy. Undefined when neither slot is
+ * set, i.e. the address is not a proxy this tool understands.
+ */
+export async function readProxy(provider, address) {
+    const oz = provider;
+    try {
+        return { implementation: (await getImplementationAddress(oz, address)).toLowerCase() };
+    }
+    catch (e) {
+        if (!(e instanceof EIP1967ImplementationNotFound))
+            throw e;
+    }
+    let beacon;
+    try {
+        beacon = (await getBeaconAddress(oz, address)).toLowerCase();
+    }
+    catch (e) {
+        if (e instanceof EIP1967BeaconNotFound)
+            return undefined;
+        throw e;
+    }
+    const implementation = (await getImplementationAddressFromBeacon(oz, beacon)).toLowerCase();
+    return { implementation, beacon };
+}
+export async function readImplementation(provider, proxy) {
+    const state = await readProxy(provider, proxy);
+    if (state === undefined) {
+        throw new LayoutUnavailableError(`${proxy} has no ERC-1967 implementation or beacon slot set on this chain.`);
+    }
+    return state.implementation;
+}
+export async function readCode(provider, address) {
+    const code = (await provider.send("eth_getCode", [address, "latest"]));
+    if (code === "0x" || code === "") {
+        throw new LayoutUnavailableError(`No code at ${address} on this chain.`);
+    }
+    return code.toLowerCase();
+}
+export async function readChainId(provider) {
+    return Number(BigInt((await provider.send("eth_chainId", []))));
+}
+export function codeSha256(code) {
+    return createHash("sha256")
+        .update(Buffer.from(code.replace(/^0x/, ""), "hex"))
+        .digest("hex");
+}
+//# sourceMappingURL=chain.js.map

package/dist/chain.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chain.js","sourceRoot":"","sources":["../src/chain.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,qBAAqB,EACrB,6BAA6B,EAC7B,gBAAgB,EAChB,wBAAwB,EACxB,kCAAkC,GAEnC,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAarD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC7B,QAAqB,EACrB,OAAe;IAEf,MAAM,EAAE,GAAG,QAAuC,CAAC;IACnD,IAAI,CAAC;QACH,OAAO,EAAE,cAAc,EAAE,CAAC,MAAM,wBAAwB,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC;IACzF,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,IAAI,CAAC,CAAC,CAAC,YAAY,6BAA6B,CAAC;YAAE,MAAM,CAAC,CAAC;IAC7D,CAAC;IACD,IAAI,MAAc,CAAC;IACnB,IAAI,CAAC;QACH,MAAM,GAAG,CAAC,MAAM,gBAAgB,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;IAC/D,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,IAAI,CAAC,YAAY,qBAAqB;YAAE,OAAO,SAAS,CAAC;QACzD,MAAM,CAAC,CAAC;IACV,CAAC;IACD,MAAM,cAAc,GAAG,CAAC,MAAM,kCAAkC,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC;IAC5F,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,CAAC;AACpC,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,QAAqB,EAAE,KAAa;IAC3E,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAC;IAC/C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,MAAM,IAAI,sBAAsB,CAC9B,GAAG,KAAK,mEAAmE,CAC5E,CAAC;IACJ,CAAC;IACD,OAAO,KAAK,CAAC,cAAc,CAAC;AAC9B,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,QAAQ,CAAC,QAAqB,EAAE,OAAe;IACnE,MAAM,IAAI,GAAG,CAAC,MAAM,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAW,CAAC;IACjF,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACjC,MAAM,IAAI,sBAAsB,CAAC,cAAc,OAAO,iBAAiB,CAAC,CAAC;IAC3E,CAAC;IACD,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;AAC5B,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,QAAqB;IACrD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,MAAM,QAAQ,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,CAAC,CAAW,CAAC,CAAC,CAAC;AAC5E,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,IAAY;IACrC,OAAO,UAAU,CAAC,QAAQ,CAAC;SACxB,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,KAAK,CAAC,CAAC;SACnD,MAAM,CAAC,KAAK,CAAC,CAAC;AACnB,CAAC"}

package/dist/diff.d.ts

@@ -0,0 +1,15 @@
+import { getStorageUpgradeReport, type StorageLayout } from "@openzeppelin/upgrades-core";
+/** OZ's storage comparison. `ok` is the verdict; `explain()` describes each problem. */
+export type LayoutReport = ReturnType<typeof getStorageUpgradeReport>;
+export interface DiffOptions {
+    /** Accept renamed variables without `@custom:oz-renamed-from` (OZ's `unsafeAllowRenames`). */
+    unsafeAllowRenames?: boolean;
+}
+/**
+ * Whether `after` can safely replace `before` behind a proxy, by OZ's rules:
+ * appends pass; inserts, removals, reorders and incompatible type changes
+ * fail, in regular and ERC-7201 namespaced storage. Renames and retypes pass
+ * when `after` approves them (`@custom:oz-renamed-from` / `oz-retyped-from`).
+ */
+export declare function diffLayouts(before: StorageLayout, after: StorageLayout, options?: DiffOptions): LayoutReport;
+//# sourceMappingURL=diff.d.ts.map

package/dist/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../src/diff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EAEvB,KAAK,aAAa,EACnB,MAAM,6BAA6B,CAAC;AAErC,wFAAwF;AACxF,MAAM,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAEtE,MAAM,WAAW,WAAW;IAC1B,8FAA8F;IAC9F,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,aAAa,EACrB,KAAK,EAAE,aAAa,EACpB,OAAO,GAAE,WAAgB,GACxB,YAAY,CAMd"}

package/dist/diff.js

@@ -0,0 +1,11 @@
+import { getStorageUpgradeReport, withValidationDefaults, } from "@openzeppelin/upgrades-core";
+/**
+ * Whether `after` can safely replace `before` behind a proxy, by OZ's rules:
+ * appends pass; inserts, removals, reorders and incompatible type changes
+ * fail, in regular and ERC-7201 namespaced storage. Renames and retypes pass
+ * when `after` approves them (`@custom:oz-renamed-from` / `oz-retyped-from`).
+ */
+export function diffLayouts(before, after, options = {}) {
+    return getStorageUpgradeReport(before, after, withValidationDefaults({ unsafeAllowRenames: options.unsafeAllowRenames }));
+}
+//# sourceMappingURL=diff.js.map

package/dist/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../src/diff.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,sBAAsB,GAEvB,MAAM,6BAA6B,CAAC;AAUrC;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CACzB,MAAqB,EACrB,KAAoB,EACpB,UAAuB,EAAE;IAEzB,OAAO,uBAAuB,CAC5B,MAAM,EACN,KAAK,EACL,sBAAsB,CAAC,EAAE,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAC3E,CAAC;AACJ,CAAC"}

package/dist/errors.d.ts

@@ -0,0 +1,18 @@
+/**
+ * The chain cannot supply a layout: no implementation behind the proxy slots,
+ * no code at the address, unverified source, an unsupported verification
+ * format, or no explorer configured. Callers may fall back to another source.
+ */
+export declare class LayoutUnavailableError extends Error {
+    constructor(message: string);
+}
+/**
+ * The answer cannot be trusted: rebuilt bytecode does not match the deployed
+ * code, a record describes different code or another chain, or compilation
+ * failed. Never fall back on this one, since a silent fallback would compare
+ * against a layout nothing is running.
+ */
+export declare class LayoutIntegrityError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,qBAAa,sBAAuB,SAAQ,KAAK;gBACnC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;GAKG;AACH,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B"}

package/dist/errors.js

@@ -0,0 +1,24 @@
+/**
+ * The chain cannot supply a layout: no implementation behind the proxy slots,
+ * no code at the address, unverified source, an unsupported verification
+ * format, or no explorer configured. Callers may fall back to another source.
+ */
+export class LayoutUnavailableError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "LayoutUnavailableError";
+    }
+}
+/**
+ * The answer cannot be trusted: rebuilt bytecode does not match the deployed
+ * code, a record describes different code or another chain, or compilation
+ * failed. Never fall back on this one, since a silent fallback would compare
+ * against a layout nothing is running.
+ */
+export class LayoutIntegrityError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "LayoutIntegrityError";
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAC/C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;IACvC,CAAC;CACF;AAED;;;;;GAKG;AACH,MAAM,OAAO,oBAAqB,SAAQ,KAAK;IAC7C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;IACrC,CAAC;CACF"}

package/dist/explorer.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Verified-source lookup against an Etherscan-compatible explorer API.
+ *
+ * Only standard-json verifications are accepted. Flattened and multi-file
+ * verifications do not record every compiler setting (`viaIR` among them), so
+ * rebuilding from them means guessing; the bytecode proof would reject a wrong
+ * guess, but refusing up front gives a clearer error.
+ */
+import type { SolcInput } from "@openzeppelin/upgrades-core";
+export declare const ETHERSCAN_V2_API_URL = "https://api.etherscan.io/v2/api";
+export interface ExplorerConfig {
+    /** Etherscan-compatible endpoint. Defaults to Etherscan v2, which serves every chain it indexes. */
+    apiUrl?: string;
+    apiKey?: string;
+}
+export interface VerifiedSource {
+    input: SolcInput;
+    /** e.g. `0.8.25+commit.b61c2a91` */
+    solcLongVersion: string;
+    /** Simple contract name as verified. */
+    contractName: string;
+}
+type FetchLike = (url: string) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<unknown>;
+}>;
+interface SourceCodeEntry {
+    SourceCode?: string;
+    ContractName?: string;
+    CompilerVersion?: string;
+}
+/**
+ * Etherscan needs a key; a custom Etherscan-compatible endpoint (e.g. a
+ * Blockscout instance) may not.
+ */
+export declare function canQueryExplorer(config: ExplorerConfig): boolean;
+export declare function fetchVerifiedSource(chainId: number, address: string, config: ExplorerConfig, fetchImpl?: FetchLike): Promise<VerifiedSource>;
+/** Exported for tests. */
+export declare function parseSourceCodeEntry(entry: SourceCodeEntry, address: string): VerifiedSource;
+export {};
+//# sourceMappingURL=explorer.d.ts.map

package/dist/explorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"explorer.d.ts","sourceRoot":"","sources":["../src/explorer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAG7D,eAAO,MAAM,oBAAoB,oCAAoC,CAAC;AAEtE,MAAM,WAAW,cAAc;IAC7B,oGAAoG;IACpG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,SAAS,CAAC;IACjB,oCAAoC;IACpC,eAAe,EAAE,MAAM,CAAC;IACxB,wCAAwC;IACxC,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,KAAK,SAAS,GAAG,CACf,GAAG,EAAE,MAAM,KACR,OAAO,CAAC;IAAE,EAAE,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,IAAI,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAAC;AAQxE,UAAU,eAAe;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAQD;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAEhE;AAED,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,cAAc,EACtB,SAAS,GAAE,SAAiB,GAC3B,OAAO,CAAC,cAAc,CAAC,CAgBzB;AAyDD,0BAA0B;AAC1B,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc,CAoC5F"}