Merge branch 'develop' into dependabot/npm_and_yarn/eslint-plugin-unicorn-48.0.1

.changeset/mighty-countries-drum.md

+---
+'@eth-optimism/sdk': patch
+---
+
+Adds Sepolia & OP Sepolia support to SDK

.changeset/smart-goats-camp.md

+---
+'@eth-optimism/contracts-bedrock': patch
+---
+
+bumps sdk version to have access to sepolia deployments

.circleci/config.yml

@@ -887,6 +887,18 @@ jobs:
           name: Build
           command: make indexer
           working_directory: indexer
+      - run:
+          name: Install node_modules
+          command: pnpm install --frozen-lockfile --prefer-offline
+          working_directory: indexer/api-ts
+      - run:
+          name: Install tygo
+          command: go install github.com/gzuidhof/tygo@latest
+          working_directory: indexer/api-ts
+      - run:
+          name: Check generated code
+          command: npm run generate && git diff --exit-code
+          working_directory: indexer/api-ts
 
   devnet:
     machine:

Makefile

@@ -109,7 +109,6 @@ devnet-down:
 
 devnet-clean:
 	rm -rf ./packages/contracts-bedrock/deployments/devnetL1
-	rm -rf ./packages/contracts-bedrock/deploy-config/devnetL1.json
 	rm -rf ./.devnet
 	cd ./ops-bedrock && docker compose down
 	docker image ls 'ops-bedrock*' --format='{{.Repository}}' | xargs -r docker rmi

go.mod

@@ -208,6 +208,6 @@ require (
 	rsc.io/tmplfunc v0.0.3 // indirect
 )
 
-replace github.com/ethereum/go-ethereum v1.12.0 => github.com/ethereum-optimism/op-geth v1.101200.0-rc.1.0.20230818191139-f7376a28049b
+replace github.com/ethereum/go-ethereum v1.12.0 => github.com/ethereum-optimism/op-geth v1.101200.2-rc.1.0.20230914224024-b84ba11915a0
 
 //replace github.com/ethereum/go-ethereum v1.12.0 => ../go-ethereum

go.sum

@@ -162,8 +162,8 @@ github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7
 github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3 h1:RWHKLhCrQThMfch+QJ1Z8veEq5ZO3DfIhZ7xgRP9WTc=
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3/go.mod h1:QziizLAiF0KqyLdNJYD7O5cpDlaFMNZzlxYNcWsJUxs=
-github.com/ethereum-optimism/op-geth v1.101200.0-rc.1.0.20230818191139-f7376a28049b h1:YF2FE/QnbhvrHwDYJHnbTKgJvw2aKwB/dd7PO1zKNqY=
-github.com/ethereum-optimism/op-geth v1.101200.0-rc.1.0.20230818191139-f7376a28049b/go.mod h1:gRnPb21PoKcHm3kHqj9BQlQkwmhOGUvQoGEbC7z852Q=
+github.com/ethereum-optimism/op-geth v1.101200.2-rc.1.0.20230914224024-b84ba11915a0 h1:Qcu7OVMbKvbu7aaDC31OY0JCqFIr2N+/SGdBTnxukCs=
+github.com/ethereum-optimism/op-geth v1.101200.2-rc.1.0.20230914224024-b84ba11915a0/go.mod h1:gRnPb21PoKcHm3kHqj9BQlQkwmhOGUvQoGEbC7z852Q=
 github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20230817174831-5d3ca1966435 h1:2CzkJkkTLuVyoVFkoW5w6vDB2Q7eJzxXw/ybA17xjqM=
 github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20230817174831-5d3ca1966435/go.mod h1:v2YpePbdGBF0Gr6VWq49MFFmcTW0kRYZ2ingBJYWEwg=
 github.com/ethereum/c-kzg-4844 v0.2.0 h1:+cUvymlnoDDQgMInp25Bo3OmLajmmY8mLJ/tLjqd77Q=

indexer/api-ts/README.md

+Generated typescript types for https://github.com/ethereum-optimism/optimism/tree/develop/indexer

indexer/api-ts/generated.ts

@@ -8,12 +8,12 @@ export interface DepositItem {
   from: string;
   to: string;
   timestamp: number /* uint64 */;
-  L1TxHash: string;
-  L2TxHash: string;
-  Block: string;
+  l1BlockHash: string;
+  l1TxHash: string;
+  l2TxHash: string;
   amount: string;
-  l1Token: string;
-  l2Token: string;
+  l1TokenAddress: string;
+  l2TokenAddress: string;
 }
 export interface DepositResponse {
   cursor: string;
@@ -41,10 +41,10 @@ export interface WithdrawalItem {
   timestamp: number /* uint64 */;
   l2BlockHash: string;
   amount: string;
-  proof: string;
-  claim: string;
-  l1Token: string;
-  l2Token: string;
+  proofTransactionHash: string;
+  claimTransactionHash: string;
+  l1TokenAddress: string;
+  l2TokenAddress: string;
 }
 export interface WithdrawalResponse {
   cursor: string;

indexer/api-ts/indexer.cjs

@@ -38,10 +38,10 @@ var createQueryString = ({ cursor, limit }) => {
   return `?${queries.join("&")}`;
 };
 var depositEndpoint = ({ baseUrl = "", address, cursor, limit }) => {
-  return [baseUrl, "deposits", address, createQueryString({ cursor, limit })].join("/");
+  return [baseUrl, "deposits", `${address}${createQueryString({ cursor, limit })}`].join("/");
 };
 var withdrawalEndoint = ({ baseUrl = "", address, cursor, limit }) => {
-  return [baseUrl, "withdrawals", address, createQueryString({ cursor, limit })].join("/");
+  return [baseUrl, "withdrawals", `${address}${createQueryString({ cursor, limit })}`].join("/");
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

indexer/api-ts/indexer.cjs.map

-{"version":3,"sources":["indexer.ts"],"sourcesContent":["export * from './generated'\n\ntype PaginationOptions = {\n  limit?: number\n  cursor?: string\n}\n\ntype Options = {\n  baseUrl?: string\n  address: `0x${string}`\n} & PaginationOptions\n\nconst createQueryString = ({ cursor, limit }: PaginationOptions): string => {\n  if (cursor === undefined && limit === undefined) {\n    return ''\n  }\n  const queries: string[] = []\n  if (cursor) {\n    queries.push(`cursor=${cursor}`)\n  }\n  if (limit) {\n    queries.push(`limit=${limit}`)\n  }\n  return `?${queries.join('&')}`\n}\n\nexport const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'deposits', address, createQueryString({ cursor, limit })].join('/')\n}\n\nexport const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'withdrawals', address, createQueryString({ cursor, limit })].join('/')\n}\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,IAAM,oBAAoB,CAAC,EAAE,QAAQ,MAAM,MAAiC;AAC1E,MAAI,WAAW,UAAa,UAAU,QAAW;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AACV,YAAQ,KAAK,UAAU,MAAM,EAAE;AAAA,EACjC;AACA,MAAI,OAAO;AACT,YAAQ,KAAK,SAAS,KAAK,EAAE;AAAA,EAC/B;AACA,SAAO,IAAI,QAAQ,KAAK,GAAG,CAAC;AAC9B;AAEO,IAAM,kBAAkB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC5F,SAAO,CAAC,SAAS,YAAY,SAAS,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG;AACtF;AAEO,IAAM,oBAAoB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC9F,SAAO,CAAC,SAAS,eAAe,SAAS,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG;AACzF;","names":[]}
+{"version":3,"sources":["indexer.ts"],"sourcesContent":["export * from './generated'\n\ntype PaginationOptions = {\n  limit?: number\n  cursor?: string\n}\n\ntype Options = {\n  baseUrl?: string\n  address: `0x${string}`\n} & PaginationOptions\n\nconst createQueryString = ({ cursor, limit }: PaginationOptions): string => {\n  if (cursor === undefined && limit === undefined) {\n    return ''\n  }\n  const queries: string[] = []\n  if (cursor) {\n    queries.push(`cursor=${cursor}`)\n  }\n  if (limit) {\n    queries.push(`limit=${limit}`)\n  }\n  return `?${queries.join('&')}`\n}\n\nexport const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'deposits', `${address}${createQueryString({ cursor, limit })}`].join('/')\n}\n\nexport const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'withdrawals', `${address}${createQueryString({ cursor, limit })}`].join('/')\n}\n\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAYA,IAAM,oBAAoB,CAAC,EAAE,QAAQ,MAAM,MAAiC;AAC1E,MAAI,WAAW,UAAa,UAAU,QAAW;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AACV,YAAQ,KAAK,UAAU,MAAM,EAAE;AAAA,EACjC;AACA,MAAI,OAAO;AACT,YAAQ,KAAK,SAAS,KAAK,EAAE;AAAA,EAC/B;AACA,SAAO,IAAI,QAAQ,KAAK,GAAG,CAAC;AAC9B;AAEO,IAAM,kBAAkB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC5F,SAAO,CAAC,SAAS,YAAY,GAAG,OAAO,GAAG,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG;AAC5F;AAEO,IAAM,oBAAoB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC9F,SAAO,CAAC,SAAS,eAAe,GAAG,OAAO,GAAG,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG;AAC/F;","names":[]}
\ No newline at end of file

indexer/api-ts/indexer.js

@@ -13,10 +13,10 @@ var createQueryString = ({ cursor, limit }) => {
   return `?${queries.join("&")}`;
 };
 var depositEndpoint = ({ baseUrl = "", address, cursor, limit }) => {
-  return [baseUrl, "deposits", address, createQueryString({ cursor, limit })].join("/");
+  return [baseUrl, "deposits", `${address}${createQueryString({ cursor, limit })}`].join("/");
 };
 var withdrawalEndoint = ({ baseUrl = "", address, cursor, limit }) => {
-  return [baseUrl, "withdrawals", address, createQueryString({ cursor, limit })].join("/");
+  return [baseUrl, "withdrawals", `${address}${createQueryString({ cursor, limit })}`].join("/");
 };
 export {
   depositEndpoint,

indexer/api-ts/indexer.js.map

-{"version":3,"sources":["indexer.ts"],"sourcesContent":["export * from './generated'\n\ntype PaginationOptions = {\n  limit?: number\n  cursor?: string\n}\n\ntype Options = {\n  baseUrl?: string\n  address: `0x${string}`\n} & PaginationOptions\n\nconst createQueryString = ({ cursor, limit }: PaginationOptions): string => {\n  if (cursor === undefined && limit === undefined) {\n    return ''\n  }\n  const queries: string[] = []\n  if (cursor) {\n    queries.push(`cursor=${cursor}`)\n  }\n  if (limit) {\n    queries.push(`limit=${limit}`)\n  }\n  return `?${queries.join('&')}`\n}\n\nexport const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'deposits', address, createQueryString({ cursor, limit })].join('/')\n}\n\nexport const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'withdrawals', address, createQueryString({ cursor, limit })].join('/')\n}\n\n"],"mappings":";AAYA,IAAM,oBAAoB,CAAC,EAAE,QAAQ,MAAM,MAAiC;AAC1E,MAAI,WAAW,UAAa,UAAU,QAAW;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AACV,YAAQ,KAAK,UAAU,MAAM,EAAE;AAAA,EACjC;AACA,MAAI,OAAO;AACT,YAAQ,KAAK,SAAS,KAAK,EAAE;AAAA,EAC/B;AACA,SAAO,IAAI,QAAQ,KAAK,GAAG,CAAC;AAC9B;AAEO,IAAM,kBAAkB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC5F,SAAO,CAAC,SAAS,YAAY,SAAS,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG;AACtF;AAEO,IAAM,oBAAoB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC9F,SAAO,CAAC,SAAS,eAAe,SAAS,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,KAAK,GAAG;AACzF;","names":[]}
+{"version":3,"sources":["indexer.ts"],"sourcesContent":["export * from './generated'\n\ntype PaginationOptions = {\n  limit?: number\n  cursor?: string\n}\n\ntype Options = {\n  baseUrl?: string\n  address: `0x${string}`\n} & PaginationOptions\n\nconst createQueryString = ({ cursor, limit }: PaginationOptions): string => {\n  if (cursor === undefined && limit === undefined) {\n    return ''\n  }\n  const queries: string[] = []\n  if (cursor) {\n    queries.push(`cursor=${cursor}`)\n  }\n  if (limit) {\n    queries.push(`limit=${limit}`)\n  }\n  return `?${queries.join('&')}`\n}\n\nexport const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'deposits', `${address}${createQueryString({ cursor, limit })}`].join('/')\n}\n\nexport const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {\n  return [baseUrl, 'withdrawals', `${address}${createQueryString({ cursor, limit })}`].join('/')\n}\n\n"],"mappings":";AAYA,IAAM,oBAAoB,CAAC,EAAE,QAAQ,MAAM,MAAiC;AAC1E,MAAI,WAAW,UAAa,UAAU,QAAW;AAC/C,WAAO;AAAA,EACT;AACA,QAAM,UAAoB,CAAC;AAC3B,MAAI,QAAQ;AACV,YAAQ,KAAK,UAAU,MAAM,EAAE;AAAA,EACjC;AACA,MAAI,OAAO;AACT,YAAQ,KAAK,SAAS,KAAK,EAAE;AAAA,EAC/B;AACA,SAAO,IAAI,QAAQ,KAAK,GAAG,CAAC;AAC9B;AAEO,IAAM,kBAAkB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC5F,SAAO,CAAC,SAAS,YAAY,GAAG,OAAO,GAAG,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG;AAC5F;AAEO,IAAM,oBAAoB,CAAC,EAAE,UAAU,IAAI,SAAS,QAAQ,MAAM,MAAuB;AAC9F,SAAO,CAAC,SAAS,eAAe,GAAG,OAAO,GAAG,kBAAkB,EAAE,QAAQ,MAAM,CAAC,CAAC,EAAE,EAAE,KAAK,GAAG;AAC/F;","names":[]}
\ No newline at end of file

indexer/api-ts/indexer.spec.ts

+import { test, expect } from 'vitest'
+import { depositEndpoint, withdrawalEndoint } from './indexer.ts'
+
+test(depositEndpoint.name, () => {
+  expect(depositEndpoint({ baseUrl: 'http://localhost:8080/api/v0', address: '0x1234', cursor: '0x1235', limit: 10 })).toMatchInlineSnapshot('"http://localhost:8080/api/v0/deposits/0x1234?cursor=0x1235&limit=10"')
+  expect(depositEndpoint({ baseUrl: 'http://localhost:8080/api/v0', address: '0x1234' })).toMatchInlineSnapshot('"http://localhost:8080/api/v0/deposits/0x1234"')
+})
+
+test(withdrawalEndoint.name, () => {
+  expect(withdrawalEndoint({ baseUrl: 'http://localhost:8080/api/v0', address: '0x1234', cursor: '0x1235', limit: 10 })).toMatchInlineSnapshot('"http://localhost:8080/api/v0/withdrawals/0x1234?cursor=0x1235&limit=10"')
+  expect(withdrawalEndoint({ baseUrl: 'http://localhost:8080/api/v0', address: '0x1234' })).toMatchInlineSnapshot('"http://localhost:8080/api/v0/withdrawals/0x1234"')
+})

indexer/api-ts/indexer.ts

@@ -25,10 +25,10 @@ const createQueryString = ({ cursor, limit }: PaginationOptions): string => {
 }
 
 export const depositEndpoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {
-  return [baseUrl, 'deposits', address, createQueryString({ cursor, limit })].join('/')
+  return [baseUrl, 'deposits', `${address}${createQueryString({ cursor, limit })}`].join('/')
 }
 
 export const withdrawalEndoint = ({ baseUrl = '', address, cursor, limit }: Options): string => {
-  return [baseUrl, 'withdrawals', address, createQueryString({ cursor, limit })].join('/')
+  return [baseUrl, 'withdrawals', `${address}${createQueryString({ cursor, limit })}`].join('/')
 }
 

indexer/api-ts/package.json

 {
   "name": "@eth-optimism/indexer-api",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "[Optimism] typescript types for the indexer service",
   "main": "indexer.cjs",
   "module": "indexer.js",
@@ -17,7 +17,8 @@
   ],
   "scripts": {
     "clean": "rm -rf generated.ts indexer.cjs indexer.js",
-    "generate": "npm run clean && tygo generate && mv ../api/routes/index.ts generated.ts && npx tsup"
+    "generate": "npm run clean && tygo generate && mv ../api/routes/index.ts generated.ts && tsup",
+    "test": "vitest"
   },
   "keywords": [
     "optimism",
@@ -30,4 +31,9 @@
   "repository": {
     "type": "git",
     "url": "https://github.com/ethereum-optimism/optimism.git"
-  }}
+  },
+  "devDependencies": {
+    "tsup": "^7.2.0",
+    "vitest": "^0.34.4"
+  }
+}

indexer/api-ts/tsconfig.json

@@ -4,7 +4,7 @@
     "strict": true,
     "skipLibCheck": true,
     "module": "ESNext",
-    "moduleResolution": "bundler",
+    "moduleResolution": "NodeNext",
     "jsx": "react",
     "target": "ESNext",
     "noEmit": true

indexer/api/routes/deposits.go

@@ -14,12 +14,12 @@ type DepositItem struct {
 	From           string `json:"from"`
 	To             string `json:"to"`
 	Timestamp      uint64 `json:"timestamp"`
-	L1TxHash       string `json:"L1TxHash"`
-	L2TxHash       string `json:"L2TxHash"`
-	L1BlockHash    string `json:"Block"`
+	L1BlockHash    string `json:"l1BlockHash"`
+	L1TxHash       string `json:"l1TxHash"`
+	L2TxHash       string `json:"l2TxHash"`
 	Amount         string `json:"amount"`
-	L1TokenAddress string `json:"l1Token"`
-	L2TokenAddress string `json:"l2Token"`
+	L1TokenAddress string `json:"l1TokenAddress"`
+	L2TokenAddress string `json:"l2TokenAddress"`
 }
 
 type DepositResponse struct {

indexer/api/routes/withdrawals.go

@@ -17,10 +17,10 @@ type WithdrawalItem struct {
 	Timestamp            uint64 `json:"timestamp"`
 	L2BlockHash          string `json:"l2BlockHash"`
 	Amount               string `json:"amount"`
-	ProofTransactionHash string `json:"proof"`
-	ClaimTransactionHash string `json:"claim"`
-	L1TokenAddress       string `json:"l1Token"`
-	L2TokenAddress       string `json:"l2Token"`
+	ProofTransactionHash string `json:"proofTransactionHash"`
+	ClaimTransactionHash string `json:"claimTransactionHash"`
+	L1TokenAddress       string `json:"l1TokenAddress"`
+	L2TokenAddress       string `json:"l2TokenAddress"`
 }
 
 type WithdrawalResponse struct {

op-bindings/artifacts.json

@@ -35,5 +35,6 @@
   "PreimageOracle",
   "BlockOracle",
   "EAS",
-  "SchemaRegistry"
+  "SchemaRegistry",
+  "ProtocolVersions"
 ]

op-bindings/bindings/mips_more.go

@@ -15,7 +15,7 @@ var MIPSStorageLayout = new(solc.StorageLayout)
 
 var MIPSDeployedBin = "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"
 
-var MIPSDeployedSourceMap = "1131:39544:105:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1710:45;;1745:10;1710:45;;;;;188:10:258;176:23;;;158:42;;146:2;131:18;1710:45:105;;;;;;;;2448:99;;;412:42:258;2534:6:105;400:55:258;382:74;;370:2;355:18;2448:99:105;211:251:258;25555:6339:105;;;;;;:::i;:::-;;:::i;:::-;;;1687:25:258;;;1675:2;1660:18;25555:6339:105;1541:177:258;25555:6339:105;25633:7;25676:18;;:::i;:::-;25823:4;25816:5;25813:15;25803:134;;25917:1;25914;25907:12;25803:134;25973:4;25967:11;25980;25964:28;25954:137;;26071:1;26068;26061:12;25954:137;26139:3;26121:16;26118:25;26108:150;;26238:1;26235;26228:12;26108:150;26302:3;26288:12;26285:21;26275:145;;26400:1;26397;26390:12;26275:145;26680:24;;27024:4;26726:20;27082:2;26784:21;;26680:24;26842:18;26726:20;26784:21;;;26680:24;26657:21;26653:52;;;26842:18;26726:20;;;26784:21;;;26680:24;26653:52;;26726:20;;26784:21;;;26680:24;26653:52;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;;26842:18;26726:20;26784:21;;;26680:24;26657:21;26653:52;;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;26842:18;26726:20;27700:10;26842:18;27690:21;;;26784;;;;27798:1;27783:77;27808:2;27805:1;27802:9;27783:77;;;26680:24;;26657:21;26653:52;26726:20;;27856:1;26784:21;;;;26668:2;26842:18;;;;27826:1;27819:9;27783:77;;;27787:14;;;27938:5;:12;;;27934:71;;;27977:13;:11;:13::i;:::-;27970:20;;;;;27934:71;28019:10;;;:15;;28033:1;28019:15;;;;;28104:8;;;;-1:-1:-1;;28096:20:105;;-1:-1:-1;28096:7:105;:20::i;:::-;28082:34;-1:-1:-1;28146:10:105;28154:2;28146:10;;;;28223:1;28213:11;;;:26;;;28228:6;:11;;28238:1;28228:11;28213:26;28209:310;;;28369:13;28438:1;28416:4;28423:10;28416:17;28415:24;;;;28386:5;:12;;;28401:10;28386:25;28385:54;28369:70;;28464:40;28475:6;:11;;28485:1;28475:11;:20;;28493:2;28475:20;;;28489:1;28475:20;28464:40;;28497:6;28464:10;:40::i;:::-;28457:47;;;;;;;;28209:310;28768:15;;;;28563:9;;;;28700:4;28694:2;28686:10;;;28685:19;;;28768:15;28793:2;28785:10;;;28784:19;28768:36;;;;;;;:::i;:::-;;;;;;-1:-1:-1;28833:5:105;28857:11;;;;;:29;;;28872:6;:14;;28882:4;28872:14;28857:29;28853:832;;;28949:5;:15;;;28965:5;28949:22;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;29012:4:105;29006:2;28998:10;;;28997:19;28853:832;;;29050:4;29041:6;:13;;;29037:648;;;29171:6;:13;;29181:3;29171:13;:30;;;;29188:6;:13;;29198:3;29188:13;29171:30;:47;;;;29205:6;:13;;29215:3;29205:13;29171:47;29167:253;;;29281:4;29288:6;29281:13;29276:18;;29037:648;;29167:253;29380:21;29383:4;29390:6;29383:13;29398:2;29380;:21::i;:::-;29375:26;;29037:648;;;29454:4;29444:6;:14;;;;:32;;;;29462:6;:14;;29472:4;29462:14;29444:32;:50;;;;29480:6;:14;;29490:4;29480:14;29444:50;29440:245;;;29564:5;:15;;;29580:5;29564:22;;;;;;;;;:::i;:::-;;;;;29559:27;;29665:5;29657:13;;29440:245;29714:1;29704:6;:11;;;;:25;;;;;29728:1;29719:6;:10;;;29704:25;29703:42;;;;29734:6;:11;;29744:1;29734:11;29703:42;29699:125;;;29772:37;29785:6;29793:4;29799:5;29806:2;29772:12;:37::i;:::-;29765:44;;;;;;;;;;;29699:125;29857:13;29838:16;30009:4;29999:14;;;;29995:446;;30078:21;30081:4;30088:6;30081:13;30096:2;30078;:21::i;:::-;30072:27;;;;30136:10;30131:15;;30170:16;30131:15;30184:1;30170:7;:16::i;:::-;30164:22;;30218:4;30208:6;:14;;;;:32;;;;;30226:6;:14;;30236:4;30226:14;;30208:32;30204:223;;;30305:4;30293:16;;30407:1;30399:9;;30204:223;30015:426;29995:446;30474:10;30487:26;30495:4;30501:2;30505;30509:3;30487:7;:26::i;:::-;30516:10;30487:39;;;;-1:-1:-1;30612:4:105;30605:11;;;30644;;;:24;;;;;30667:1;30659:4;:9;;;;30644:24;:39;;;;;30679:4;30672;:11;;;30644:39;30640:847;;;30707:4;:9;;30715:1;30707:9;:22;;;;30720:4;:9;;30728:1;30720:9;30707:22;30703:144;;;30791:37;30802:4;:9;;30810:1;30802:9;:21;;30818:5;30802:21;;;30814:1;30802:21;30825:2;30791:10;:37::i;:::-;30784:44;;;;;;;;;;;;;;;30703:144;30869:4;:11;;30877:3;30869:11;30865:121;;30939:28;30948:5;30955:2;30959:7;;;;30939:8;:28::i;30865:121::-;31007:4;:11;;31015:3;31007:11;31003:121;;31077:28;31086:5;31093:2;31097:7;;;;;31077:8;:28::i;31003:121::-;31194:4;:11;;31202:3;31194:11;31190:80;;31236:15;:13;:15::i;31190:80::-;31373:4;31365;:12;;;;:27;;;;;31388:4;31381;:11;;;31365:27;31361:112;;;31423:31;31434:4;31440:2;31444;31448:5;31423:10;:31::i;31361:112::-;31547:6;:14;;31557:4;31547:14;:28;;;;-1:-1:-1;31565:10:105;;;;;31547:28;31543:93;;;31620:1;31595:5;:15;;;31611:5;31595:22;;;;;;;;;:::i;:::-;:26;;;;:22;;;;;;:26;31543:93;31682:9;:26;;31695:13;31682:26;31678:92;;31728:27;31737:9;31748:1;31751:3;31728:8;:27::i;:::-;31851:26;31860:5;31867:3;31872:4;31851:8;:26::i;:::-;31844:33;;;;;;;;;;;;;25555:6339;;;;;;;:::o;3092:2334::-;3639:4;3633:11;;3555:4;3358:31;3347:43;;3418:13;3358:31;3757:2;3457:13;;3347:43;3364:24;3358:31;3457:13;;;3347:43;;;;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3418:13;4185:11;3364:24;3358:31;3457:13;;;3347:43;3418:13;4280:11;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3133:12;;4420:13;;3633:11;;3457:13;;;;4185:11;3133:12;4500:84;4525:2;4522:1;4519:9;4500:84;;;3374:13;3364:24;;3358:31;3347:43;;3378:2;3418:13;;;;4580:1;3457:13;;;;4543:1;4536:9;4500:84;;;4504:14;4647:1;4643:2;4636:13;4742:5;4738:2;4734:14;4727:5;4722:27;4816:1;4802:15;;4837:6;4861:1;4856:273;;;;5196:1;5186:11;;4830:369;;4856:273;4888:8;4946:22;;;;5025:1;5020:22;;;;5112:1;5102:11;;4881:234;;4946:22;4965:1;4955:11;;4946:22;;5020;5039:1;5029:11;;4881:234;;4830:369;-1:-1:-1;;;5322:14:105;;;5305:32;;5365:19;5361:30;5397:3;5393:16;;;;5358:52;;3092:2334;-1:-1:-1;3092:2334:105:o;21610:1831::-;21683:11;21794:14;21811:24;21823:11;21811;:24::i;:::-;21794:41;;21943:1;21936:5;21932:13;21929:33;;;21958:1;21955;21948:12;21929:33;22091:2;22079:15;;;22032:20;22521:5;22518:1;22514:13;22556:4;22592:1;22577:343;22602:2;22599:1;22596:9;22577:343;;;22725:2;22713:15;;;22662:20;22760:12;;;22774:1;22756:20;22797:42;;;;22865:1;22860:42;;;;22749:153;;22797:42;22255:1;22248:12;;;22288:2;22281:13;;;22333:2;22320:16;;22806:31;;22797:42;;22860;22255:1;22248:12;;;22288:2;22281:13;;;22333:2;22320:16;;22869:31;;22749:153;-1:-1:-1;;22620:1:105;22613:9;22577:343;;;22581:14;23030:4;23024:11;23009:26;;23116:7;23110:4;23107:17;23097:124;;23158:10;23155:1;23148:21;23200:2;23197:1;23190:13;23097:124;-1:-1:-1;;23348:2:105;23337:14;;;;23325:10;23321:31;23318:1;23314:39;23382:16;;;;23400:10;23378:33;;21610:1831;-1:-1:-1;;;21610:1831:105:o;18720:823::-;18789:12;18876:18;;:::i;:::-;18944:4;18935:13;;18996:5;:8;;;19007:1;18996:12;18980:28;;:5;:12;;;:28;;;18976:95;;19028:28;;;;;2114:2:258;19028:28:105;;;2096:21:258;2153:2;2133:18;;;2126:30;2192:20;2172:18;;;2165:48;2230:18;;19028:28:105;;;;;;;;18976:95;19160:8;;;;;19193:12;;;;;19182:23;;;;;;;19219:20;;;;;19160:8;19351:13;;;19347:90;;19412:6;19421:1;19412:10;19384:5;:15;;;19400:8;19384:25;;;;;;;;;:::i;:::-;:38;;;;:25;;;;;;:38;19347:90;19513:13;:11;:13::i;:::-;19506:20;18720:823;-1:-1:-1;;;;;18720:823:105:o;2645:339::-;2706:11;2770:18;;;;2779:8;;;;2770:18;;;;;;2769:25;;;;;2786:1;2833:2;:9;;;2827:16;;;;;2826:22;;2825:32;;;;;;;2887:9;;2886:15;2769:25;2944:21;;2964:1;2944:21;;;2955:6;2944:21;2929:11;;;;;:37;;-1:-1:-1;;;2645:339:105;;;;:::o;13581:2026::-;13678:12;13764:18;;:::i;:::-;13832:4;13823:13;;13864:17;13924:5;:8;;;13935:1;13924:12;13908:28;;:5;:12;;;:28;;;13904:97;;13956:30;;;;;2461:2:258;13956:30:105;;;2443:21:258;2500:2;2480:18;;;2473:30;2539:22;2519:18;;;2512:50;2579:18;;13956:30:105;2259:344:258;13904:97:105;14071:7;:12;;14082:1;14071:12;:28;;;;14087:7;:12;;14098:1;14087:12;14071:28;14067:947;;;14119:9;14131:5;:15;;;14147:6;14131:23;;;;;;;;;:::i;:::-;;;;;14119:35;;14195:2;14188:9;;:3;:9;;;:25;;;;;14201:7;:12;;14212:1;14201:12;14188:25;14187:58;;;;14226:2;14219:9;;:3;:9;;;;:25;;;;;14232:7;:12;;14243:1;14232:12;14219:25;14172:73;;14101:159;14067:947;;;14357:7;:12;;14368:1;14357:12;14353:661;;14418:1;14410:3;14404:15;;;;14389:30;;14353:661;;;14522:7;:12;;14533:1;14522:12;14518:496;;14582:1;14575:3;14569:14;;;14554:29;;14518:496;;;14703:7;:12;;14714:1;14703:12;14699:315;;14791:4;14785:2;14776:11;;;14775:20;14761:10;14818:8;;;14814:84;;14878:1;14871:3;14865:14;;;14850:29;;14814:84;14919:3;:8;;14926:1;14919:8;14915:85;;14980:1;14972:3;14966:15;;;;14951:30;;14915:85;14717:297;14699:315;15090:8;;;;;15168:12;;;;15157:23;;;;;15324:178;;;;15415:1;15389:22;15392:5;15400:6;15392:14;15408:2;15389;:22::i;:::-;:27;;;;;;;15375:42;;15384:1;15375:42;15360:57;:12;;;:57;15324:178;;;15471:12;;;;;15486:1;15471:16;15456:31;;;;15324:178;15577:13;:11;:13::i;:::-;15570:20;13581:2026;-1:-1:-1;;;;;;;;13581:2026:105:o;31940:8733::-;32027:10;32089;32097:2;32089:10;;;;32128:11;;;:44;;;32154:1;32144:6;:11;;;;:27;;;;;32168:3;32159:6;:12;;;32144:27;32124:8490;;;32213:4;32206:11;;32337:6;32397:3;32392:25;;;;32472:3;32467:25;;;;32546:3;32541:25;;;;32621:3;32616:25;;;;32695:3;32690:25;;;;32768:3;32763:25;;;;32842:3;32837:25;;;;32330:532;;32392:25;32411:4;32403:12;;32392:25;;32467;32486:4;32478:12;;32467:25;;32541;32560:4;32552:12;;32541:25;;32616;32635:4;32627:12;;32616:25;;32690;32709:4;32701:12;;32690:25;;32763;32782:4;32774:12;;32763:25;;32837;32856:4;32848:12;;32330:532;;32925:4;:12;;32933:4;32925:12;32921:4023;;-1:-1:-1;;;32976:9:105;32968:26;;32989:4;32984:1;32976:9;;;32975:18;32968:26;32961:33;;32921:4023;33062:4;:12;;33070:4;33062:12;33058:3886;;-1:-1:-1;;;33113:9:105;33105:26;;33126:4;33121:1;33113:9;;;33112:18;33105:26;33098:33;;33058:3886;33199:4;:12;;33207:4;33199:12;33195:3749;;33264:4;33259:1;33251:9;;;33250:18;33297:27;33251:9;33300:11;;;;33313:2;:10;;;33297:2;:27::i;:::-;33290:34;;;;;;;33195:3749;33393:4;:12;;33401:4;33393:12;33389:3555;;-1:-1:-1;;;33436:17:105;;;33448:4;33443:9;;33436:17;33429:24;;33389:3555;33522:4;:11;;33530:3;33522:11;33518:3426;;-1:-1:-1;;;33564:17:105;;;33576:4;33571:9;;33564:17;33557:24;;33518:3426;33650:4;:12;;33658:4;33650:12;33646:3298;;33693:21;33702:2;33696:8;;:2;:8;;;;33711:2;33706;:7;33693:2;:21::i;:::-;33686:28;;;;;;33646:3298;33963:4;:12;;33971:4;33963:12;33959:2985;;34006:2;33999:9;;;;;;33959:2985;34077:4;:12;;34085:4;34077:12;34073:2871;;34120:2;34113:9;;;;;;34073:2871;34191:4;:12;;34199:4;34191:12;34187:2757;;34234:2;34227:9;;;;;;34187:2757;34305:4;:12;;34313:4;34305:12;34301:2643;;34348:2;34341:9;;;;;;34301:2643;34422:4;:12;;34430:4;34422:12;34418:2526;;34465:2;34458:9;;;;;;34418:2526;34582:4;:12;;34590:4;34582:12;34578:2366;;34625:2;34618:9;;;;;;34578:2366;34696:4;:12;;34704:4;34696:12;34692:2252;;34739:2;34732:9;;;;;;34692:2252;34810:4;:12;;34818:4;34810:12;34806:2138;;34853:2;34846:9;;;;;;34806:2138;34924:4;:12;;34932:4;34924:12;34920:2024;;34967:2;34960:9;;;;;;34920:2024;35038:4;:12;;35046:4;35038:12;35034:1910;;35081:2;35074:9;;;;;;35034:1910;35152:4;:12;;35160:4;35152:12;35148:1796;;35195:2;35188:9;;;;;;35148:1796;35267:4;:12;;35275:4;35267:12;35263:1681;;35310:2;35303:9;;;;;;35263:1681;35380:4;:12;;35388:4;35380:12;35376:1568;;35423:2;35416:9;;;;;;35376:1568;35494:4;:12;;35502:4;35494:12;35490:1454;;35537:2;35530:9;;;;;;35490:1454;35686:4;:12;;35694:4;35686:12;35682:1262;;-1:-1:-1;;;35730:7:105;;;35722:16;;35682:1262;35807:4;:12;;35815:4;35807:12;35803:1141;;-1:-1:-1;;;35851:7:105;;;35843:16;;35803:1141;35927:4;:12;;35935:4;35927:12;35923:1021;;-1:-1:-1;;;35971:7:105;;;35963:16;;35923:1021;36048:4;:12;;36056:4;36048:12;36044:900;;-1:-1:-1;;;36092:7:105;;;36084:16;;36044:900;36168:4;:12;;36176:4;36168:12;36164:780;;-1:-1:-1;;;36212:7:105;;;36204:16;;36164:780;36287:4;:12;;36295:4;36287:12;36283:661;;-1:-1:-1;;;36331:7:105;;;36323:16;;36283:661;36407:4;:12;;36415:4;36407:12;36403:541;;-1:-1:-1;;;36451:7:105;;;36443:16;;36403:541;36527:4;:12;;36535:4;36527:12;36523:421;;-1:-1:-1;;;36572:7:105;;;36570:10;36563:17;;36523:421;36649:4;:12;;36657:4;36649:12;36645:299;;36710:2;36692:21;;36698:2;36692:21;;;:29;;36720:1;36692:29;;;36716:1;36692:29;36685:36;;;;;;;;36645:299;36791:4;:12;;36799:4;36791:12;36787:157;;36839:2;36834:7;;:2;:7;;;:15;;36848:1;36834:15;;36787:157;36896:29;;;;;2810:2:258;36896:29:105;;;2792:21:258;2849:2;2829:18;;;2822:30;2888:21;2868:18;;;2861:49;2927:18;;36896:29:105;2608:343:258;36787:157:105;32174:4784;32124:8490;;;37014:6;:14;;37024:4;37014:14;37010:3590;;37073:4;37066:11;;37148:3;37140:11;;;37136:549;;-1:-1:-1;;;37193:21:105;;;37179:36;;37136:549;37300:4;:12;;37308:4;37300:12;:28;;;;37316:4;:12;;37324:4;37316:12;37300:28;37296:389;;;37360:4;:12;;37368:4;37360:12;37356:83;;37409:3;;;37356:83;37464:8;37502:127;37514:10;37509:15;;:20;37502:127;;37594:8;37561:3;37594:8;;;;;37561:3;37502:127;;;37661:1;-1:-1:-1;37654:8:105;;-1:-1:-1;;37654:8:105;37010:3590;37752:6;:14;;37762:4;37752:14;37748:2852;;-1:-1:-1;;37797:8:105;37803:2;37797:8;;;;37790:15;;37748:2852;37872:6;:14;;37882:4;37872:14;37868:2732;;37917:42;37935:2;37940:1;37935:6;37945:1;37934:12;37929:2;:17;37921:26;;:3;:26;;;;37951:4;37920:35;37957:1;37917:2;:42::i;37868:2732::-;38026:6;:14;;38036:4;38026:14;38022:2578;;38071:45;38089:2;38094:1;38089:6;38099:1;38088:12;38083:2;:17;38075:26;;:3;:26;;;;38105:6;38074:37;38113:2;38071;:45::i;38022:2578::-;38184:6;:14;;38194:4;38184:14;38180:2420;;-1:-1:-1;;38235:21:105;38254:1;38249;38244:6;;38243:12;38235:21;;38292:36;;;38363:5;38358:10;;38235:21;;;;;38357:18;38350:25;;38180:2420;38442:6;:14;;38452:4;38442:14;38438:2162;;38487:3;38480:10;;;;;38438:2162;38558:6;:14;;38568:4;38558:14;38554:2046;;38618:2;38623:1;38618:6;38628:1;38617:12;38612:2;:17;38604:26;;:3;:26;;;;38634:4;38603:35;38596:42;;;;;38554:2046;38707:6;:14;;38717:4;38707:14;38703:1897;;38767:2;38772:1;38767:6;38777:1;38766:12;38761:2;:17;38753:26;;:3;:26;;;;38783:6;38752:37;38745:44;;;;;38703:1897;38858:6;:14;;38868:4;38858:14;38854:1746;;-1:-1:-1;;38909:26:105;38933:1;38928;38923:6;;38922:12;38917:2;:17;38909:26;;38971:41;;;39047:5;39042:10;;38909:26;;;;;39041:18;39034:25;;38854:1746;39127:6;:14;;39137:4;39127:14;39123:1477;;-1:-1:-1;;39184:4:105;39178:34;39210:1;39205;39200:6;;39199:12;39194:2;:17;39178:34;;39268:27;;;39248:48;;;39326:10;;39179:9;;;39178:34;;39325:18;39318:25;;39123:1477;39411:6;:14;;39421:4;39411:14;39407:1193;;-1:-1:-1;;39468:6:105;39462:36;39496:1;39491;39486:6;;39485:12;39480:2;:17;39462:36;;39554:29;;;39534:50;;;39614:10;;39463:11;;;39462:36;;39613:18;39606:25;;39407:1193;39700:6;:14;;39710:4;39700:14;39696:904;;-1:-1:-1;;39751:20:105;39769:1;39764;39759:6;;39758:12;39751:20;;39807:36;;;39879:5;39873:11;;39751:20;;;;;39872:19;39865:26;;39696:904;39959:6;:14;;39969:4;39959:14;39955:645;;40004:2;39997:9;;;;;39955:645;40075:6;:14;;40085:4;40075:14;40071:529;;-1:-1:-1;;40126:25:105;40149:1;40144;40139:6;;40138:12;40133:2;:17;40126:25;;40187:41;;;40264:5;40258:11;;40126:25;;;;;40257:19;40250:26;;40071:529;40343:6;:14;;40353:4;40343:14;40339:261;;40388:3;40381:10;;;;;40339:261;40458:6;:14;;40468:4;40458:14;40454:146;;40503:2;40496:9;;;;;19824:782;19910:12;19997:18;;:::i;:::-;-1:-1:-1;20065:4:105;20172:2;20160:14;;;;20152:41;;;;;;;3158:2:258;20152:41:105;;;3140:21:258;3197:2;3177:18;;;3170:30;3236:16;3216:18;;;3209:44;3270:18;;20152:41:105;2956:338:258;20152:41:105;20289:14;;;;;;;:30;;;20307:12;20289:30;20285:102;;;20368:4;20339:5;:15;;;20355:9;20339:26;;;;;;;;;:::i;:::-;:33;;;;:26;;;;;;:33;20285:102;20442:12;;;;;20431:23;;;;:8;;;:23;20498:1;20483:16;;;20468:31;;;20576:13;:11;:13::i;5467:7728::-;5510:12;5596:18;;:::i;:::-;-1:-1:-1;5774:15:105;;:18;;;;5664:4;5934:18;;;;5978;;;;6022;;;;;5664:4;;5754:17;;;;5934:18;5978;6112;;;6126:4;6112:18;6108:6777;;6162:2;6191:4;6186:9;;:14;6182:144;;6302:4;6297:9;;6289:4;:18;6283:24;6182:144;6347:2;:7;;6353:1;6347:7;6343:161;;6383:10;;;;;6415:16;;;;;;;;6383:10;-1:-1:-1;6343:161:105;;;6483:2;6478:7;;6343:161;6132:386;6108:6777;;;6620:10;:18;;6634:4;6620:18;6616:6269;;1745:10;6658:14;;6616:6269;;;6756:10;:18;;6770:4;6756:18;6752:6133;;6799:1;6794:6;;6752:6133;;;6924:10;:18;;6938:4;6924:18;6920:5965;;6977:4;6962:12;;;:19;6999:26;;;:14;;;:26;7050:13;:11;:13::i;:::-;7043:20;;;;;;;;;5467:7728;:::o;6920:5965::-;7189:10;:18;;7203:4;7189:18;7185:5700;;7340:14;;;7336:2708;7185:5700;7336:2708;7510:22;;;;;7506:2538;;7635:10;7648:27;7656:2;7661:10;7656:15;7673:1;7648:7;:27::i;:::-;7759:17;;;;7635:40;;-1:-1:-1;7759:17:105;7737:19;7909:14;7928:1;7903:26;7899:131;;7971:36;7995:11;1277:21:106;1426:15;;;1467:8;1461:4;1454:22;1595:4;1582:18;;1602:19;1578:44;1624:11;1575:61;;1222:430;7971:36:105;7957:50;;7899:131;8116:20;;;;;8083:54;;;;;;;;3472:25:258;;;8083:54:105;3533:23:258;;;3513:18;;;3506:51;8052:11:105;;;;8083:19;:6;:19;;;;3445:18:258;;8083:54:105;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8051:86;;;;8364:1;8360:2;8356:10;8461:9;8458:1;8454:17;8543:6;8536:5;8533:17;8530:40;;;8563:5;8553:15;;8530:40;;8646:6;8642:2;8639:14;8636:34;;;8666:2;8656:12;;8636:34;8772:3;8767:1;8759:6;8755:14;8750:3;8746:24;8742:34;8735:41;;8872:3;8868:1;8856:9;8847:6;8844:1;8840:14;8836:30;8832:38;8828:48;8821:55;;9027:1;9023;9019;9007:9;9004:1;9000:17;8996:25;8992:33;8988:41;9154:1;9150;9146;9137:6;9125:9;9122:1;9118:17;9114:30;9110:38;9106:46;9102:54;9084:72;;9285:10;9281:15;9275:4;9271:26;9263:34;;9401:3;9393:4;9389:9;9384:3;9380:19;9377:28;9370:35;;;;9547:33;9556:2;9561:10;9556:15;9573:1;9576:3;9547:8;:33::i;:::-;9602:20;;;:38;;;;;;;;;-1:-1:-1;7506:2538:105;;-1:-1:-1;;;7506:2538:105;;9759:18;;;;;9755:289;;9929:2;9924:7;;7185:5700;;9755:289;9983:10;9978:15;;2053:3;10015:10;;9755:289;7185:5700;;;10173:10;:18;;10187:4;10173:18;10169:2716;;10327:15;;;1824:1;10327:15;;:34;;-1:-1:-1;10346:15:105;;;1859:1;10346:15;10327:34;:57;;;-1:-1:-1;10365:19:105;;;1936:1;10365:19;10327:57;10323:1593;;;10413:2;10408:7;;10169:2716;;10323:1593;10539:23;;;;;10535:1381;;10586:10;10599:27;10607:2;10612:10;10607:15;10624:1;10599:7;:27::i;:::-;10702:17;;;;10586:40;;-1:-1:-1;10945:1:105;10937:10;;11039:1;11035:17;11114:13;;;11111:32;;;11136:5;11130:11;;11111:32;11422:14;;;11228:1;11418:22;;;11414:32;;;;11311:26;11335:1;11220:10;;;11315:18;;;11311:26;11410:43;11216:20;;11518:12;11646:17;;;:23;11714:1;11691:20;;;:24;11224:2;-1:-1:-1;11224:2:105;7185:5700;;10169:2716;12118:10;:18;;12132:4;12118:18;12114:771;;12228:2;:7;;12234:1;12228:7;12224:647;;12321:14;;;;;:40;;-1:-1:-1;12339:22:105;;;1978:1;12339:22;12321:40;:62;;;-1:-1:-1;12365:18:105;;;1897:1;12365:18;12321:62;12317:404;;;12416:1;12411:6;;12224:647;;12317:404;12462:15;;;1824:1;12462:15;;:34;;-1:-1:-1;12481:15:105;;;1859:1;12481:15;12462:34;:61;;;-1:-1:-1;12500:23:105;;;2021:1;12500:23;12462:61;:84;;;-1:-1:-1;12527:19:105;;;1936:1;12527:19;12462:84;12458:263;;;12579:1;12574:6;;7185:5700;;12224:647;12772:10;12767:15;;2087:4;12804:11;;12224:647;12960:15;;;;;:23;;;;:18;;;;:23;;;;12997:15;;:23;;;:18;;;;:23;-1:-1:-1;13086:12:105;;;;13075:23;;;:8;;;:23;13142:1;13127:16;13112:31;;;;;13165:13;:11;:13::i;15948:2480::-;16042:12;16128:18;;:::i;:::-;-1:-1:-1;16196:4:105;16228:10;16336:13;;;16345:4;16336:13;16332:1705;;-1:-1:-1;16375:8:105;;;;16332:1705;;;16494:5;:13;;16503:4;16494:13;16490:1547;;16527:14;;;:8;;;:14;16490:1547;;;16657:5;:13;;16666:4;16657:13;16653:1384;;-1:-1:-1;16696:8:105;;;;16653:1384;;;16815:5;:13;;16824:4;16815:13;16811:1226;;16848:14;;;:8;;;:14;16811:1226;;;16989:5;:13;;16998:4;16989:13;16985:1052;;17116:9;17062:17;17042;;;17062;;;;17042:37;17123:2;17116:9;;;;;17098:8;;;:28;17144:22;:8;;;:22;16985:1052;;;17303:5;:13;;17312:4;17303:13;17299:738;;17370:11;17356;;;17370;;;17356:25;17425:2;17418:9;;;;;17400:8;;;:28;17446:22;:8;;;:22;17299:738;;;17627:5;:13;;17636:4;17627:13;17623:414;;17697:3;17678:23;;17684:3;17678:23;;;;;;;:::i;:::-;;17660:42;;:8;;;:42;17738:23;;;;;;;;;;;;;:::i;:::-;;17720:42;;:8;;;:42;17623:414;;;17931:5;:13;;17940:4;17931:13;17927:110;;17981:3;17975:9;;:3;:9;;;;;;;:::i;:::-;;17964:20;;;;:8;;;:20;18013:9;;;;;;;;;;;:::i;:::-;;18002:20;;:8;;;:20;17927:110;18130:14;;;;18126:85;;18193:3;18164:5;:15;;;18180:9;18164:26;;;;;;;;;:::i;:::-;:32;;;;:26;;;;;;:32;18126:85;18265:12;;;;;18254:23;;;;:8;;;:23;18321:1;18306:16;;;18291:31;;;18398:13;:11;:13::i;:::-;18391:20;15948:2480;-1:-1:-1;;;;;;;15948:2480:105:o;23777:1654::-;23953:14;23970:24;23982:11;23970;:24::i;:::-;23953:41;;24102:1;24095:5;24091:13;24088:33;;;24117:1;24114;24107:12;24088:33;24256:2;24450:15;;;24275:2;24264:14;;24252:10;24248:31;24245:1;24241:39;24406:16;;;24191:20;;24391:10;24380:22;;;24376:27;24366:38;24363:60;24892:5;24889:1;24885:13;24963:1;24948:343;24973:2;24970:1;24967:9;24948:343;;;25096:2;25084:15;;;25033:20;25131:12;;;25145:1;25127:20;25168:42;;;;25236:1;25231:42;;;;25120:153;;25168:42;22255:1;22248:12;;;22288:2;22281:13;;;22333:2;22320:16;;25177:31;;25168:42;;25231;22255:1;22248:12;;;22288:2;22281:13;;;22333:2;22320:16;;25240:31;;25120:153;-1:-1:-1;;24991:1:105;24984:9;24948:343;;;-1:-1:-1;;25390:4:105;25383:18;-1:-1:-1;;;;23777:1654:105:o;20810:586::-;21132:20;;;21156:7;21132:32;21125:3;:40;;;21238:14;;21293:17;;21287:24;;;21279:72;;;;;;;4209:2:258;21279:72:105;;;4191:21:258;4248:2;4228:18;;;4221:30;4287:34;4267:18;;;4260:62;4358:5;4338:18;;;4331:33;4381:19;;21279:72:105;4007:399:258;21279:72:105;21365:14;20810:586;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;467:347:258:-;518:8;528:6;582:3;575:4;567:6;563:17;559:27;549:55;;600:1;597;590:12;549:55;-1:-1:-1;623:20:258;;666:18;655:30;;652:50;;;698:1;695;688:12;652:50;735:4;727:6;723:17;711:29;;787:3;780:4;771:6;763;759:19;755:30;752:39;749:59;;;804:1;801;794:12;749:59;467:347;;;;;:::o;819:717::-;909:6;917;925;933;986:2;974:9;965:7;961:23;957:32;954:52;;;1002:1;999;992:12;954:52;1042:9;1029:23;1071:18;1112:2;1104:6;1101:14;1098:34;;;1128:1;1125;1118:12;1098:34;1167:58;1217:7;1208:6;1197:9;1193:22;1167:58;:::i;:::-;1244:8;;-1:-1:-1;1141:84:258;-1:-1:-1;1332:2:258;1317:18;;1304:32;;-1:-1:-1;1348:16:258;;;1345:36;;;1377:1;1374;1367:12;1345:36;;1416:60;1468:7;1457:8;1446:9;1442:24;1416:60;:::i;:::-;819:717;;;;-1:-1:-1;1495:8:258;-1:-1:-1;;;;819:717:258:o;1723:184::-;1775:77;1772:1;1765:88;1872:4;1869:1;1862:15;1896:4;1893:1;1886:15;3568:245;3647:6;3655;3708:2;3696:9;3687:7;3683:23;3679:32;3676:52;;;3724:1;3721;3714:12;3676:52;-1:-1:-1;;3747:16:258;;3803:2;3788:18;;;3782:25;3747:16;;3782:25;;-1:-1:-1;3568:245:258:o;3818:184::-;3870:77;3867:1;3860:88;3967:4;3964:1;3957:15;3991:4;3988:1;3981:15"
+var MIPSDeployedSourceMap = "1131:39544:106:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1710:45;;1745:10;1710:45;;;;;188:10:260;176:23;;;158:42;;146:2;131:18;1710:45:106;;;;;;;;2448:99;;;412:42:260;2534:6:106;400:55:260;382:74;;370:2;355:18;2448:99:106;211:251:260;25555:6339:106;;;;;;:::i;:::-;;:::i;:::-;;;1687:25:260;;;1675:2;1660:18;25555:6339:106;1541:177:260;25555:6339:106;25633:7;25676:18;;:::i;:::-;25823:4;25816:5;25813:15;25803:134;;25917:1;25914;25907:12;25803:134;25973:4;25967:11;25980;25964:28;25954:137;;26071:1;26068;26061:12;25954:137;26139:3;26121:16;26118:25;26108:150;;26238:1;26235;26228:12;26108:150;26302:3;26288:12;26285:21;26275:145;;26400:1;26397;26390:12;26275:145;26680:24;;27024:4;26726:20;27082:2;26784:21;;26680:24;26842:18;26726:20;26784:21;;;26680:24;26657:21;26653:52;;;26842:18;26726:20;;;26784:21;;;26680:24;26653:52;;26726:20;;26784:21;;;26680:24;26653:52;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;;26842:18;26726:20;26784:21;;;26680:24;26657:21;26653:52;;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;26842:18;26726:20;26784:21;;;26680:24;26653:52;;26842:18;26726:20;27700:10;26842:18;27690:21;;;26784;;;;27798:1;27783:77;27808:2;27805:1;27802:9;27783:77;;;26680:24;;26657:21;26653:52;26726:20;;27856:1;26784:21;;;;26668:2;26842:18;;;;27826:1;27819:9;27783:77;;;27787:14;;;27938:5;:12;;;27934:71;;;27977:13;:11;:13::i;:::-;27970:20;;;;;27934:71;28019:10;;;:15;;28033:1;28019:15;;;;;28104:8;;;;-1:-1:-1;;28096:20:106;;-1:-1:-1;28096:7:106;:20::i;:::-;28082:34;-1:-1:-1;28146:10:106;28154:2;28146:10;;;;28223:1;28213:11;;;:26;;;28228:6;:11;;28238:1;28228:11;28213:26;28209:310;;;28369:13;28438:1;28416:4;28423:10;28416:17;28415:24;;;;28386:5;:12;;;28401:10;28386:25;28385:54;28369:70;;28464:40;28475:6;:11;;28485:1;28475:11;:20;;28493:2;28475:20;;;28489:1;28475:20;28464:40;;28497:6;28464:10;:40::i;:::-;28457:47;;;;;;;;28209:310;28768:15;;;;28563:9;;;;28700:4;28694:2;28686:10;;;28685:19;;;28768:15;28793:2;28785:10;;;28784:19;28768:36;;;;;;;:::i;:::-;;;;;;-1:-1:-1;28833:5:106;28857:11;;;;;:29;;;28872:6;:14;;28882:4;28872:14;28857:29;28853:832;;;28949:5;:15;;;28965:5;28949:22;;;;;;;;;:::i;:::-;;;;;;-1:-1:-1;;29012:4:106;29006:2;28998:10;;;28997:19;28853:832;;;29050:4;29041:6;:13;;;29037:648;;;29171:6;:13;;29181:3;29171:13;:30;;;;29188:6;:13;;29198:3;29188:13;29171:30;:47;;;;29205:6;:13;;29215:3;29205:13;29171:47;29167:253;;;29281:4;29288:6;29281:13;29276:18;;29037:648;;29167:253;29380:21;29383:4;29390:6;29383:13;29398:2;29380;:21::i;:::-;29375:26;;29037:648;;;29454:4;29444:6;:14;;;;:32;;;;29462:6;:14;;29472:4;29462:14;29444:32;:50;;;;29480:6;:14;;29490:4;29480:14;29444:50;29440:245;;;29564:5;:15;;;29580:5;29564:22;;;;;;;;;:::i;:::-;;;;;29559:27;;29665:5;29657:13;;29440:245;29714:1;29704:6;:11;;;;:25;;;;;29728:1;29719:6;:10;;;29704:25;29703:42;;;;29734:6;:11;;29744:1;29734:11;29703:42;29699:125;;;29772:37;29785:6;29793:4;29799:5;29806:2;29772:12;:37::i;:::-;29765:44;;;;;;;;;;;29699:125;29857:13;29838:16;30009:4;29999:14;;;;29995:446;;30078:21;30081:4;30088:6;30081:13;30096:2;30078;:21::i;:::-;30072:27;;;;30136:10;30131:15;;30170:16;30131:15;30184:1;30170:7;:16::i;:::-;30164:22;;30218:4;30208:6;:14;;;;:32;;;;;30226:6;:14;;30236:4;30226:14;;30208:32;30204:223;;;30305:4;30293:16;;30407:1;30399:9;;30204:223;30015:426;29995:446;30474:10;30487:26;30495:4;30501:2;30505;30509:3;30487:7;:26::i;:::-;30516:10;30487:39;;;;-1:-1:-1;30612:4:106;30605:11;;;30644;;;:24;;;;;30667:1;30659:4;:9;;;;30644:24;:39;;;;;30679:4;30672;:11;;;30644:39;30640:847;;;30707:4;:9;;30715:1;30707:9;:22;;;;30720:4;:9;;30728:1;30720:9;30707:22;30703:144;;;30791:37;30802:4;:9;;30810:1;30802:9;:21;;30818:5;30802:21;;;30814:1;30802:21;30825:2;30791:10;:37::i;:::-;30784:44;;;;;;;;;;;;;;;30703:144;30869:4;:11;;30877:3;30869:11;30865:121;;30939:28;30948:5;30955:2;30959:7;;;;30939:8;:28::i;30865:121::-;31007:4;:11;;31015:3;31007:11;31003:121;;31077:28;31086:5;31093:2;31097:7;;;;;31077:8;:28::i;31003:121::-;31194:4;:11;;31202:3;31194:11;31190:80;;31236:15;:13;:15::i;31190:80::-;31373:4;31365;:12;;;;:27;;;;;31388:4;31381;:11;;;31365:27;31361:112;;;31423:31;31434:4;31440:2;31444;31448:5;31423:10;:31::i;31361:112::-;31547:6;:14;;31557:4;31547:14;:28;;;;-1:-1:-1;31565:10:106;;;;;31547:28;31543:93;;;31620:1;31595:5;:15;;;31611:5;31595:22;;;;;;;;;:::i;:::-;:26;;;;:22;;;;;;:26;31543:93;31682:9;:26;;31695:13;31682:26;31678:92;;31728:27;31737:9;31748:1;31751:3;31728:8;:27::i;:::-;31851:26;31860:5;31867:3;31872:4;31851:8;:26::i;:::-;31844:33;;;;;;;;;;;;;25555:6339;;;;;;;:::o;3092:2334::-;3639:4;3633:11;;3555:4;3358:31;3347:43;;3418:13;3358:31;3757:2;3457:13;;3347:43;3364:24;3358:31;3457:13;;;3347:43;;;;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3418:13;4185:11;3364:24;3358:31;3457:13;;;3347:43;3418:13;4280:11;3364:24;3358:31;3457:13;;;3347:43;3364:24;3358:31;3457:13;;;3347:43;3133:12;;4420:13;;3633:11;;3457:13;;;;4185:11;3133:12;4500:84;4525:2;4522:1;4519:9;4500:84;;;3374:13;3364:24;;3358:31;3347:43;;3378:2;3418:13;;;;4580:1;3457:13;;;;4543:1;4536:9;4500:84;;;4504:14;4647:1;4643:2;4636:13;4742:5;4738:2;4734:14;4727:5;4722:27;4816:1;4802:15;;4837:6;4861:1;4856:273;;;;5196:1;5186:11;;4830:369;;4856:273;4888:8;4946:22;;;;5025:1;5020:22;;;;5112:1;5102:11;;4881:234;;4946:22;4965:1;4955:11;;4946:22;;5020;5039:1;5029:11;;4881:234;;4830:369;-1:-1:-1;;;5322:14:106;;;5305:32;;5365:19;5361:30;5397:3;5393:16;;;;5358:52;;3092:2334;-1:-1:-1;3092:2334:106:o;21610:1831::-;21683:11;21794:14;21811:24;21823:11;21811;:24::i;:::-;21794:41;;21943:1;21936:5;21932:13;21929:33;;;21958:1;21955;21948:12;21929:33;22091:2;22079:15;;;22032:20;22521:5;22518:1;22514:13;22556:4;22592:1;22577:343;22602:2;22599:1;22596:9;22577:343;;;22725:2;22713:15;;;22662:20;22760:12;;;22774:1;22756:20;22797:42;;;;22865:1;22860:42;;;;22749:153;;22797:42;22255:1;22248:12;;;22288:2;22281:13;;;22333:2;22320:16;;22806:31;;22797:42;;22860;22255:1;22248:12;;;22288:2;22281:13;;;22333:2;22320:16;;22869:31;;22749:153;-1:-1:-1;;22620:1:106;22613:9;22577:343;;;22581:14;23030:4;23024:11;23009:26;;23116:7;23110:4;23107:17;23097:124;;23158:10;23155:1;23148:21;23200:2;23197:1;23190:13;23097:124;-1:-1:-1;;23348:2:106;23337:14;;;;23325:10;23321:31;23318:1;23314:39;23382:16;;;;23400:10;23378:33;;21610:1831;-1:-1:-1;;;21610:1831:106:o;18720:823::-;18789:12;18876:18;;:::i;:::-;18944:4;18935:13;;18996:5;:8;;;19007:1;18996:12;18980:28;;:5;:12;;;:28;;;18976:95;;19028:28;;;;;2114:2:260;19028:28:106;;;2096:21:260;2153:2;2133:18;;;2126:30;2192:20;2172:18;;;2165:48;2230:18;;19028:28:106;;;;;;;;18976:95;19160:8;;;;;19193:12;;;;;19182:23;;;;;;;19219:20;;;;;19160:8;19351:13;;;19347:90;;19412:6;19421:1;19412:10;19384:5;:15;;;19400:8;19384:25;;;;;;;;;:::i;:::-;:38;;;;:25;;;;;;:38;19347:90;19513:13;:11;:13::i;:::-;19506:20;18720:823;-1:-1:-1;;;;;18720:823:106:o;2645:339::-;2706:11;2770:18;;;;2779:8;;;;2770:18;;;;;;2769:25;;;;;2786:1;2833:2;:9;;;2827:16;;;;;2826:22;;2825:32;;;;;;;2887:9;;2886:15;2769:25;2944:21;;2964:1;2944:21;;;2955:6;2944:21;2929:11;;;;;:37;;-1:-1:-1;;;2645:339:106;;;;:::o;13581:2026::-;13678:12;13764:18;;:::i;:::-;13832:4;13823:13;;13864:17;13924:5;:8;;;13935:1;13924:12;13908:28;;:5;:12;;;:28;;;13904:97;;13956:30;;;;;2461:2:260;13956:30:106;;;2443:21:260;2500:2;2480:18;;;2473:30;2539:22;2519:18;;;2512:50;2579:18;;13956:30:106;2259:344:260;13904:97:106;14071:7;:12;;14082:1;14071:12;:28;;;;14087:7;:12;;14098:1;14087:12;14071:28;14067:947;;;14119:9;14131:5;:15;;;14147:6;14131:23;;;;;;;;;:::i;:::-;;;;;14119:35;;14195:2;14188:9;;:3;:9;;;:25;;;;;14201:7;:12;;14212:1;14201:12;14188:25;14187:58;;;;14226:2;14219:9;;:3;:9;;;;:25;;;;;14232:7;:12;;14243:1;14232:12;14219:25;14172:73;;14101:159;14067:947;;;14357:7;:12;;14368:1;14357:12;14353:661;;14418:1;14410:3;14404:15;;;;14389:30;;14353:661;;;14522:7;:12;;14533:1;14522:12;14518:496;;14582:1;14575:3;14569:14;;;14554:29;;14518:496;;;14703:7;:12;;14714:1;14703:12;14699:315;;14791:4;14785:2;14776:11;;;14775:20;14761:10;14818:8;;;14814:84;;14878:1;14871:3;14865:14;;;14850:29;;14814:84;14919:3;:8;;14926:1;14919:8;14915:85;;14980:1;14972:3;14966:15;;;;14951:30;;14915:85;14717:297;14699:315;15090:8;;;;;15168:12;;;;15157:23;;;;;15324:178;;;;15415:1;15389:22;15392:5;15400:6;15392:14;15408:2;15389;:22::i;:::-;:27;;;;;;;15375:42;;15384:1;15375:42;15360:57;:12;;;:57;15324:178;;;15471:12;;;;;15486:1;15471:16;15456:31;;;;15324:178;15577:13;:11;:13::i;:::-;15570:20;13581:2026;-1:-1:-1;;;;;;;;13581:2026:106:o;31940:8733::-;32027:10;32089;32097:2;32089:10;;;;32128:11;;;:44;;;32154:1;32144:6;:11;;;;:27;;;;;32168:3;32159:6;:12;;;32144:27;32124:8490;;;32213:4;32206:11;;32337:6;32397:3;32392:25;;;;32472:3;32467:25;;;;32546:3;32541:25;;;;32621:3;32616:25;;;;32695:3;32690:25;;;;32768:3;32763:25;;;;32842:3;32837:25;;;;32330:532;;32392:25;32411:4;32403:12;;32392:25;;32467;32486:4;32478:12;;32467:25;;32541;32560:4;32552:12;;32541:25;;32616;32635:4;32627:12;;32616:25;;32690;32709:4;32701:12;;32690:25;;32763;32782:4;32774:12;;32763:25;;32837;32856:4;32848:12;;32330:532;;32925:4;:12;;32933:4;32925:12;32921:4023;;-1:-1:-1;;;32976:9:106;32968:26;;32989:4;32984:1;32976:9;;;32975:18;32968:26;32961:33;;32921:4023;33062:4;:12;;33070:4;33062:12;33058:3886;;-1:-1:-1;;;33113:9:106;33105:26;;33126:4;33121:1;33113:9;;;33112:18;33105:26;33098:33;;33058:3886;33199:4;:12;;33207:4;33199:12;33195:3749;;33264:4;33259:1;33251:9;;;33250:18;33297:27;33251:9;33300:11;;;;33313:2;:10;;;33297:2;:27::i;:::-;33290:34;;;;;;;33195:3749;33393:4;:12;;33401:4;33393:12;33389:3555;;-1:-1:-1;;;33436:17:106;;;33448:4;33443:9;;33436:17;33429:24;;33389:3555;33522:4;:11;;33530:3;33522:11;33518:3426;;-1:-1:-1;;;33564:17:106;;;33576:4;33571:9;;33564:17;33557:24;;33518:3426;33650:4;:12;;33658:4;33650:12;33646:3298;;33693:21;33702:2;33696:8;;:2;:8;;;;33711:2;33706;:7;33693:2;:21::i;:::-;33686:28;;;;;;33646:3298;33963:4;:12;;33971:4;33963:12;33959:2985;;34006:2;33999:9;;;;;;33959:2985;34077:4;:12;;34085:4;34077:12;34073:2871;;34120:2;34113:9;;;;;;34073:2871;34191:4;:12;;34199:4;34191:12;34187:2757;;34234:2;34227:9;;;;;;34187:2757;34305:4;:12;;34313:4;34305:12;34301:2643;;34348:2;34341:9;;;;;;34301:2643;34422:4;:12;;34430:4;34422:12;34418:2526;;34465:2;34458:9;;;;;;34418:2526;34582:4;:12;;34590:4;34582:12;34578:2366;;34625:2;34618:9;;;;;;34578:2366;34696:4;:12;;34704:4;34696:12;34692:2252;;34739:2;34732:9;;;;;;34692:2252;34810:4;:12;;34818:4;34810:12;34806:2138;;34853:2;34846:9;;;;;;34806:2138;34924:4;:12;;34932:4;34924:12;34920:2024;;34967:2;34960:9;;;;;;34920:2024;35038:4;:12;;35046:4;35038:12;35034:1910;;35081:2;35074:9;;;;;;35034:1910;35152:4;:12;;35160:4;35152:12;35148:1796;;35195:2;35188:9;;;;;;35148:1796;35267:4;:12;;35275:4;35267:12;35263:1681;;35310:2;35303:9;;;;;;35263:1681;35380:4;:12;;35388:4;35380:12;35376:1568;;35423:2;35416:9;;;;;;35376:1568;35494:4;:12;;35502:4;35494:12;35490:1454;;35537:2;35530:9;;;;;;35490:1454;35686:4;:12;;35694:4;35686:12;35682:1262;;-1:-1:-1;;;35730:7:106;;;35722:16;;35682:1262;35807:4;:12;;35815:4;35807:12;35803:1141;;-1:-1:-1;;;35851:7:106;;;35843:16;;35803:1141;35927:4;:12;;35935:4;35927:12;35923:1021;;-1:-1:-1;;;35971:7:106;;;35963:16;;35923:1021;36048:4;:12;;36056:4;36048:12;36044:900;;-1:-1:-1;;;36092:7:106;;;36084:16;;36044:900;36168:4;:12;;36176:4;36168:12;36164:780;;-1:-1:-1;;;36212:7:106;;;36204:16;;36164:780;36287:4;:12;;36295:4;36287:12;36283:661;;-1:-1:-1;;;36331:7:106;;;36323:16;;36283:661;36407:4;:12;;36415:4;36407:12;36403:541;;-1:-1:-1;;;36451:7:106;;;36443:16;;36403:541;36527:4;:12;;36535:4;36527:12;36523:421;;-1:-1:-1;;;36572:7:106;;;36570:10;36563:17;;36523:421;36649:4;:12;;36657:4;36649:12;36645:299;;36710:2;36692:21;;36698:2;36692:21;;;:29;;36720:1;36692:29;;;36716:1;36692:29;36685:36;;;;;;;;36645:299;36791:4;:12;;36799:4;36791:12;36787:157;;36839:2;36834:7;;:2;:7;;;:15;;36848:1;36834:15;;36787:157;36896:29;;;;;2810:2:260;36896:29:106;;;2792:21:260;2849:2;2829:18;;;2822:30;2888:21;2868:18;;;2861:49;2927:18;;36896:29:106;2608:343:260;36787:157:106;32174:4784;32124:8490;;;37014:6;:14;;37024:4;37014:14;37010:3590;;37073:4;37066:11;;37148:3;37140:11;;;37136:549;;-1:-1:-1;;;37193:21:106;;;37179:36;;37136:549;37300:4;:12;;37308:4;37300:12;:28;;;;37316:4;:12;;37324:4;37316:12;37300:28;37296:389;;;37360:4;:12;;37368:4;37360:12;37356:83;;37409:3;;;37356:83;37464:8;37502:127;37514:10;37509:15;;:20;37502:127;;37594:8;37561:3;37594:8;;;;;37561:3;37502:127;;;37661:1;-1:-1:-1;37654:8:106;;-1:-1:-1;;37654:8:106;37010:3590;37752:6;:14;;37762:4;37752:14;37748:2852;;-1:-1:-1;;37797:8:106;37803:2;37797:8;;;;37790:15;;37748:2852;37872:6;:14;;37882:4;37872:14;37868:2732;;37917:42;37935:2;37940:1;37935:6;37945:1;37934:12;37929:2;:17;37921:26;;:3;:26;;;;37951:4;37920:35;37957:1;37917:2;:42::i;37868:2732::-;38026:6;:14;;38036:4;38026:14;38022:2578;;38071:45;38089:2;38094:1;38089:6;38099:1;38088:12;38083:2;:17;38075:26;;:3;:26;;;;38105:6;38074:37;38113:2;38071;:45::i;38022:2578::-;38184:6;:14;;38194:4;38184:14;38180:2420;;-1:-1:-1;;38235:21:106;38254:1;38249;38244:6;;38243:12;38235:21;;38292:36;;;38363:5;38358:10;;38235:21;;;;;38357:18;38350:25;;38180:2420;38442:6;:14;;38452:4;38442:14;38438:2162;;38487:3;38480:10;;;;;38438:2162;38558:6;:14;;38568:4;38558:14;38554:2046;;38618:2;38623:1;38618:6;38628:1;38617:12;38612:2;:17;38604:26;;:3;:26;;;;38634:4;38603:35;38596:42;;;;;38554:2046;38707:6;:14;;38717:4;38707:14;38703:1897;;38767:2;38772:1;38767:6;38777:1;38766:12;38761:2;:17;38753:26;;:3;:26;;;;38783:6;38752:37;38745:44;;;;;38703:1897;38858:6;:14;;38868:4;38858:14;38854:1746;;-1:-1:-1;;38909:26:106;38933:1;38928;38923:6;;38922:12;38917:2;:17;38909:26;;38971:41;;;39047:5;39042:10;;38909:26;;;;;39041:18;39034:25;;38854:1746;39127:6;:14;;39137:4;39127:14;39123:1477;;-1:-1:-1;;39184:4:106;39178:34;39210:1;39205;39200:6;;39199:12;39194:2;:17;39178:34;;39268:27;;;39248:48;;;39326:10;;39179:9;;;39178:34;;39325:18;39318:25;;39123:1477;39411:6;:14;;39421:4;39411:14;39407:1193;;-1:-1:-1;;39468:6:106;39462:36;39496:1;39491;39486:6;;39485:12;39480:2;:17;39462:36;;39554:29;;;39534:50;;;39614:10;;39463:11;;;39462:36;;39613:18;39606:25;;39407:1193;39700:6;:14;;39710:4;39700:14;39696:904;;-1:-1:-1;;39751:20:106;39769:1;39764;39759:6;;39758:12;39751:20;;39807:36;;;39879:5;39873:11;;39751:20;;;;;39872:19;39865:26;;39696:904;39959:6;:14;;39969:4;39959:14;39955:645;;40004:2;39997:9;;;;;39955:645;40075:6;:14;;40085:4;40075:14;40071:529;;-1:-1:-1;;40126:25:106;40149:1;40144;40139:6;;40138:12;40133:2;:17;40126:25;;40187:41;;;40264:5;40258:11;;40126:25;;;;;40257:19;40250:26;;40071:529;40343:6;:14;;40353:4;40343:14;40339:261;;40388:3;40381:10;;;;;40339:261;40458:6;:14;;40468:4;40458:14;40454:146;;40503:2;40496:9;;;;;19824:782;19910:12;19997:18;;:::i;:::-;-1:-1:-1;20065:4:106;20172:2;20160:14;;;;20152:41;;;;;;;3158:2:260;20152:41:106;;;3140:21:260;3197:2;3177:18;;;3170:30;3236:16;3216:18;;;3209:44;3270:18;;20152:41:106;2956:338:260;20152:41:106;20289:14;;;;;;;:30;;;20307:12;20289:30;20285:102;;;20368:4;20339:5;:15;;;20355:9;20339:26;;;;;;;;;:::i;:::-;:33;;;;:26;;;;;;:33;20285:102;20442:12;;;;;20431:23;;;;:8;;;:23;20498:1;20483:16;;;20468:31;;;20576:13;:11;:13::i;5467:7728::-;5510:12;5596:18;;:::i;:::-;-1:-1:-1;5774:15:106;;:18;;;;5664:4;5934:18;;;;5978;;;;6022;;;;;5664:4;;5754:17;;;;5934:18;5978;6112;;;6126:4;6112:18;6108:6777;;6162:2;6191:4;6186:9;;:14;6182:144;;6302:4;6297:9;;6289:4;:18;6283:24;6182:144;6347:2;:7;;6353:1;6347:7;6343:161;;6383:10;;;;;6415:16;;;;;;;;6383:10;-1:-1:-1;6343:161:106;;;6483:2;6478:7;;6343:161;6132:386;6108:6777;;;6620:10;:18;;6634:4;6620:18;6616:6269;;1745:10;6658:14;;6616:6269;;;6756:10;:18;;6770:4;6756:18;6752:6133;;6799:1;6794:6;;6752:6133;;;6924:10;:18;;6938:4;6924:18;6920:5965;;6977:4;6962:12;;;:19;6999:26;;;:14;;;:26;7050:13;:11;:13::i;:::-;7043:20;;;;;;;;;5467:7728;:::o;6920:5965::-;7189:10;:18;;7203:4;7189:18;7185:5700;;7340:14;;;7336:2708;7185:5700;7336:2708;7510:22;;;;;7506:2538;;7635:10;7648:27;7656:2;7661:10;7656:15;7673:1;7648:7;:27::i;:::-;7759:17;;;;7635:40;;-1:-1:-1;7759:17:106;7737:19;7909:14;7928:1;7903:26;7899:131;;7971:36;7995:11;1277:21:107;1426:15;;;1467:8;1461:4;1454:22;1595:4;1582:18;;1602:19;1578:44;1624:11;1575:61;;1222:430;7971:36:106;7957:50;;7899:131;8116:20;;;;;8083:54;;;;;;;;3472:25:260;;;8083:54:106;3533:23:260;;;3513:18;;;3506:51;8052:11:106;;;;8083:19;:6;:19;;;;3445:18:260;;8083:54:106;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;8051:86;;;;8364:1;8360:2;8356:10;8461:9;8458:1;8454:17;8543:6;8536:5;8533:17;8530:40;;;8563:5;8553:15;;8530:40;;8646:6;8642:2;8639:14;8636:34;;;8666:2;8656:12;;8636:34;8772:3;8767:1;8759:6;8755:14;8750:3;8746:24;8742:34;8735:41;;8872:3;8868:1;8856:9;8847:6;8844:1;8840:14;8836:30;8832:38;8828:48;8821:55;;9027:1;9023;9019;9007:9;9004:1;9000:17;8996:25;8992:33;8988:41;9154:1;9150;9146;9137:6;9125:9;9122:1;9118:17;9114:30;9110:38;9106:46;9102:54;9084:72;;9285:10;9281:15;9275:4;9271:26;9263:34;;9401:3;9393:4;9389:9;9384:3;9380:19;9377:28;9370:35;;;;9547:33;9556:2;9561:10;9556:15;9573:1;9576:3;9547:8;:33::i;:::-;9602:20;;;:38;;;;;;;;;-1:-1:-1;7506:2538:106;;-1:-1:-1;;;7506:2538:106;;9759:18;;;;;9755:289;;9929:2;9924:7;;7185:5700;;9755:289;9983:10;9978:15;;2053:3;10015:10;;9755:289;7185:5700;;;10173:10;:18;;10187:4;10173:18;10169:2716;;10327:15;;;1824:1;10327:15;;:34;;-1:-1:-1;10346:15:106;;;1859:1;10346:15;10327:34;:57;;;-1:-1:-1;10365:19:106;;;1936:1;10365:19;10327:57;10323:1593;;;10413:2;10408:7;;10169:2716;;10323:1593;10539:23;;;;;10535:1381;;10586:10;10599:27;10607:2;10612:10;10607:15;10624:1;10599:7;:27::i;:::-;10702:17;;;;10586:40;;-1:-1:-1;10945:1:106;10937:10;;11039:1;11035:17;11114:13;;;11111:32;;;11136:5;11130:11;;11111:32;11422:14;;;11228:1;11418:22;;;11414:32;;;;11311:26;11335:1;11220:10;;;11315:18;;;11311:26;11410:43;11216:20;;11518:12;11646:17;;;:23;11714:1;11691:20;;;:24;11224:2;-1:-1:-1;11224:2:106;7185:5700;;10169:2716;12118:10;:18;;12132:4;12118:18;12114:771;;12228:2;:7;;12234:1;12228:7;12224:647;;12321:14;;;;;:40;;-1:-1:-1;12339:22:106;;;1978:1;12339:22;12321:40;:62;;;-1:-1:-1;12365:18:106;;;1897:1;12365:18;12321:62;12317:404;;;12416:1;12411:6;;12224:647;;12317:404;12462:15;;;1824:1;12462:15;;:34;;-1:-1:-1;12481:15:106;;;1859:1;12481:15;12462:34;:61;;;-1:-1:-1;12500:23:106;;;2021:1;12500:23;12462:61;:84;;;-1:-1:-1;12527:19:106;;;1936:1;12527:19;12462:84;12458:263;;;12579:1;12574:6;;7185:5700;;12224:647;12772:10;12767:15;;2087:4;12804:11;;12224:647;12960:15;;;;;:23;;;;:18;;;;:23;;;;12997:15;;:23;;;:18;;;;:23;-1:-1:-1;13086:12:106;;;;13075:23;;;:8;;;:23;13142:1;13127:16;13112:31;;;;;13165:13;:11;:13::i;15948:2480::-;16042:12;16128:18;;:::i;:::-;-1:-1:-1;16196:4:106;16228:10;16336:13;;;16345:4;16336:13;16332:1705;;-1:-1:-1;16375:8:106;;;;16332:1705;;;16494:5;:13;;16503:4;16494:13;16490:1547;;16527:14;;;:8;;;:14;16490:1547;;;16657:5;:13;;16666:4;16657:13;16653:1384;;-1:-1:-1;16696:8:106;;;;16653:1384;;;16815:5;:13;;16824:4;16815:13;16811:1226;;16848:14;;;:8;;;:14;16811:1226;;;16989:5;:13;;16998:4;16989:13;16985:1052;;17116:9;17062:17;17042;;;17062;;;;17042:37;17123:2;17116:9;;;;;17098:8;;;:28;17144:22;:8;;;:22;16985:1052;;;17303:5;:13;;17312:4;17303:13;17299:738;;17370:11;17356;;;17370;;;17356:25;17425:2;17418:9;;;;;17400:8;;;:28;17446:22;:8;;;:22;17299:738;;;17627:5;:13;;17636:4;17627:13;17623:414;;17697:3;17678:23;;17684:3;17678:23;;;;;;;:::i;:::-;;17660:42;;:8;;;:42;17738:23;;;;;;;;;;;;;:::i;:::-;;17720:42;;:8;;;:42;17623:414;;;17931:5;:13;;17940:4;17931:13;17927:110;;17981:3;17975:9;;:3;:9;;;;;;;:::i;:::-;;17964:20;;;;:8;;;:20;18013:9;;;;;;;;;;;:::i;:::-;;18002:20;;:8;;;:20;17927:110;18130:14;;;;18126:85;;18193:3;18164:5;:15;;;18180:9;18164:26;;;;;;;;;:::i;:::-;:32;;;;:26;;;;;;:32;18126:85;18265:12;;;;;18254:23;;;;:8;;;:23;18321:1;18306:16;;;18291:31;;;18398:13;:11;:13::i;:::-;18391:20;15948:2480;-1:-1:-1;;;;;;;15948:2480:106:o;23777:1654::-;23953:14;23970:24;23982:11;23970;:24::i;:::-;23953:41;;24102:1;24095:5;24091:13;24088:33;;;24117:1;24114;24107:12;24088:33;24256:2;24450:15;;;24275:2;24264:14;;24252:10;24248:31;24245:1;24241:39;24406:16;;;24191:20;;24391:10;24380:22;;;24376:27;24366:38;24363:60;24892:5;24889:1;24885:13;24963:1;24948:343;24973:2;24970:1;24967:9;24948:343;;;25096:2;25084:15;;;25033:20;25131:12;;;25145:1;25127:20;25168:42;;;;25236:1;25231:42;;;;25120:153;;25168:42;22255:1;22248:12;;;22288:2;22281:13;;;22333:2;22320:16;;25177:31;;25168:42;;25231;22255:1;22248:12;;;22288:2;22281:13;;;22333:2;22320:16;;25240:31;;25120:153;-1:-1:-1;;24991:1:106;24984:9;24948:343;;;-1:-1:-1;;25390:4:106;25383:18;-1:-1:-1;;;;23777:1654:106:o;20810:586::-;21132:20;;;21156:7;21132:32;21125:3;:40;;;21238:14;;21293:17;;21287:24;;;21279:72;;;;;;;4209:2:260;21279:72:106;;;4191:21:260;4248:2;4228:18;;;4221:30;4287:34;4267:18;;;4260:62;4358:5;4338:18;;;4331:33;4381:19;;21279:72:106;4007:399:260;21279:72:106;21365:14;20810:586;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;467:347:260:-;518:8;528:6;582:3;575:4;567:6;563:17;559:27;549:55;;600:1;597;590:12;549:55;-1:-1:-1;623:20:260;;666:18;655:30;;652:50;;;698:1;695;688:12;652:50;735:4;727:6;723:17;711:29;;787:3;780:4;771:6;763;759:19;755:30;752:39;749:59;;;804:1;801;794:12;749:59;467:347;;;;;:::o;819:717::-;909:6;917;925;933;986:2;974:9;965:7;961:23;957:32;954:52;;;1002:1;999;992:12;954:52;1042:9;1029:23;1071:18;1112:2;1104:6;1101:14;1098:34;;;1128:1;1125;1118:12;1098:34;1167:58;1217:7;1208:6;1197:9;1193:22;1167:58;:::i;:::-;1244:8;;-1:-1:-1;1141:84:260;-1:-1:-1;1332:2:260;1317:18;;1304:32;;-1:-1:-1;1348:16:260;;;1345:36;;;1377:1;1374;1367:12;1345:36;;1416:60;1468:7;1457:8;1446:9;1442:24;1416:60;:::i;:::-;819:717;;;;-1:-1:-1;1495:8:260;-1:-1:-1;;;;819:717:260:o;1723:184::-;1775:77;1772:1;1765:88;1872:4;1869:1;1862:15;1896:4;1893:1;1886:15;3568:245;3647:6;3655;3708:2;3696:9;3687:7;3683:23;3679:32;3676:52;;;3724:1;3721;3714:12;3676:52;-1:-1:-1;;3747:16:260;;3803:2;3788:18;;;3782:25;3747:16;;3782:25;;-1:-1:-1;3568:245:260:o;3818:184::-;3870:77;3867:1;3860:88;3967:4;3964:1;3957:15;3991:4;3988:1;3981:15"
 
 func init() {
 	if err := json.Unmarshal([]byte(MIPSStorageLayoutJSON), MIPSStorageLayout); err != nil {

op-bindings/bindings/preimageoracle_more.go

@@ -15,7 +15,7 @@ var PreimageOracleStorageLayout = new(solc.StorageLayout)
 
 var PreimageOracleDeployedBin = "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"
 
-var PreimageOracleDeployedSourceMap = "306:4436:107:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;537:68;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;413:25:258;;;401:2;386:18;537:68:107;;;;;;;;680:66;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;614:14:258;;607:22;589:41;;577:2;562:18;680:66:107;449:187:258;1938:1165:107;;;;;;:::i;:::-;;:::i;789:536::-;;;;;;:::i;:::-;;:::i;:::-;;;;1205:25:258;;;1261:2;1246:18;;1239:34;;;;1178:18;789:536:107;1031:248:258;3145:1595:107;;;;;;:::i;:::-;;:::i;:::-;;1672:224;;;;;;:::i;:::-;1767:19;;;;:14;:19;;;;;;;;:31;;;;;;;;:38;;;;1801:4;1767:38;;;;;;1815:18;;;;;;;;:30;;;;;;;;;:37;;;;1862:20;;;;;;;;;;:27;1672:224;419:50;;;;;;:::i;:::-;;;;;;;;;;;;;;;1938:1165;2100:12;2205:36;2234:6;2205:28;:36::i;:::-;2198:43;-1:-1:-1;2335:9:107;:5;2343:1;2335:9;:::i;:::-;2321:11;:23;:37;;;;2356:2;2348:5;:10;2321:37;2317:90;;;2381:15;;;;;;;;;;;;;;2317:90;2476:12;2576:4;2569:18;;;2677:3;2673:15;;;2660:29;;2709:4;2702:19;;;;2811:18;;2901:20;;;:14;:20;;;;;;:33;;;;;;;;:40;;;;2937:4;2901:40;;;;;;2951:19;;;;;;;;:32;;;;;;;;;:39;3067:21;;;;;;;;;:29;2916:4;1938:1165;-1:-1:-1;1938:1165:107:o;789:536::-;865:12;914:20;;;:14;:20;;;;;;;;:29;;;;;;;;;865:12;;914:29;;906:62;;;;;;;3229:2:258;906:62:107;;;3211:21:258;3268:2;3248:18;;;3241:30;3307:22;3287:18;;;3280:50;3347:18;;906:62:107;;;;;;;;-1:-1:-1;1099:14:107;1116:21;;;1087:2;1116:21;;;;;;;;1167:10;1116:21;1176:1;1167:10;:::i;:::-;1151:12;:7;1161:2;1151:12;:::i;:::-;:26;1147:87;;1216:7;1203:10;:6;1212:1;1203:10;:::i;:::-;:20;;;;:::i;:::-;1193:30;;1147:87;-1:-1:-1;1290:19:107;;;;:13;:19;;;;;;;;:28;;;;;;;;;;;;789:536;;-1:-1:-1;789:536:107:o;3145:1595::-;3441:4;3428:18;3246:12;;3570:1;3560:12;;3544:29;;3541:210;;;3645:10;3642:1;3635:21;3735:1;3729:4;3722:15;3541:210;3994:3;3990:14;;;3894:4;3978:27;4025:11;3999:4;4144:16;4025:11;4126:41;4357:29;;;4361:11;4357:29;4351:36;4409:20;;;;4556:19;4549:27;4578:11;4546:44;4609:19;;;;4587:1;4609:19;;;;;;;;:32;;;;;;;;:39;;;;4644:4;4609:39;;;;;;4658:18;;;;;;;;:31;;;;;;;;;:38;;;;4706:20;;;;;;;;;;;:27;;;;-1:-1:-1;;;;3145:1595:107:o;492:353:106:-;752:11;777:19;765:32;;749:49;824:14;749:49;1277:21;1426:15;;;1467:8;1461:4;1454:22;1595:4;1582:18;;1602:19;1578:44;1624:11;1575:61;;1222:430;824:14;817:21;492:353;-1:-1:-1;;492:353:106:o;14:248:258:-;82:6;90;143:2;131:9;122:7;118:23;114:32;111:52;;;159:1;156;149:12;111:52;-1:-1:-1;;182:23:258;;;252:2;237:18;;;224:32;;-1:-1:-1;14:248:258:o;641:385::-;727:6;735;743;751;804:3;792:9;783:7;779:23;775:33;772:53;;;821:1;818;811:12;772:53;-1:-1:-1;;844:23:258;;;914:2;899:18;;886:32;;-1:-1:-1;965:2:258;950:18;;937:32;;1016:2;1001:18;988:32;;-1:-1:-1;641:385:258;-1:-1:-1;641:385:258:o;1284:659::-;1363:6;1371;1379;1432:2;1420:9;1411:7;1407:23;1403:32;1400:52;;;1448:1;1445;1438:12;1400:52;1484:9;1471:23;1461:33;;1545:2;1534:9;1530:18;1517:32;1568:18;1609:2;1601:6;1598:14;1595:34;;;1625:1;1622;1615:12;1595:34;1663:6;1652:9;1648:22;1638:32;;1708:7;1701:4;1697:2;1693:13;1689:27;1679:55;;1730:1;1727;1720:12;1679:55;1770:2;1757:16;1796:2;1788:6;1785:14;1782:34;;;1812:1;1809;1802:12;1782:34;1857:7;1852:2;1843:6;1839:2;1835:15;1831:24;1828:37;1825:57;;;1878:1;1875;1868:12;1825:57;1909:2;1905;1901:11;1891:21;;1931:6;1921:16;;;;;1284:659;;;;;:::o;2338:180::-;2397:6;2450:2;2438:9;2429:7;2425:23;2421:32;2418:52;;;2466:1;2463;2456:12;2418:52;-1:-1:-1;2489:23:258;;2338:180;-1:-1:-1;2338:180:258:o;2705:184::-;2757:77;2754:1;2747:88;2854:4;2851:1;2844:15;2878:4;2875:1;2868:15;2894:128;2934:3;2965:1;2961:6;2958:1;2955:13;2952:39;;;2971:18;;:::i;:::-;-1:-1:-1;3007:9:258;;2894:128::o;3376:125::-;3416:4;3444:1;3441;3438:8;3435:34;;;3449:18;;:::i;:::-;-1:-1:-1;3486:9:258;;3376:125::o"
+var PreimageOracleDeployedSourceMap = "306:4436:108:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;537:68;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;413:25:260;;;401:2;386:18;537:68:108;;;;;;;;680:66;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;614:14:260;;607:22;589:41;;577:2;562:18;680:66:108;449:187:260;1938:1165:108;;;;;;:::i;:::-;;:::i;789:536::-;;;;;;:::i;:::-;;:::i;:::-;;;;1205:25:260;;;1261:2;1246:18;;1239:34;;;;1178:18;789:536:108;1031:248:260;3145:1595:108;;;;;;:::i;:::-;;:::i;:::-;;1672:224;;;;;;:::i;:::-;1767:19;;;;:14;:19;;;;;;;;:31;;;;;;;;:38;;;;1801:4;1767:38;;;;;;1815:18;;;;;;;;:30;;;;;;;;;:37;;;;1862:20;;;;;;;;;;:27;1672:224;419:50;;;;;;:::i;:::-;;;;;;;;;;;;;;;1938:1165;2100:12;2205:36;2234:6;2205:28;:36::i;:::-;2198:43;-1:-1:-1;2335:9:108;:5;2343:1;2335:9;:::i;:::-;2321:11;:23;:37;;;;2356:2;2348:5;:10;2321:37;2317:90;;;2381:15;;;;;;;;;;;;;;2317:90;2476:12;2576:4;2569:18;;;2677:3;2673:15;;;2660:29;;2709:4;2702:19;;;;2811:18;;2901:20;;;:14;:20;;;;;;:33;;;;;;;;:40;;;;2937:4;2901:40;;;;;;2951:19;;;;;;;;:32;;;;;;;;;:39;3067:21;;;;;;;;;:29;2916:4;1938:1165;-1:-1:-1;1938:1165:108:o;789:536::-;865:12;914:20;;;:14;:20;;;;;;;;:29;;;;;;;;;865:12;;914:29;;906:62;;;;;;;3229:2:260;906:62:108;;;3211:21:260;3268:2;3248:18;;;3241:30;3307:22;3287:18;;;3280:50;3347:18;;906:62:108;;;;;;;;-1:-1:-1;1099:14:108;1116:21;;;1087:2;1116:21;;;;;;;;1167:10;1116:21;1176:1;1167:10;:::i;:::-;1151:12;:7;1161:2;1151:12;:::i;:::-;:26;1147:87;;1216:7;1203:10;:6;1212:1;1203:10;:::i;:::-;:20;;;;:::i;:::-;1193:30;;1147:87;-1:-1:-1;1290:19:108;;;;:13;:19;;;;;;;;:28;;;;;;;;;;;;789:536;;-1:-1:-1;789:536:108:o;3145:1595::-;3441:4;3428:18;3246:12;;3570:1;3560:12;;3544:29;;3541:210;;;3645:10;3642:1;3635:21;3735:1;3729:4;3722:15;3541:210;3994:3;3990:14;;;3894:4;3978:27;4025:11;3999:4;4144:16;4025:11;4126:41;4357:29;;;4361:11;4357:29;4351:36;4409:20;;;;4556:19;4549:27;4578:11;4546:44;4609:19;;;;4587:1;4609:19;;;;;;;;:32;;;;;;;;:39;;;;4644:4;4609:39;;;;;;4658:18;;;;;;;;:31;;;;;;;;;:38;;;;4706:20;;;;;;;;;;;:27;;;;-1:-1:-1;;;;3145:1595:108:o;492:353:107:-;752:11;777:19;765:32;;749:49;824:14;749:49;1277:21;1426:15;;;1467:8;1461:4;1454:22;1595:4;1582:18;;1602:19;1578:44;1624:11;1575:61;;1222:430;824:14;817:21;492:353;-1:-1:-1;;492:353:107:o;14:248:260:-;82:6;90;143:2;131:9;122:7;118:23;114:32;111:52;;;159:1;156;149:12;111:52;-1:-1:-1;;182:23:260;;;252:2;237:18;;;224:32;;-1:-1:-1;14:248:260:o;641:385::-;727:6;735;743;751;804:3;792:9;783:7;779:23;775:33;772:53;;;821:1;818;811:12;772:53;-1:-1:-1;;844:23:260;;;914:2;899:18;;886:32;;-1:-1:-1;965:2:260;950:18;;937:32;;1016:2;1001:18;988:32;;-1:-1:-1;641:385:260;-1:-1:-1;641:385:260:o;1284:659::-;1363:6;1371;1379;1432:2;1420:9;1411:7;1407:23;1403:32;1400:52;;;1448:1;1445;1438:12;1400:52;1484:9;1471:23;1461:33;;1545:2;1534:9;1530:18;1517:32;1568:18;1609:2;1601:6;1598:14;1595:34;;;1625:1;1622;1615:12;1595:34;1663:6;1652:9;1648:22;1638:32;;1708:7;1701:4;1697:2;1693:13;1689:27;1679:55;;1730:1;1727;1720:12;1679:55;1770:2;1757:16;1796:2;1788:6;1785:14;1782:34;;;1812:1;1809;1802:12;1782:34;1857:7;1852:2;1843:6;1839:2;1835:15;1831:24;1828:37;1825:57;;;1878:1;1875;1868:12;1825:57;1909:2;1905;1901:11;1891:21;;1931:6;1921:16;;;;;1284:659;;;;;:::o;2338:180::-;2397:6;2450:2;2438:9;2429:7;2425:23;2421:32;2418:52;;;2466:1;2463;2456:12;2418:52;-1:-1:-1;2489:23:260;;2338:180;-1:-1:-1;2338:180:260:o;2705:184::-;2757:77;2754:1;2747:88;2854:4;2851:1;2844:15;2878:4;2875:1;2868:15;2894:128;2934:3;2965:1;2961:6;2958:1;2955:13;2952:39;;;2971:18;;:::i;:::-;-1:-1:-1;3007:9:260;;2894:128::o;3376:125::-;3416:4;3444:1;3441;3438:8;3435:34;;;3449:18;;:::i;:::-;-1:-1:-1;3486:9:260;;3376:125::o"
 
 func init() {
 	if err := json.Unmarshal([]byte(PreimageOracleStorageLayoutJSON), PreimageOracleStorageLayout); err != nil {

op-bindings/bindings/protocolversions.go

+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package bindings
+
+import (
+	"errors"
+	"math/big"
+	"strings"
+
+	ethereum "github.com/ethereum/go-ethereum"
+	"github.com/ethereum/go-ethereum/accounts/abi"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
+	"github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var (
+	_ = errors.New
+	_ = big.NewInt
+	_ = strings.NewReader
+	_ = ethereum.NotFound
+	_ = bind.Bind
+	_ = common.Big1
+	_ = types.BloomLookup
+	_ = event.NewSubscription
+)
+
+// ProtocolVersionsMetaData contains all meta data concerning the ProtocolVersions contract.
+var ProtocolVersionsMetaData = &bind.MetaData{
+	ABI: "[{\"inputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"version\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"enumProtocolVersions.UpdateType\",\"name\":\"updateType\",\"type\":\"uint8\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"ConfigUpdate\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"uint8\",\"name\":\"version\",\"type\":\"uint8\"}],\"name\":\"Initialized\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"RECOMMENDED_SLOT\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"REQUIRED_SLOT\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"VERSION\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"ProtocolVersion\",\"name\":\"_required\",\"type\":\"uint256\"},{\"internalType\":\"ProtocolVersion\",\"name\":\"_recommended\",\"type\":\"uint256\"}],\"name\":\"initialize\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"recommended\",\"outputs\":[{\"internalType\":\"ProtocolVersion\",\"name\":\"out_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"required\",\"outputs\":[{\"internalType\":\"ProtocolVersion\",\"name\":\"out_\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"ProtocolVersion\",\"name\":\"_recommended\",\"type\":\"uint256\"}],\"name\":\"setRecommended\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"ProtocolVersion\",\"name\":\"_required\",\"type\":\"uint256\"}],\"name\":\"setRequired\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"version\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"}]",
+	Bin: "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",
+}
+
+// ProtocolVersionsABI is the input ABI used to generate the binding from.
+// Deprecated: Use ProtocolVersionsMetaData.ABI instead.
+var ProtocolVersionsABI = ProtocolVersionsMetaData.ABI
+
+// ProtocolVersionsBin is the compiled bytecode used for deploying new contracts.
+// Deprecated: Use ProtocolVersionsMetaData.Bin instead.
+var ProtocolVersionsBin = ProtocolVersionsMetaData.Bin
+
+// DeployProtocolVersions deploys a new Ethereum contract, binding an instance of ProtocolVersions to it.
+func DeployProtocolVersions(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ProtocolVersions, error) {
+	parsed, err := ProtocolVersionsMetaData.GetAbi()
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	if parsed == nil {
+		return common.Address{}, nil, nil, errors.New("GetABI returned nil")
+	}
+
+	address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ProtocolVersionsBin), backend)
+	if err != nil {
+		return common.Address{}, nil, nil, err
+	}
+	return address, tx, &ProtocolVersions{ProtocolVersionsCaller: ProtocolVersionsCaller{contract: contract}, ProtocolVersionsTransactor: ProtocolVersionsTransactor{contract: contract}, ProtocolVersionsFilterer: ProtocolVersionsFilterer{contract: contract}}, nil
+}
+
+// ProtocolVersions is an auto generated Go binding around an Ethereum contract.
+type ProtocolVersions struct {
+	ProtocolVersionsCaller     // Read-only binding to the contract
+	ProtocolVersionsTransactor // Write-only binding to the contract
+	ProtocolVersionsFilterer   // Log filterer for contract events
+}
+
+// ProtocolVersionsCaller is an auto generated read-only Go binding around an Ethereum contract.
+type ProtocolVersionsCaller struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ProtocolVersionsTransactor is an auto generated write-only Go binding around an Ethereum contract.
+type ProtocolVersionsTransactor struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ProtocolVersionsFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
+type ProtocolVersionsFilterer struct {
+	contract *bind.BoundContract // Generic contract wrapper for the low level calls
+}
+
+// ProtocolVersionsSession is an auto generated Go binding around an Ethereum contract,
+// with pre-set call and transact options.
+type ProtocolVersionsSession struct {
+	Contract     *ProtocolVersions // Generic contract binding to set the session for
+	CallOpts     bind.CallOpts     // Call options to use throughout this session
+	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
+}
+
+// ProtocolVersionsCallerSession is an auto generated read-only Go binding around an Ethereum contract,
+// with pre-set call options.
+type ProtocolVersionsCallerSession struct {
+	Contract *ProtocolVersionsCaller // Generic contract caller binding to set the session for
+	CallOpts bind.CallOpts           // Call options to use throughout this session
+}
+
+// ProtocolVersionsTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
+// with pre-set transact options.
+type ProtocolVersionsTransactorSession struct {
+	Contract     *ProtocolVersionsTransactor // Generic contract transactor binding to set the session for
+	TransactOpts bind.TransactOpts           // Transaction auth options to use throughout this session
+}
+
+// ProtocolVersionsRaw is an auto generated low-level Go binding around an Ethereum contract.
+type ProtocolVersionsRaw struct {
+	Contract *ProtocolVersions // Generic contract binding to access the raw methods on
+}
+
+// ProtocolVersionsCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
+type ProtocolVersionsCallerRaw struct {
+	Contract *ProtocolVersionsCaller // Generic read-only contract binding to access the raw methods on
+}
+
+// ProtocolVersionsTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
+type ProtocolVersionsTransactorRaw struct {
+	Contract *ProtocolVersionsTransactor // Generic write-only contract binding to access the raw methods on
+}
+
+// NewProtocolVersions creates a new instance of ProtocolVersions, bound to a specific deployed contract.
+func NewProtocolVersions(address common.Address, backend bind.ContractBackend) (*ProtocolVersions, error) {
+	contract, err := bindProtocolVersions(address, backend, backend, backend)
+	if err != nil {
+		return nil, err
+	}
+	return &ProtocolVersions{ProtocolVersionsCaller: ProtocolVersionsCaller{contract: contract}, ProtocolVersionsTransactor: ProtocolVersionsTransactor{contract: contract}, ProtocolVersionsFilterer: ProtocolVersionsFilterer{contract: contract}}, nil
+}
+
+// NewProtocolVersionsCaller creates a new read-only instance of ProtocolVersions, bound to a specific deployed contract.
+func NewProtocolVersionsCaller(address common.Address, caller bind.ContractCaller) (*ProtocolVersionsCaller, error) {
+	contract, err := bindProtocolVersions(address, caller, nil, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ProtocolVersionsCaller{contract: contract}, nil
+}
+
+// NewProtocolVersionsTransactor creates a new write-only instance of ProtocolVersions, bound to a specific deployed contract.
+func NewProtocolVersionsTransactor(address common.Address, transactor bind.ContractTransactor) (*ProtocolVersionsTransactor, error) {
+	contract, err := bindProtocolVersions(address, nil, transactor, nil)
+	if err != nil {
+		return nil, err
+	}
+	return &ProtocolVersionsTransactor{contract: contract}, nil
+}
+
+// NewProtocolVersionsFilterer creates a new log filterer instance of ProtocolVersions, bound to a specific deployed contract.
+func NewProtocolVersionsFilterer(address common.Address, filterer bind.ContractFilterer) (*ProtocolVersionsFilterer, error) {
+	contract, err := bindProtocolVersions(address, nil, nil, filterer)
+	if err != nil {
+		return nil, err
+	}
+	return &ProtocolVersionsFilterer{contract: contract}, nil
+}
+
+// bindProtocolVersions binds a generic wrapper to an already deployed contract.
+func bindProtocolVersions(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
+	parsed, err := abi.JSON(strings.NewReader(ProtocolVersionsABI))
+	if err != nil {
+		return nil, err
+	}
+	return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_ProtocolVersions *ProtocolVersionsRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ProtocolVersions.Contract.ProtocolVersionsCaller.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_ProtocolVersions *ProtocolVersionsRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.ProtocolVersionsTransactor.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ProtocolVersions *ProtocolVersionsRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.ProtocolVersionsTransactor.contract.Transact(opts, method, params...)
+}
+
+// Call invokes the (constant) contract method with params as input values and
+// sets the output to result. The result type might be a single field for simple
+// returns, a slice of interfaces for anonymous returns and a struct for named
+// returns.
+func (_ProtocolVersions *ProtocolVersionsCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
+	return _ProtocolVersions.Contract.contract.Call(opts, result, method, params...)
+}
+
+// Transfer initiates a plain transaction to move funds to the contract, calling
+// its default method if one is available.
+func (_ProtocolVersions *ProtocolVersionsTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.contract.Transfer(opts)
+}
+
+// Transact invokes the (paid) contract method with params as input values.
+func (_ProtocolVersions *ProtocolVersionsTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.contract.Transact(opts, method, params...)
+}
+
+// RECOMMENDEDSLOT is a free data retrieval call binding the contract method 0xf7d12760.
+//
+// Solidity: function RECOMMENDED_SLOT() view returns(bytes32)
+func (_ProtocolVersions *ProtocolVersionsCaller) RECOMMENDEDSLOT(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _ProtocolVersions.contract.Call(opts, &out, "RECOMMENDED_SLOT")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// RECOMMENDEDSLOT is a free data retrieval call binding the contract method 0xf7d12760.
+//
+// Solidity: function RECOMMENDED_SLOT() view returns(bytes32)
+func (_ProtocolVersions *ProtocolVersionsSession) RECOMMENDEDSLOT() ([32]byte, error) {
+	return _ProtocolVersions.Contract.RECOMMENDEDSLOT(&_ProtocolVersions.CallOpts)
+}
+
+// RECOMMENDEDSLOT is a free data retrieval call binding the contract method 0xf7d12760.
+//
+// Solidity: function RECOMMENDED_SLOT() view returns(bytes32)
+func (_ProtocolVersions *ProtocolVersionsCallerSession) RECOMMENDEDSLOT() ([32]byte, error) {
+	return _ProtocolVersions.Contract.RECOMMENDEDSLOT(&_ProtocolVersions.CallOpts)
+}
+
+// REQUIREDSLOT is a free data retrieval call binding the contract method 0x206a8300.
+//
+// Solidity: function REQUIRED_SLOT() view returns(bytes32)
+func (_ProtocolVersions *ProtocolVersionsCaller) REQUIREDSLOT(opts *bind.CallOpts) ([32]byte, error) {
+	var out []interface{}
+	err := _ProtocolVersions.contract.Call(opts, &out, "REQUIRED_SLOT")
+
+	if err != nil {
+		return *new([32]byte), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte)
+
+	return out0, err
+
+}
+
+// REQUIREDSLOT is a free data retrieval call binding the contract method 0x206a8300.
+//
+// Solidity: function REQUIRED_SLOT() view returns(bytes32)
+func (_ProtocolVersions *ProtocolVersionsSession) REQUIREDSLOT() ([32]byte, error) {
+	return _ProtocolVersions.Contract.REQUIREDSLOT(&_ProtocolVersions.CallOpts)
+}
+
+// REQUIREDSLOT is a free data retrieval call binding the contract method 0x206a8300.
+//
+// Solidity: function REQUIRED_SLOT() view returns(bytes32)
+func (_ProtocolVersions *ProtocolVersionsCallerSession) REQUIREDSLOT() ([32]byte, error) {
+	return _ProtocolVersions.Contract.REQUIREDSLOT(&_ProtocolVersions.CallOpts)
+}
+
+// VERSION is a free data retrieval call binding the contract method 0xffa1ad74.
+//
+// Solidity: function VERSION() view returns(uint256)
+func (_ProtocolVersions *ProtocolVersionsCaller) VERSION(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _ProtocolVersions.contract.Call(opts, &out, "VERSION")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// VERSION is a free data retrieval call binding the contract method 0xffa1ad74.
+//
+// Solidity: function VERSION() view returns(uint256)
+func (_ProtocolVersions *ProtocolVersionsSession) VERSION() (*big.Int, error) {
+	return _ProtocolVersions.Contract.VERSION(&_ProtocolVersions.CallOpts)
+}
+
+// VERSION is a free data retrieval call binding the contract method 0xffa1ad74.
+//
+// Solidity: function VERSION() view returns(uint256)
+func (_ProtocolVersions *ProtocolVersionsCallerSession) VERSION() (*big.Int, error) {
+	return _ProtocolVersions.Contract.VERSION(&_ProtocolVersions.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_ProtocolVersions *ProtocolVersionsCaller) Owner(opts *bind.CallOpts) (common.Address, error) {
+	var out []interface{}
+	err := _ProtocolVersions.contract.Call(opts, &out, "owner")
+
+	if err != nil {
+		return *new(common.Address), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address)
+
+	return out0, err
+
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_ProtocolVersions *ProtocolVersionsSession) Owner() (common.Address, error) {
+	return _ProtocolVersions.Contract.Owner(&_ProtocolVersions.CallOpts)
+}
+
+// Owner is a free data retrieval call binding the contract method 0x8da5cb5b.
+//
+// Solidity: function owner() view returns(address)
+func (_ProtocolVersions *ProtocolVersionsCallerSession) Owner() (common.Address, error) {
+	return _ProtocolVersions.Contract.Owner(&_ProtocolVersions.CallOpts)
+}
+
+// Recommended is a free data retrieval call binding the contract method 0xd798b1ac.
+//
+// Solidity: function recommended() view returns(uint256 out_)
+func (_ProtocolVersions *ProtocolVersionsCaller) Recommended(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _ProtocolVersions.contract.Call(opts, &out, "recommended")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// Recommended is a free data retrieval call binding the contract method 0xd798b1ac.
+//
+// Solidity: function recommended() view returns(uint256 out_)
+func (_ProtocolVersions *ProtocolVersionsSession) Recommended() (*big.Int, error) {
+	return _ProtocolVersions.Contract.Recommended(&_ProtocolVersions.CallOpts)
+}
+
+// Recommended is a free data retrieval call binding the contract method 0xd798b1ac.
+//
+// Solidity: function recommended() view returns(uint256 out_)
+func (_ProtocolVersions *ProtocolVersionsCallerSession) Recommended() (*big.Int, error) {
+	return _ProtocolVersions.Contract.Recommended(&_ProtocolVersions.CallOpts)
+}
+
+// Required is a free data retrieval call binding the contract method 0xdc8452cd.
+//
+// Solidity: function required() view returns(uint256 out_)
+func (_ProtocolVersions *ProtocolVersionsCaller) Required(opts *bind.CallOpts) (*big.Int, error) {
+	var out []interface{}
+	err := _ProtocolVersions.contract.Call(opts, &out, "required")
+
+	if err != nil {
+		return *new(*big.Int), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int)
+
+	return out0, err
+
+}
+
+// Required is a free data retrieval call binding the contract method 0xdc8452cd.
+//
+// Solidity: function required() view returns(uint256 out_)
+func (_ProtocolVersions *ProtocolVersionsSession) Required() (*big.Int, error) {
+	return _ProtocolVersions.Contract.Required(&_ProtocolVersions.CallOpts)
+}
+
+// Required is a free data retrieval call binding the contract method 0xdc8452cd.
+//
+// Solidity: function required() view returns(uint256 out_)
+func (_ProtocolVersions *ProtocolVersionsCallerSession) Required() (*big.Int, error) {
+	return _ProtocolVersions.Contract.Required(&_ProtocolVersions.CallOpts)
+}
+
+// Version is a free data retrieval call binding the contract method 0x54fd4d50.
+//
+// Solidity: function version() view returns(string)
+func (_ProtocolVersions *ProtocolVersionsCaller) Version(opts *bind.CallOpts) (string, error) {
+	var out []interface{}
+	err := _ProtocolVersions.contract.Call(opts, &out, "version")
+
+	if err != nil {
+		return *new(string), err
+	}
+
+	out0 := *abi.ConvertType(out[0], new(string)).(*string)
+
+	return out0, err
+
+}
+
+// Version is a free data retrieval call binding the contract method 0x54fd4d50.
+//
+// Solidity: function version() view returns(string)
+func (_ProtocolVersions *ProtocolVersionsSession) Version() (string, error) {
+	return _ProtocolVersions.Contract.Version(&_ProtocolVersions.CallOpts)
+}
+
+// Version is a free data retrieval call binding the contract method 0x54fd4d50.
+//
+// Solidity: function version() view returns(string)
+func (_ProtocolVersions *ProtocolVersionsCallerSession) Version() (string, error) {
+	return _ProtocolVersions.Contract.Version(&_ProtocolVersions.CallOpts)
+}
+
+// Initialize is a paid mutator transaction binding the contract method 0x7a1ac61e.
+//
+// Solidity: function initialize(address _owner, uint256 _required, uint256 _recommended) returns()
+func (_ProtocolVersions *ProtocolVersionsTransactor) Initialize(opts *bind.TransactOpts, _owner common.Address, _required *big.Int, _recommended *big.Int) (*types.Transaction, error) {
+	return _ProtocolVersions.contract.Transact(opts, "initialize", _owner, _required, _recommended)
+}
+
+// Initialize is a paid mutator transaction binding the contract method 0x7a1ac61e.
+//
+// Solidity: function initialize(address _owner, uint256 _required, uint256 _recommended) returns()
+func (_ProtocolVersions *ProtocolVersionsSession) Initialize(_owner common.Address, _required *big.Int, _recommended *big.Int) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.Initialize(&_ProtocolVersions.TransactOpts, _owner, _required, _recommended)
+}
+
+// Initialize is a paid mutator transaction binding the contract method 0x7a1ac61e.
+//
+// Solidity: function initialize(address _owner, uint256 _required, uint256 _recommended) returns()
+func (_ProtocolVersions *ProtocolVersionsTransactorSession) Initialize(_owner common.Address, _required *big.Int, _recommended *big.Int) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.Initialize(&_ProtocolVersions.TransactOpts, _owner, _required, _recommended)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_ProtocolVersions *ProtocolVersionsTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) {
+	return _ProtocolVersions.contract.Transact(opts, "renounceOwnership")
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_ProtocolVersions *ProtocolVersionsSession) RenounceOwnership() (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.RenounceOwnership(&_ProtocolVersions.TransactOpts)
+}
+
+// RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6.
+//
+// Solidity: function renounceOwnership() returns()
+func (_ProtocolVersions *ProtocolVersionsTransactorSession) RenounceOwnership() (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.RenounceOwnership(&_ProtocolVersions.TransactOpts)
+}
+
+// SetRecommended is a paid mutator transaction binding the contract method 0x5fd579af.
+//
+// Solidity: function setRecommended(uint256 _recommended) returns()
+func (_ProtocolVersions *ProtocolVersionsTransactor) SetRecommended(opts *bind.TransactOpts, _recommended *big.Int) (*types.Transaction, error) {
+	return _ProtocolVersions.contract.Transact(opts, "setRecommended", _recommended)
+}
+
+// SetRecommended is a paid mutator transaction binding the contract method 0x5fd579af.
+//
+// Solidity: function setRecommended(uint256 _recommended) returns()
+func (_ProtocolVersions *ProtocolVersionsSession) SetRecommended(_recommended *big.Int) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.SetRecommended(&_ProtocolVersions.TransactOpts, _recommended)
+}
+
+// SetRecommended is a paid mutator transaction binding the contract method 0x5fd579af.
+//
+// Solidity: function setRecommended(uint256 _recommended) returns()
+func (_ProtocolVersions *ProtocolVersionsTransactorSession) SetRecommended(_recommended *big.Int) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.SetRecommended(&_ProtocolVersions.TransactOpts, _recommended)
+}
+
+// SetRequired is a paid mutator transaction binding the contract method 0x0457d6f2.
+//
+// Solidity: function setRequired(uint256 _required) returns()
+func (_ProtocolVersions *ProtocolVersionsTransactor) SetRequired(opts *bind.TransactOpts, _required *big.Int) (*types.Transaction, error) {
+	return _ProtocolVersions.contract.Transact(opts, "setRequired", _required)
+}
+
+// SetRequired is a paid mutator transaction binding the contract method 0x0457d6f2.
+//
+// Solidity: function setRequired(uint256 _required) returns()
+func (_ProtocolVersions *ProtocolVersionsSession) SetRequired(_required *big.Int) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.SetRequired(&_ProtocolVersions.TransactOpts, _required)
+}
+
+// SetRequired is a paid mutator transaction binding the contract method 0x0457d6f2.
+//
+// Solidity: function setRequired(uint256 _required) returns()
+func (_ProtocolVersions *ProtocolVersionsTransactorSession) SetRequired(_required *big.Int) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.SetRequired(&_ProtocolVersions.TransactOpts, _required)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_ProtocolVersions *ProtocolVersionsTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) {
+	return _ProtocolVersions.contract.Transact(opts, "transferOwnership", newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_ProtocolVersions *ProtocolVersionsSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.TransferOwnership(&_ProtocolVersions.TransactOpts, newOwner)
+}
+
+// TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b.
+//
+// Solidity: function transferOwnership(address newOwner) returns()
+func (_ProtocolVersions *ProtocolVersionsTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) {
+	return _ProtocolVersions.Contract.TransferOwnership(&_ProtocolVersions.TransactOpts, newOwner)
+}
+
+// ProtocolVersionsConfigUpdateIterator is returned from FilterConfigUpdate and is used to iterate over the raw logs and unpacked data for ConfigUpdate events raised by the ProtocolVersions contract.
+type ProtocolVersionsConfigUpdateIterator struct {
+	Event *ProtocolVersionsConfigUpdate // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *ProtocolVersionsConfigUpdateIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(ProtocolVersionsConfigUpdate)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(ProtocolVersionsConfigUpdate)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *ProtocolVersionsConfigUpdateIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *ProtocolVersionsConfigUpdateIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// ProtocolVersionsConfigUpdate represents a ConfigUpdate event raised by the ProtocolVersions contract.
+type ProtocolVersionsConfigUpdate struct {
+	Version    *big.Int
+	UpdateType uint8
+	Data       []byte
+	Raw        types.Log // Blockchain specific contextual infos
+}
+
+// FilterConfigUpdate is a free log retrieval operation binding the contract event 0x1d2b0bda21d56b8bd12d4f94ebacffdfb35f5e226f84b461103bb8beab6353be.
+//
+// Solidity: event ConfigUpdate(uint256 indexed version, uint8 indexed updateType, bytes data)
+func (_ProtocolVersions *ProtocolVersionsFilterer) FilterConfigUpdate(opts *bind.FilterOpts, version []*big.Int, updateType []uint8) (*ProtocolVersionsConfigUpdateIterator, error) {
+
+	var versionRule []interface{}
+	for _, versionItem := range version {
+		versionRule = append(versionRule, versionItem)
+	}
+	var updateTypeRule []interface{}
+	for _, updateTypeItem := range updateType {
+		updateTypeRule = append(updateTypeRule, updateTypeItem)
+	}
+
+	logs, sub, err := _ProtocolVersions.contract.FilterLogs(opts, "ConfigUpdate", versionRule, updateTypeRule)
+	if err != nil {
+		return nil, err
+	}
+	return &ProtocolVersionsConfigUpdateIterator{contract: _ProtocolVersions.contract, event: "ConfigUpdate", logs: logs, sub: sub}, nil
+}
+
+// WatchConfigUpdate is a free log subscription operation binding the contract event 0x1d2b0bda21d56b8bd12d4f94ebacffdfb35f5e226f84b461103bb8beab6353be.
+//
+// Solidity: event ConfigUpdate(uint256 indexed version, uint8 indexed updateType, bytes data)
+func (_ProtocolVersions *ProtocolVersionsFilterer) WatchConfigUpdate(opts *bind.WatchOpts, sink chan<- *ProtocolVersionsConfigUpdate, version []*big.Int, updateType []uint8) (event.Subscription, error) {
+
+	var versionRule []interface{}
+	for _, versionItem := range version {
+		versionRule = append(versionRule, versionItem)
+	}
+	var updateTypeRule []interface{}
+	for _, updateTypeItem := range updateType {
+		updateTypeRule = append(updateTypeRule, updateTypeItem)
+	}
+
+	logs, sub, err := _ProtocolVersions.contract.WatchLogs(opts, "ConfigUpdate", versionRule, updateTypeRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(ProtocolVersionsConfigUpdate)
+				if err := _ProtocolVersions.contract.UnpackLog(event, "ConfigUpdate", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// ParseConfigUpdate is a log parse operation binding the contract event 0x1d2b0bda21d56b8bd12d4f94ebacffdfb35f5e226f84b461103bb8beab6353be.
+//
+// Solidity: event ConfigUpdate(uint256 indexed version, uint8 indexed updateType, bytes data)
+func (_ProtocolVersions *ProtocolVersionsFilterer) ParseConfigUpdate(log types.Log) (*ProtocolVersionsConfigUpdate, error) {
+	event := new(ProtocolVersionsConfigUpdate)
+	if err := _ProtocolVersions.contract.UnpackLog(event, "ConfigUpdate", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// ProtocolVersionsInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ProtocolVersions contract.
+type ProtocolVersionsInitializedIterator struct {
+	Event *ProtocolVersionsInitialized // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *ProtocolVersionsInitializedIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(ProtocolVersionsInitialized)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(ProtocolVersionsInitialized)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *ProtocolVersionsInitializedIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *ProtocolVersionsInitializedIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// ProtocolVersionsInitialized represents a Initialized event raised by the ProtocolVersions contract.
+type ProtocolVersionsInitialized struct {
+	Version uint8
+	Raw     types.Log // Blockchain specific contextual infos
+}
+
+// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498.
+//
+// Solidity: event Initialized(uint8 version)
+func (_ProtocolVersions *ProtocolVersionsFilterer) FilterInitialized(opts *bind.FilterOpts) (*ProtocolVersionsInitializedIterator, error) {
+
+	logs, sub, err := _ProtocolVersions.contract.FilterLogs(opts, "Initialized")
+	if err != nil {
+		return nil, err
+	}
+	return &ProtocolVersionsInitializedIterator{contract: _ProtocolVersions.contract, event: "Initialized", logs: logs, sub: sub}, nil
+}
+
+// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498.
+//
+// Solidity: event Initialized(uint8 version)
+func (_ProtocolVersions *ProtocolVersionsFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ProtocolVersionsInitialized) (event.Subscription, error) {
+
+	logs, sub, err := _ProtocolVersions.contract.WatchLogs(opts, "Initialized")
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(ProtocolVersionsInitialized)
+				if err := _ProtocolVersions.contract.UnpackLog(event, "Initialized", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498.
+//
+// Solidity: event Initialized(uint8 version)
+func (_ProtocolVersions *ProtocolVersionsFilterer) ParseInitialized(log types.Log) (*ProtocolVersionsInitialized, error) {
+	event := new(ProtocolVersionsInitialized)
+	if err := _ProtocolVersions.contract.UnpackLog(event, "Initialized", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}
+
+// ProtocolVersionsOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the ProtocolVersions contract.
+type ProtocolVersionsOwnershipTransferredIterator struct {
+	Event *ProtocolVersionsOwnershipTransferred // Event containing the contract specifics and raw log
+
+	contract *bind.BoundContract // Generic contract to use for unpacking event data
+	event    string              // Event name to use for unpacking event data
+
+	logs chan types.Log        // Log channel receiving the found contract events
+	sub  ethereum.Subscription // Subscription for errors, completion and termination
+	done bool                  // Whether the subscription completed delivering logs
+	fail error                 // Occurred error to stop iteration
+}
+
+// Next advances the iterator to the subsequent event, returning whether there
+// are any more events found. In case of a retrieval or parsing error, false is
+// returned and Error() can be queried for the exact failure.
+func (it *ProtocolVersionsOwnershipTransferredIterator) Next() bool {
+	// If the iterator failed, stop iterating
+	if it.fail != nil {
+		return false
+	}
+	// If the iterator completed, deliver directly whatever's available
+	if it.done {
+		select {
+		case log := <-it.logs:
+			it.Event = new(ProtocolVersionsOwnershipTransferred)
+			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+				it.fail = err
+				return false
+			}
+			it.Event.Raw = log
+			return true
+
+		default:
+			return false
+		}
+	}
+	// Iterator still in progress, wait for either a data or an error event
+	select {
+	case log := <-it.logs:
+		it.Event = new(ProtocolVersionsOwnershipTransferred)
+		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
+			it.fail = err
+			return false
+		}
+		it.Event.Raw = log
+		return true
+
+	case err := <-it.sub.Err():
+		it.done = true
+		it.fail = err
+		return it.Next()
+	}
+}
+
+// Error returns any retrieval or parsing error occurred during filtering.
+func (it *ProtocolVersionsOwnershipTransferredIterator) Error() error {
+	return it.fail
+}
+
+// Close terminates the iteration process, releasing any pending underlying
+// resources.
+func (it *ProtocolVersionsOwnershipTransferredIterator) Close() error {
+	it.sub.Unsubscribe()
+	return nil
+}
+
+// ProtocolVersionsOwnershipTransferred represents a OwnershipTransferred event raised by the ProtocolVersions contract.
+type ProtocolVersionsOwnershipTransferred struct {
+	PreviousOwner common.Address
+	NewOwner      common.Address
+	Raw           types.Log // Blockchain specific contextual infos
+}
+
+// FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
+//
+// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
+func (_ProtocolVersions *ProtocolVersionsFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*ProtocolVersionsOwnershipTransferredIterator, error) {
+
+	var previousOwnerRule []interface{}
+	for _, previousOwnerItem := range previousOwner {
+		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
+	}
+	var newOwnerRule []interface{}
+	for _, newOwnerItem := range newOwner {
+		newOwnerRule = append(newOwnerRule, newOwnerItem)
+	}
+
+	logs, sub, err := _ProtocolVersions.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return &ProtocolVersionsOwnershipTransferredIterator{contract: _ProtocolVersions.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil
+}
+
+// WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
+//
+// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
+func (_ProtocolVersions *ProtocolVersionsFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *ProtocolVersionsOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) {
+
+	var previousOwnerRule []interface{}
+	for _, previousOwnerItem := range previousOwner {
+		previousOwnerRule = append(previousOwnerRule, previousOwnerItem)
+	}
+	var newOwnerRule []interface{}
+	for _, newOwnerItem := range newOwner {
+		newOwnerRule = append(newOwnerRule, newOwnerItem)
+	}
+
+	logs, sub, err := _ProtocolVersions.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule)
+	if err != nil {
+		return nil, err
+	}
+	return event.NewSubscription(func(quit <-chan struct{}) error {
+		defer sub.Unsubscribe()
+		for {
+			select {
+			case log := <-logs:
+				// New log arrived, parse the event and forward to the user
+				event := new(ProtocolVersionsOwnershipTransferred)
+				if err := _ProtocolVersions.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+					return err
+				}
+				event.Raw = log
+
+				select {
+				case sink <- event:
+				case err := <-sub.Err():
+					return err
+				case <-quit:
+					return nil
+				}
+			case err := <-sub.Err():
+				return err
+			case <-quit:
+				return nil
+			}
+		}
+	}), nil
+}
+
+// ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0.
+//
+// Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)
+func (_ProtocolVersions *ProtocolVersionsFilterer) ParseOwnershipTransferred(log types.Log) (*ProtocolVersionsOwnershipTransferred, error) {
+	event := new(ProtocolVersionsOwnershipTransferred)
+	if err := _ProtocolVersions.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil {
+		return nil, err
+	}
+	event.Raw = log
+	return event, nil
+}

op-bindings/bindings/protocolversions_more.go

+// Code generated - DO NOT EDIT.
+// This file is a generated binding and any manual changes will be lost.
+
+package bindings
+
+import (
+	"encoding/json"
+
+	"github.com/ethereum-optimism/optimism/op-bindings/solc"
+)
+
+const ProtocolVersionsStorageLayoutJSON = "{\"storage\":[{\"astId\":1000,\"contract\":\"src/L1/ProtocolVersions.sol:ProtocolVersions\",\"label\":\"_initialized\",\"offset\":0,\"slot\":\"0\",\"type\":\"t_uint8\"},{\"astId\":1001,\"contract\":\"src/L1/ProtocolVersions.sol:ProtocolVersions\",\"label\":\"_initializing\",\"offset\":1,\"slot\":\"0\",\"type\":\"t_bool\"},{\"astId\":1002,\"contract\":\"src/L1/ProtocolVersions.sol:ProtocolVersions\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"1\",\"type\":\"t_array(t_uint256)50_storage\"},{\"astId\":1003,\"contract\":\"src/L1/ProtocolVersions.sol:ProtocolVersions\",\"label\":\"_owner\",\"offset\":0,\"slot\":\"51\",\"type\":\"t_address\"},{\"astId\":1004,\"contract\":\"src/L1/ProtocolVersions.sol:ProtocolVersions\",\"label\":\"__gap\",\"offset\":0,\"slot\":\"52\",\"type\":\"t_array(t_uint256)49_storage\"}],\"types\":{\"t_address\":{\"encoding\":\"inplace\",\"label\":\"address\",\"numberOfBytes\":\"20\"},\"t_array(t_uint256)49_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[49]\",\"numberOfBytes\":\"1568\",\"base\":\"t_uint256\"},\"t_array(t_uint256)50_storage\":{\"encoding\":\"inplace\",\"label\":\"uint256[50]\",\"numberOfBytes\":\"1600\",\"base\":\"t_uint256\"},\"t_bool\":{\"encoding\":\"inplace\",\"label\":\"bool\",\"numberOfBytes\":\"1\"},\"t_uint256\":{\"encoding\":\"inplace\",\"label\":\"uint256\",\"numberOfBytes\":\"32\"},\"t_uint8\":{\"encoding\":\"inplace\",\"label\":\"uint8\",\"numberOfBytes\":\"1\"}}}"
+
+var ProtocolVersionsStorageLayout = new(solc.StorageLayout)
+
+var ProtocolVersionsDeployedBin = "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"
+
+func init() {
+	if err := json.Unmarshal([]byte(ProtocolVersionsStorageLayoutJSON), ProtocolVersionsStorageLayout); err != nil {
+		panic(err)
+	}
+
+	layouts["ProtocolVersions"] = ProtocolVersionsStorageLayout
+	deployedBytecodes["ProtocolVersions"] = ProtocolVersionsDeployedBin
+}

op-chain-ops/genesis/config.go

@@ -8,7 +8,6 @@ import (
 	"math/big"
 	"os"
 	"path/filepath"
-
 	"reflect"
 
 	"github.com/ethereum/go-ethereum/common"
@@ -16,6 +15,7 @@ import (
 	gstate "github.com/ethereum/go-ethereum/core/state"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/rpc"
 
 	"github.com/ethereum-optimism/optimism/op-bindings/hardhat"
@@ -198,6 +198,12 @@ type DeployConfig struct {
 	// FundDevAccounts configures whether or not to fund the dev accounts. Should only be used
 	// during devnet deployments.
 	FundDevAccounts bool `json:"fundDevAccounts"`
+	// RequiredProtocolVersion indicates the protocol version that
+	// nodes are required to adopt, to stay in sync with the network.
+	RequiredProtocolVersion params.ProtocolVersion `json:"requiredProtocolVersion"`
+	// RequiredProtocolVersion indicates the protocol version that
+	// nodes are recommended to adopt, to stay in sync with the network.
+	RecommendedProtocolVersion params.ProtocolVersion `json:"recommendedProtocolVersion"`
 }
 
 // Copy will deeply copy the DeployConfig. This does a JSON roundtrip to copy
@@ -522,6 +528,8 @@ type L1Deployments struct {
 	ProxyAdmin                        common.Address `json:"ProxyAdmin"`
 	SystemConfig                      common.Address `json:"SystemConfig"`
 	SystemConfigProxy                 common.Address `json:"SystemConfigProxy"`
+	ProtocolVersions                  common.Address `json:"ProtocolVersions"`
+	ProtocolVersionsProxy             common.Address `json:"ProtocolVersionsProxy"`
 }
 
 // GetName will return the name of the contract given an address.

op-chain-ops/genesis/config_test.go

@@ -89,6 +89,8 @@ func TestL1Deployments(t *testing.T) {
 	require.NotEqual(t, deployments.ProxyAdmin, common.Address{})
 	require.NotEqual(t, deployments.SystemConfig, common.Address{})
 	require.NotEqual(t, deployments.SystemConfigProxy, common.Address{})
+	require.NotEqual(t, deployments.ProtocolVersions, common.Address{})
+	require.NotEqual(t, deployments.ProtocolVersionsProxy, common.Address{})
 
 	require.Equal(t, "AddressManager", deployments.GetName(deployments.AddressManager))
 	require.Equal(t, "OptimismPortalProxy", deployments.GetName(deployments.OptimismPortalProxy))

op-chain-ops/genesis/testdata/l1-deployments.json

@@ -16,5 +16,7 @@
   "OptimismPortalProxy": "0xaC425EECd4Fd8E9E669a62906D99aF89B9951516",
   "ProxyAdmin": "0x3218c3b0dC0386BAe83A58E5F908c4b070210b4F",
   "SystemConfig": "0x36bAcDD96F28e1ac0780bB9CbE6e20780840730F",
-  "SystemConfigProxy": "0x14065A373936533A0c88b7986CADabDD62d471e6"
+  "SystemConfigProxy": "0x14065A373936533A0c88b7986CADabDD62d471e6",
+  "ProtocolVersions": "0x883C06a27D76B1CEbdf7EB376f5556c355afC8e5",
+  "ProtocolVersionsProxy": "0x3732a4D4Ab006cA4825822baEA1569A107683fa1"
 }

op-chain-ops/genesis/testdata/test-deploy-config-full.json

@@ -67,5 +67,7 @@
   "faultGameAbsolutePrestate": "0x0000000000000000000000000000000000000000000000000000000000000000",
   "faultGameMaxDepth": 63,
   "faultGameMaxDuration": 604800,
-  "systemConfigStartBlock": 0
+  "systemConfigStartBlock": 0,
+  "requiredProtocolVersion": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "recommendedProtocolVersion": "0x0000000000000000000000000000000000000000000000000000000000000000"
 }

op-challenger/cmd/main_test.go

@@ -169,6 +169,26 @@ func TestMaxConcurrency(t *testing.T) {
 	})
 }
 
+func TestPollInterval(t *testing.T) {
+	t.Run("UsesDefault", func(t *testing.T) {
+		cfg := configForArgs(t, addRequiredArgs(config.TraceTypeCannon))
+		require.Equal(t, config.DefaultPollInterval, cfg.PollInterval)
+	})
+
+	t.Run("Valid", func(t *testing.T) {
+		expected := 100 * time.Second
+		cfg := configForArgs(t, addRequiredArgs(config.TraceTypeAlphabet, "--http-poll-interval", "100s"))
+		require.Equal(t, expected, cfg.PollInterval)
+	})
+
+	t.Run("Invalid", func(t *testing.T) {
+		verifyArgsInvalid(
+			t,
+			"invalid value \"abc\" for flag -http-poll-interval",
+			addRequiredArgs(config.TraceTypeAlphabet, "--http-poll-interval", "abc"))
+	})
+}
+
 func TestCannonBin(t *testing.T) {
 	t.Run("NotRequiredForAlphabetTrace", func(t *testing.T) {
 		configForArgs(t, addRequiredArgsExcept(config.TraceTypeAlphabet, "--cannon-bin"))

op-challenger/config/config.go

@@ -78,6 +78,7 @@ func ValidTraceType(value TraceType) bool {
 }
 
 const (
+	DefaultPollInterval       = time.Second * 12
 	DefaultCannonSnapshotFreq = uint(1_000_000_000)
 	DefaultCannonInfoFreq     = uint(10_000_000)
 	// DefaultGameWindow is the default maximum time duration in the past
@@ -98,6 +99,7 @@ type Config struct {
 	AgreeWithProposedOutput bool             // Temporary config if we agree or disagree with the posted output
 	Datadir                 string           // Data Directory
 	MaxConcurrency          uint             // Maximum number of threads to use when progressing games
+	PollInterval            time.Duration    // Polling interval for latest-block subscription when using an HTTP RPC provider
 
 	TraceType TraceType // Type of trace
 
@@ -131,6 +133,7 @@ func NewConfig(
 		L1EthRpc:           l1EthRpc,
 		GameFactoryAddress: gameFactoryAddress,
 		MaxConcurrency:     uint(runtime.NumCPU()),
+		PollInterval:       DefaultPollInterval,
 
 		AgreeWithProposedOutput: agreeWithProposedOutput,
 

op-challenger/config/config_test.go

@@ -118,6 +118,13 @@ func TestMaxConcurrency(t *testing.T) {
 	})
 }
 
+func TestHttpPollInterval(t *testing.T) {
+	t.Run("Default", func(t *testing.T) {
+		config := validConfig(TraceTypeAlphabet)
+		require.EqualValues(t, DefaultPollInterval, config.PollInterval)
+	})
+}
+
 func TestCannonL2Required(t *testing.T) {
 	config := validConfig(TraceTypeCannon)
 	config.CannonL2 = ""

op-challenger/flags/flags.go

@@ -70,6 +70,12 @@ var (
 		EnvVars: prefixEnvVars("MAX_CONCURRENCY"),
 		Value:   uint(runtime.NumCPU()),
 	}
+	HTTPPollInterval = &cli.DurationFlag{
+		Name:    "http-poll-interval",
+		Usage:   "Polling interval for latest-block subscription when using an HTTP RPC provider.",
+		EnvVars: prefixEnvVars("HTTP_POLL_INTERVAL"),
+		Value:   config.DefaultPollInterval,
+	}
 	AlphabetFlag = &cli.StringFlag{
 		Name:    "alphabet",
 		Usage:   "Correct Alphabet Trace (alphabet trace type only)",
@@ -142,6 +148,7 @@ var requiredFlags = []cli.Flag{
 // optionalFlags is a list of unchecked cli flags
 var optionalFlags = []cli.Flag{
 	MaxConcurrencyFlag,
+	HTTPPollInterval,
 	AlphabetFlag,
 	GameAllowlistFlag,
 	CannonNetworkFlag,
@@ -247,6 +254,7 @@ func NewConfigFromCLI(ctx *cli.Context) (*config.Config, error) {
 		GameAllowlist:           allowedGames,
 		GameWindow:              ctx.Duration(GameWindowFlag.Name),
 		MaxConcurrency:          maxConcurrency,
+		PollInterval:            ctx.Duration(HTTPPollInterval.Name),
 		AlphabetTrace:           ctx.String(AlphabetFlag.Name),
 		CannonNetwork:           ctx.String(CannonNetworkFlag.Name),
 		CannonRollupConfigPath:  ctx.String(CannonRollupConfigFlag.Name),

op-challenger/game/fault/agent.go

@@ -9,6 +9,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/types"
 	gameTypes "github.com/ethereum-optimism/optimism/op-challenger/game/types"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
 )
 
@@ -66,7 +67,12 @@ func (a *Agent) Act(ctx context.Context) error {
 
 	// Perform the actions
 	for _, action := range actions {
-		log := a.log.New("action", action.Type, "is_attack", action.IsAttack, "parent", action.ParentIdx, "value", action.Value)
+		log := a.log.New("action", action.Type, "is_attack", action.IsAttack, "parent", action.ParentIdx)
+		if action.Type == types.ActionTypeStep {
+			log = log.New("prestate", common.Bytes2Hex(action.PreState), "proof", common.Bytes2Hex(action.ProofData))
+		} else {
+			log = log.New("value", action.Value)
+		}
 
 		if action.OracleData != nil {
 			a.log.Info("Updating oracle data", "oracleKey", action.OracleData.OracleKey, "oracleData", action.OracleData.OracleData)

op-challenger/game/fault/trace/cannon/provider.go

@@ -53,8 +53,6 @@ type CannonTraceProvider struct {
 	// lastStep stores the last step in the actual trace if known. 0 indicates unknown.
 	// Cached as an optimisation to avoid repeatedly attempting to execute beyond the end of the trace.
 	lastStep uint64
-	// lastProof stores the proof data to use for all steps extended beyond lastStep
-	lastProof *proofData
 }
 
 func NewTraceProvider(ctx context.Context, logger log.Logger, m CannonMetricer, cfg *config.Config, l1Client bind.ContractCaller, dir string, gameAddr common.Address) (*CannonTraceProvider, error) {
@@ -139,24 +137,19 @@ func (p *CannonTraceProvider) AbsolutePreStateCommitment(ctx context.Context) (c
 // loadProof will attempt to load or generate the proof data at the specified index
 // If the requested index is beyond the end of the actual trace it is extended with no-op instructions.
 func (p *CannonTraceProvider) loadProof(ctx context.Context, i uint64) (*proofData, error) {
-	if p.lastProof != nil && i > p.lastStep {
-		// If the requested index is after the last step in the actual trace, extend the final no-op step
-		return p.lastProof, nil
-	}
 	// Attempt to read the last step from disk cache
-	if p.lastProof == nil && p.lastStep == 0 {
-		step, err := ReadLastStep(p.dir)
+	if p.lastStep == 0 {
+		step, err := readLastStep(p.dir)
 		if err != nil {
 			p.logger.Warn("Failed to read last step from disk cache", "err", err)
 		} else {
 			p.lastStep = step
-			// If the last step is tracked, set i to the last step
-			// to read the correct proof from disk.
-			if i > p.lastStep {
-				i = step
-			}
 		}
 	}
+	// If the last step is tracked, set i to the last step to generate or load the final proof
+	if p.lastStep != 0 && i > p.lastStep {
+		i = p.lastStep
+	}
 	path := filepath.Join(p.dir, proofsDir, fmt.Sprintf("%d.json.gz", i))
 	file, err := ioutil.OpenDecompressed(path)
 	if errors.Is(err, os.ErrNotExist) {
@@ -183,9 +176,6 @@ func (p *CannonTraceProvider) loadProof(ctx context.Context, i uint64) (*proofDa
 				if err != nil {
 					return nil, fmt.Errorf("cannot hash witness: %w", err)
 				}
-				if err := WriteLastStep(p.dir, state.Step); err != nil {
-					p.logger.Warn("Failed to write last step to disk cache", "step", p.lastStep)
-				}
 				proof := &proofData{
 					ClaimValue:   witnessHash,
 					StateData:    hexutil.Bytes(witness),
@@ -194,7 +184,9 @@ func (p *CannonTraceProvider) loadProof(ctx context.Context, i uint64) (*proofDa
 					OracleValue:  nil,
 					OracleOffset: 0,
 				}
-				p.lastProof = proof
+				if err := writeLastStep(p.dir, proof, p.lastStep); err != nil {
+					p.logger.Warn("Failed to write last step to disk cache", "step", p.lastStep)
+				}
 				return proof, nil
 			} else {
 				return nil, fmt.Errorf("expected proof not generated but final state was not exited, requested step %v, final state at step %v", i, state.Step)
@@ -217,8 +209,8 @@ type diskStateCacheObj struct {
 	Step uint64 `json:"step"`
 }
 
-// ReadLastStep reads the tracked last step from disk.
-func ReadLastStep(dir string) (uint64, error) {
+// readLastStep reads the tracked last step from disk.
+func readLastStep(dir string) (uint64, error) {
 	state := diskStateCacheObj{}
 	file, err := ioutil.OpenDecompressed(filepath.Join(dir, diskStateCache))
 	if err != nil {
@@ -232,8 +224,15 @@ func ReadLastStep(dir string) (uint64, error) {
 	return state.Step, nil
 }
 
-// WriteLastStep writes the last step to disk as a persistent cache.
-func WriteLastStep(dir string, step uint64) error {
+// writeLastStep writes the last step and proof to disk as a persistent cache.
+func writeLastStep(dir string, proof *proofData, step uint64) error {
 	state := diskStateCacheObj{Step: step}
-	return ioutil.WriteCompressedJson(filepath.Join(dir, diskStateCache), state)
+	lastStepFile := filepath.Join(dir, diskStateCache)
+	if err := ioutil.WriteCompressedJson(lastStepFile, state); err != nil {
+		return fmt.Errorf("failed to write last step to %v: %w", lastStepFile, err)
+	}
+	if err := ioutil.WriteCompressedJson(filepath.Join(dir, proofsDir, fmt.Sprintf("%d.json.gz", step)), proof); err != nil {
+		return fmt.Errorf("failed to write proof: %w", err)
+	}
+	return nil
 }

op-challenger/game/fault/trace/cannon/provider_test.go

@@ -158,20 +158,16 @@ func TestGetStepData(t *testing.T) {
 			Exited: true,
 		}
 		generator.proof = &proofData{
-			ClaimValue:   common.Hash{0xaa},
-			StateData:    []byte{0xbb},
-			ProofData:    []byte{0xcc},
-			OracleKey:    common.Hash{0xdd}.Bytes(),
-			OracleValue:  []byte{0xdd},
-			OracleOffset: 10,
+			ClaimValue: common.Hash{0xaa},
+			StateData:  []byte{0xbb},
+			ProofData:  []byte{0xcc},
 		}
 		preimage, proof, data, err := provider.GetStepData(context.Background(), 7000)
 		require.NoError(t, err)
-		require.Contains(t, generator.generated, 10, "should have tried to generate the proof")
+		require.Empty(t, generator.generated, "should not have to generate the proof again")
 
-		witness := generator.finalState.EncodeWitness()
-		require.EqualValues(t, witness, preimage)
-		require.Equal(t, []byte{}, proof)
+		require.EqualValues(t, initGenerator.finalState.EncodeWitness(), preimage)
+		require.Empty(t, proof)
 		require.Nil(t, data)
 	})
 

op-challenger/game/monitor.go

@@ -9,7 +9,12 @@ import (
 
 	"github.com/ethereum-optimism/optimism/op-challenger/game/scheduler"
 	"github.com/ethereum-optimism/optimism/op-service/clock"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+
+	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
+	ethTypes "github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/event"
 	"github.com/ethereum/go-ethereum/log"
 )
 
@@ -32,6 +37,20 @@ type gameMonitor struct {
 	gameWindow       time.Duration
 	fetchBlockNumber blockNumberFetcher
 	allowedGames     []common.Address
+	l1HeadsSub       ethereum.Subscription
+	l1Source         *headSource
+}
+
+type MinimalSubscriber interface {
+	EthSubscribe(ctx context.Context, channel interface{}, args ...interface{}) (ethereum.Subscription, error)
+}
+
+type headSource struct {
+	inner MinimalSubscriber
+}
+
+func (s *headSource) SubscribeNewHead(ctx context.Context, ch chan<- *ethTypes.Header) (ethereum.Subscription, error) {
+	return s.inner.EthSubscribe(ctx, ch, "newHeads")
 }
 
 func newGameMonitor(
@@ -42,6 +61,7 @@ func newGameMonitor(
 	gameWindow time.Duration,
 	fetchBlockNumber blockNumberFetcher,
 	allowedGames []common.Address,
+	l1Source MinimalSubscriber,
 ) *gameMonitor {
 	return &gameMonitor{
 		logger:           logger,
@@ -51,6 +71,7 @@ func newGameMonitor(
 		gameWindow:       gameWindow,
 		fetchBlockNumber: fetchBlockNumber,
 		allowedGames:     allowedGames,
+		l1Source:         &headSource{inner: l1Source},
 	}
 }
 
@@ -99,29 +120,32 @@ func (m *gameMonitor) progressGames(ctx context.Context, blockNum uint64) error
 	return nil
 }
 
-func (m *gameMonitor) MonitorGames(ctx context.Context) error {
-	m.logger.Info("Monitoring fault dispute games")
+func (m *gameMonitor) onNewL1Head(ctx context.Context, sig eth.L1BlockRef) {
+	if err := m.progressGames(ctx, sig.Number); err != nil {
+		m.logger.Error("Failed to progress games", "err", err)
+	}
+}
+
+func (m *gameMonitor) resubscribeFunction(ctx context.Context) event.ResubscribeErrFunc {
+	return func(innerCtx context.Context, err error) (event.Subscription, error) {
+		if err != nil {
+			m.logger.Warn("resubscribing after failed L1 subscription", "err", err)
+		}
+		return eth.WatchHeadChanges(ctx, m.l1Source, m.onNewL1Head)
+	}
+}
 
-	blockNum := uint64(0)
+func (m *gameMonitor) MonitorGames(ctx context.Context) error {
+	m.l1HeadsSub = event.ResubscribeErr(time.Second*10, m.resubscribeFunction(ctx))
 	for {
 		select {
 		case <-ctx.Done():
-			return ctx.Err()
-		default:
-			nextBlockNum, err := m.fetchBlockNumber(ctx)
-			if err != nil {
-				m.logger.Error("Failed to load current block number", "err", err)
-				continue
-			}
-			if nextBlockNum > blockNum {
-				blockNum = nextBlockNum
-				if err := m.progressGames(ctx, nextBlockNum); err != nil {
-					m.logger.Error("Failed to progress games", "err", err)
-				}
-			}
-			if err := m.clock.SleepCtx(ctx, time.Second); err != nil {
+			return nil
+		case err, ok := <-m.l1HeadsSub.Err():
+			if !ok {
 				return err
 			}
+			m.logger.Error("L1 subscription error", "err", err)
 		}
 	}
 }

op-challenger/game/monitor_test.go

@@ -2,35 +2,40 @@ package game
 
 import (
 	"context"
+	"fmt"
 	"math/big"
 	"testing"
 	"time"
 
-	"github.com/ethereum-optimism/optimism/op-node/testlog"
-	"github.com/ethereum-optimism/optimism/op-service/clock"
+	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/common"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
 	"github.com/stretchr/testify/require"
+
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
+	"github.com/ethereum-optimism/optimism/op-node/testlog"
+	"github.com/ethereum-optimism/optimism/op-service/clock"
 )
 
 func TestMonitorMinGameTimestamp(t *testing.T) {
 	t.Parallel()
 
 	t.Run("zero game window returns zero", func(t *testing.T) {
-		monitor, _, _ := setupMonitorTest(t, []common.Address{})
+		monitor, _, _, _ := setupMonitorTest(t, []common.Address{})
 		monitor.gameWindow = time.Duration(0)
 		require.Equal(t, monitor.minGameTimestamp(), uint64(0))
 	})
 
 	t.Run("non-zero game window with zero clock", func(t *testing.T) {
-		monitor, _, _ := setupMonitorTest(t, []common.Address{})
+		monitor, _, _, _ := setupMonitorTest(t, []common.Address{})
 		monitor.gameWindow = time.Minute
 		monitor.clock = clock.NewDeterministicClock(time.Unix(0, 0))
 		require.Equal(t, monitor.minGameTimestamp(), uint64(0))
 	})
 
 	t.Run("minimum computed correctly", func(t *testing.T) {
-		monitor, _, _ := setupMonitorTest(t, []common.Address{})
+		monitor, _, _, _ := setupMonitorTest(t, []common.Address{})
 		monitor.gameWindow = time.Minute
 		frozen := time.Unix(int64(time.Hour.Seconds()), 0)
 		monitor.clock = clock.NewDeterministicClock(frozen)
@@ -39,29 +44,95 @@ func TestMonitorMinGameTimestamp(t *testing.T) {
 	})
 }
 
-func TestMonitorExitsWhenContextDone(t *testing.T) {
-	monitor, _, _ := setupMonitorTest(t, []common.Address{{}})
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	err := monitor.MonitorGames(ctx)
-	require.ErrorIs(t, err, context.Canceled)
+// TestMonitorGames tests that the monitor can handle a new head event
+// and resubscribe to new heads if the subscription errors.
+func TestMonitorGames(t *testing.T) {
+	t.Run("Schedules games", func(t *testing.T) {
+		addr1 := common.Address{0xaa}
+		addr2 := common.Address{0xbb}
+		monitor, source, sched, mockHeadSource := setupMonitorTest(t, []common.Address{})
+		source.games = []FaultDisputeGame{newFDG(addr1, 9999), newFDG(addr2, 9999)}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		go func() {
+			headerNotSent := true
+			waitErr := wait.For(context.Background(), 100*time.Millisecond, func() (bool, error) {
+				if len(sched.scheduled) >= 1 {
+					return true, nil
+				}
+				if mockHeadSource.sub == nil {
+					return false, nil
+				}
+				if headerNotSent {
+					mockHeadSource.sub.headers <- &ethtypes.Header{
+						Number: big.NewInt(1),
+					}
+					headerNotSent = false
+				}
+				return false, nil
+			})
+			require.NoError(t, waitErr)
+			mockHeadSource.err = fmt.Errorf("eth subscribe test error")
+			cancel()
+		}()
+
+		err := monitor.MonitorGames(ctx)
+		require.NoError(t, err)
+		require.Len(t, sched.scheduled, 1)
+		require.Equal(t, []common.Address{addr1, addr2}, sched.scheduled[0])
+	})
+
+	t.Run("Resubscribes on error", func(t *testing.T) {
+		addr1 := common.Address{0xaa}
+		addr2 := common.Address{0xbb}
+		monitor, source, sched, mockHeadSource := setupMonitorTest(t, []common.Address{})
+		source.games = []FaultDisputeGame{newFDG(addr1, 9999), newFDG(addr2, 9999)}
+
+		ctx, cancel := context.WithCancel(context.Background())
+		defer cancel()
+
+		go func() {
+			headerNotSent := true
+			waitErr := wait.For(context.Background(), 100*time.Millisecond, func() (bool, error) {
+				return mockHeadSource.sub != nil, nil
+			})
+			require.NoError(t, waitErr)
+			mockHeadSource.sub.errChan <- fmt.Errorf("test error")
+			waitErr = wait.For(context.Background(), 100*time.Millisecond, func() (bool, error) {
+				if len(sched.scheduled) >= 1 {
+					return true, nil
+				}
+				if mockHeadSource.sub == nil {
+					return false, nil
+				}
+				if headerNotSent {
+					mockHeadSource.sub.headers <- &ethtypes.Header{
+						Number: big.NewInt(1),
+					}
+					headerNotSent = false
+				}
+				return false, nil
+			})
+			require.NoError(t, waitErr)
+			mockHeadSource.err = fmt.Errorf("eth subscribe test error")
+			cancel()
+		}()
+
+		err := monitor.MonitorGames(ctx)
+		require.NoError(t, err)
+		require.Len(t, sched.scheduled, 1)
+		require.Equal(t, []common.Address{addr1, addr2}, sched.scheduled[0])
+	})
 }
 
 func TestMonitorCreateAndProgressGameAgents(t *testing.T) {
-	monitor, source, sched := setupMonitorTest(t, []common.Address{})
+	monitor, source, sched, _ := setupMonitorTest(t, []common.Address{})
 
 	addr1 := common.Address{0xaa}
 	addr2 := common.Address{0xbb}
-	source.games = []FaultDisputeGame{
-		{
-			Proxy:     addr1,
-			Timestamp: 9999,
-		},
-		{
-			Proxy:     addr2,
-			Timestamp: 9999,
-		},
-	}
+	source.games = []FaultDisputeGame{newFDG(addr1, 9999), newFDG(addr2, 9999)}
 
 	require.NoError(t, monitor.progressGames(context.Background(), uint64(1)))
 
@@ -72,18 +143,8 @@ func TestMonitorCreateAndProgressGameAgents(t *testing.T) {
 func TestMonitorOnlyScheduleSpecifiedGame(t *testing.T) {
 	addr1 := common.Address{0xaa}
 	addr2 := common.Address{0xbb}
-	monitor, source, sched := setupMonitorTest(t, []common.Address{addr2})
-
-	source.games = []FaultDisputeGame{
-		{
-			Proxy:     addr1,
-			Timestamp: 9999,
-		},
-		{
-			Proxy:     addr2,
-			Timestamp: 9999,
-		},
-	}
+	monitor, source, sched, _ := setupMonitorTest(t, []common.Address{addr2})
+	source.games = []FaultDisputeGame{newFDG(addr1, 9999), newFDG(addr2, 9999)}
 
 	require.NoError(t, monitor.progressGames(context.Background(), uint64(1)))
 
@@ -91,7 +152,17 @@ func TestMonitorOnlyScheduleSpecifiedGame(t *testing.T) {
 	require.Equal(t, []common.Address{addr2}, sched.scheduled[0])
 }
 
-func setupMonitorTest(t *testing.T, allowedGames []common.Address) (*gameMonitor, *stubGameSource, *stubScheduler) {
+func newFDG(proxy common.Address, timestamp uint64) FaultDisputeGame {
+	return FaultDisputeGame{
+		Proxy:     proxy,
+		Timestamp: timestamp,
+	}
+}
+
+func setupMonitorTest(
+	t *testing.T,
+	allowedGames []common.Address,
+) (*gameMonitor, *stubGameSource, *stubScheduler, *mockNewHeadSource) {
 	logger := testlog.Logger(t, log.LvlDebug)
 	source := &stubGameSource{}
 	i := uint64(1)
@@ -100,15 +171,58 @@ func setupMonitorTest(t *testing.T, allowedGames []common.Address) (*gameMonitor
 		return i, nil
 	}
 	sched := &stubScheduler{}
-	monitor := newGameMonitor(logger, clock.SystemClock, source, sched, time.Duration(0), fetchBlockNum, allowedGames)
-	return monitor, source, sched
+	mockHeadSource := &mockNewHeadSource{}
+	monitor := newGameMonitor(
+		logger,
+		clock.SystemClock,
+		source,
+		sched,
+		time.Duration(0),
+		fetchBlockNum,
+		allowedGames,
+		mockHeadSource,
+	)
+	return monitor, source, sched, mockHeadSource
+}
+
+type mockNewHeadSource struct {
+	sub *mockSubscription
+	err error
+}
+
+func (m *mockNewHeadSource) EthSubscribe(
+	ctx context.Context,
+	ch any,
+	args ...any,
+) (ethereum.Subscription, error) {
+	errChan := make(chan error)
+	m.sub = &mockSubscription{errChan, (ch).(chan<- *ethtypes.Header)}
+	if m.err != nil {
+		return nil, m.err
+	}
+	return m.sub, nil
+}
+
+type mockSubscription struct {
+	errChan chan error
+	headers chan<- *ethtypes.Header
+}
+
+func (m *mockSubscription) Unsubscribe() {}
+
+func (m *mockSubscription) Err() <-chan error {
+	return m.errChan
 }
 
 type stubGameSource struct {
 	games []FaultDisputeGame
 }
 
-func (s *stubGameSource) FetchAllGamesAtBlock(ctx context.Context, earliest uint64, blockNumber *big.Int) ([]FaultDisputeGame, error) {
+func (s *stubGameSource) FetchAllGamesAtBlock(
+	ctx context.Context,
+	earliest uint64,
+	blockNumber *big.Int,
+) ([]FaultDisputeGame, error) {
 	return s.games, nil
 }
 

op-challenger/game/service.go

@@ -10,6 +10,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-challenger/game/scheduler"
 	"github.com/ethereum-optimism/optimism/op-challenger/metrics"
 	"github.com/ethereum-optimism/optimism/op-challenger/version"
+	opClient "github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-service/client"
 	"github.com/ethereum-optimism/optimism/op-service/clock"
 	oppprof "github.com/ethereum-optimism/optimism/op-service/pprof"
@@ -34,7 +35,7 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*Se
 		return nil, fmt.Errorf("failed to create the transaction manager: %w", err)
 	}
 
-	client, err := client.DialEthClientWithTimeout(client.DefaultDialTimeout, logger, cfg.L1EthRpc)
+	l1Client, err := client.DialEthClientWithTimeout(client.DefaultDialTimeout, logger, cfg.L1EthRpc)
 	if err != nil {
 		return nil, fmt.Errorf("failed to dial L1: %w", err)
 	}
@@ -57,10 +58,10 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*Se
 				logger.Error("error starting metrics server", "err", err)
 			}
 		}()
-		m.StartBalanceMetrics(ctx, logger, client, txMgr.From())
+		m.StartBalanceMetrics(ctx, logger, l1Client, txMgr.From())
 	}
 
-	factory, err := bindings.NewDisputeGameFactory(cfg.GameFactoryAddress, client)
+	factory, err := bindings.NewDisputeGameFactory(cfg.GameFactoryAddress, l1Client)
 	if err != nil {
 		return nil, fmt.Errorf("failed to bind the fault dispute game factory contract: %w", err)
 	}
@@ -73,10 +74,14 @@ func NewService(ctx context.Context, logger log.Logger, cfg *config.Config) (*Se
 		disk,
 		cfg.MaxConcurrency,
 		func(addr common.Address, dir string) (scheduler.GamePlayer, error) {
-			return fault.NewGamePlayer(ctx, logger, m, cfg, dir, addr, txMgr, client)
+			return fault.NewGamePlayer(ctx, logger, m, cfg, dir, addr, txMgr, l1Client)
 		})
 
-	monitor := newGameMonitor(logger, cl, loader, sched, cfg.GameWindow, client.BlockNumber, cfg.GameAllowlist)
+	pollClient, err := opClient.NewRPCWithClient(ctx, logger, cfg.L1EthRpc, opClient.NewBaseRPCClient(l1Client.Client()), cfg.PollInterval)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create RPC client: %w", err)
+	}
+	monitor := newGameMonitor(logger, cl, loader, sched, cfg.GameWindow, l1Client.BlockNumber, cfg.GameAllowlist, pollClient)
 
 	m.RecordInfo(version.SimpleWithMeta)
 	m.RecordUp()

op-e2e/e2eutils/challenger/helper.go

@@ -145,6 +145,10 @@ func NewChallengerConfig(t *testing.T, l1Endpoint string, options ...Option) *co
 		_, err := os.Stat(cfg.CannonAbsolutePreState)
 		require.NoError(t, err, "cannon pre-state should be built. Make sure you've run make cannon-prestate")
 	}
+	if cfg.PollInterval == 0 {
+		cfg.PollInterval = time.Second
+	}
+
 	return &cfg
 }
 

op-e2e/e2eutils/disputegame/game_helper.go

@@ -65,7 +65,7 @@ func (g *FaultGameHelper) MaxDepth(ctx context.Context) int64 {
 }
 
 func (g *FaultGameHelper) waitForClaim(ctx context.Context, errorMsg string, predicate func(claim ContractClaim) bool) {
-	timedCtx, cancel := context.WithTimeout(ctx, time.Minute)
+	timedCtx, cancel := context.WithTimeout(ctx, 2*time.Minute)
 	defer cancel()
 	err := wait.For(timedCtx, time.Second, func() (bool, error) {
 		count, err := g.game.ClaimDataLen(&bind.CallOpts{Context: timedCtx})
@@ -89,6 +89,31 @@ func (g *FaultGameHelper) waitForClaim(ctx context.Context, errorMsg string, pre
 	}
 }
 
+func (g *FaultGameHelper) waitForNoClaim(ctx context.Context, errorMsg string, predicate func(claim ContractClaim) bool) {
+	timedCtx, cancel := context.WithTimeout(ctx, 3*time.Minute)
+	defer cancel()
+	err := wait.For(timedCtx, time.Second, func() (bool, error) {
+		count, err := g.game.ClaimDataLen(&bind.CallOpts{Context: timedCtx})
+		if err != nil {
+			return false, fmt.Errorf("retrieve number of claims: %w", err)
+		}
+		// Search backwards because the new claims are at the end and more likely the ones we will fail on.
+		for i := count.Int64() - 1; i >= 0; i-- {
+			claimData, err := g.game.ClaimData(&bind.CallOpts{Context: timedCtx}, big.NewInt(i))
+			if err != nil {
+				return false, fmt.Errorf("retrieve claim %v: %w", i, err)
+			}
+			if predicate(claimData) {
+				return false, nil
+			}
+		}
+		return true, nil
+	})
+	if err != nil { // Avoid waiting time capturing game data when there's no error
+		g.require.NoErrorf(err, "%v\n%v", errorMsg, g.gameData(ctx))
+	}
+}
+
 func (g *FaultGameHelper) GetClaimValue(ctx context.Context, claimIdx int64) common.Hash {
 	g.WaitForClaimCount(ctx, claimIdx+1)
 	claim := g.getClaim(ctx, claimIdx)
@@ -105,6 +130,16 @@ func (g *FaultGameHelper) getClaim(ctx context.Context, claimIdx int64) Contract
 	return claimData
 }
 
+func (g *FaultGameHelper) WaitForClaimAtDepth(ctx context.Context, depth int) {
+	g.waitForClaim(
+		ctx,
+		fmt.Sprintf("Could not find claim depth %v", depth),
+		func(claim ContractClaim) bool {
+			pos := types.NewPositionFromGIndex(claim.Position.Uint64())
+			return pos.Depth() == depth
+		})
+}
+
 func (g *FaultGameHelper) WaitForClaimAtMaxDepth(ctx context.Context, countered bool) {
 	maxDepth := g.MaxDepth(ctx)
 	g.waitForClaim(
@@ -116,6 +151,15 @@ func (g *FaultGameHelper) WaitForClaimAtMaxDepth(ctx context.Context, countered
 		})
 }
 
+func (g *FaultGameHelper) WaitForAllClaimsCountered(ctx context.Context) {
+	g.waitForNoClaim(
+		ctx,
+		"Did not find all claims countered",
+		func(claim ContractClaim) bool {
+			return !claim.Countered
+		})
+}
+
 func (g *FaultGameHelper) Resolve(ctx context.Context) {
 	ctx, cancel := context.WithTimeout(ctx, time.Minute)
 	defer cancel()

op-e2e/e2eutils/disputegame/helper.go

@@ -100,7 +100,7 @@ func (h *FactoryHelper) StartAlphabetGame(ctx context.Context, claimedAlphabet s
 	l2BlockNumber := h.waitForProposals(ctx)
 	l1Head := h.checkpointL1Block(ctx)
 
-	ctx, cancel := context.WithTimeout(ctx, 1*time.Minute)
+	ctx, cancel := context.WithTimeout(ctx, 2*time.Minute)
 	defer cancel()
 
 	trace := alphabet.NewTraceProvider(claimedAlphabet, alphabetGameDepth)

op-e2e/faultproof_test.go

@@ -341,6 +341,66 @@ func TestCannonProposedOutputRootInvalid(t *testing.T) {
 	}
 }
 
+func TestCannonPoisonedPostState(t *testing.T) {
+	t.Skip("Known failure case")
+	InitParallel(t)
+
+	ctx := context.Background()
+	sys, l1Client := startFaultDisputeSystem(t)
+	t.Cleanup(sys.Close)
+
+	l1Endpoint := sys.NodeEndpoint("l1")
+	l2Endpoint := sys.NodeEndpoint("sequencer")
+
+	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys.cfg.L1Deployments, l1Client)
+	game, correctTrace := disputeGameFactory.StartCannonGameWithCorrectRoot(ctx, sys.RollupConfig, sys.L2GenesisCfg, l1Endpoint, l2Endpoint,
+		challenger.WithPrivKey(sys.cfg.Secrets.Mallory),
+	)
+	require.NotNil(t, game)
+	game.LogGameData(ctx)
+
+	// Honest first attack at "honest" level
+	correctTrace.Attack(ctx, 0)
+
+	// Honest defense at "dishonest" level
+	correctTrace.Defend(ctx, 1)
+
+	// Dishonest attack at "honest" level - honest move would be to defend
+	game.Attack(ctx, 2, common.Hash{0x03, 0xaa})
+
+	// Start the honest challenger
+	game.StartChallenger(ctx, sys.RollupConfig, sys.L2GenesisCfg, l1Endpoint, l2Endpoint, "Honest",
+		// Agree with the proposed output, so disagree with the root claim
+		challenger.WithAgreeProposedOutput(true),
+		challenger.WithPrivKey(sys.cfg.Secrets.Bob),
+	)
+
+	// Start dishonest challenger that posts correct claims
+	game.StartChallenger(ctx, sys.RollupConfig, sys.L2GenesisCfg, l1Endpoint, l2Endpoint, "DishonestCorrect",
+		// Disagree with the proposed output, so agree with the root claim
+		challenger.WithAgreeProposedOutput(false),
+		challenger.WithPrivKey(sys.cfg.Secrets.Mallory),
+	)
+
+	// Give the challengers time to progress down the full game depth
+	depth := game.MaxDepth(ctx)
+	for i := 3; i <= int(depth); i++ {
+		game.WaitForClaimAtDepth(ctx, i)
+		game.LogGameData(ctx)
+	}
+
+	// Wait for all the leaf nodes to be countered
+	// Wait for the challengers to drive the game down to the leaf node which should be countered
+	game.WaitForAllClaimsCountered(ctx)
+
+	// Time travel past when the game will be resolvable.
+	sys.TimeTravelClock.AdvanceTime(game.GameDuration(ctx))
+	require.NoError(t, wait.ForNextBlock(ctx, l1Client))
+
+	game.WaitForGameStatus(ctx, disputegame.StatusChallengerWins)
+	game.LogGameData(ctx)
+}
+
 // setupDisputeGameForInvalidOutputRoot sets up an L2 chain with at least one valid output root followed by an invalid output root.
 // A cannon dispute game is started to dispute the invalid output root with the correct root claim provided.
 // An honest challenger is run to defend the root claim (ie disagree with the invalid output root).

op-e2e/l2_gossip_test.go

@@ -14,8 +14,8 @@ func TestTxGossip(t *testing.T) {
 	gethOpts := []geth.GethOption{
 		geth.WithP2P(),
 	}
-	cfg.GethOptions["sequencer"] = gethOpts
-	cfg.GethOptions["verifier"] = gethOpts
+	cfg.GethOptions["sequencer"] = append(cfg.GethOptions["sequencer"], gethOpts...)
+	cfg.GethOptions["verifier"] = append(cfg.GethOptions["verifier"], gethOpts...)
 	sys, err := cfg.Start(t)
 	require.NoError(t, err, "Start system")
 

op-e2e/setup.go

@@ -408,16 +408,17 @@ func (cfg SystemConfig) Start(t *testing.T, _opts ...SystemConfigOption) (*Syste
 				L2Time:       uint64(cfg.DeployConfig.L1GenesisBlockTimestamp),
 				SystemConfig: e2eutils.SystemConfigFromDeployConfig(cfg.DeployConfig),
 			},
-			BlockTime:              cfg.DeployConfig.L2BlockTime,
-			MaxSequencerDrift:      cfg.DeployConfig.MaxSequencerDrift,
-			SeqWindowSize:          cfg.DeployConfig.SequencerWindowSize,
-			ChannelTimeout:         cfg.DeployConfig.ChannelTimeout,
-			L1ChainID:              cfg.L1ChainIDBig(),
-			L2ChainID:              cfg.L2ChainIDBig(),
-			BatchInboxAddress:      cfg.DeployConfig.BatchInboxAddress,
-			DepositContractAddress: cfg.DeployConfig.OptimismPortalProxy,
-			L1SystemConfigAddress:  cfg.DeployConfig.SystemConfigProxy,
-			RegolithTime:           cfg.DeployConfig.RegolithTime(uint64(cfg.DeployConfig.L1GenesisBlockTimestamp)),
+			BlockTime:               cfg.DeployConfig.L2BlockTime,
+			MaxSequencerDrift:       cfg.DeployConfig.MaxSequencerDrift,
+			SeqWindowSize:           cfg.DeployConfig.SequencerWindowSize,
+			ChannelTimeout:          cfg.DeployConfig.ChannelTimeout,
+			L1ChainID:               cfg.L1ChainIDBig(),
+			L2ChainID:               cfg.L2ChainIDBig(),
+			BatchInboxAddress:       cfg.DeployConfig.BatchInboxAddress,
+			DepositContractAddress:  cfg.DeployConfig.OptimismPortalProxy,
+			L1SystemConfigAddress:   cfg.DeployConfig.SystemConfigProxy,
+			RegolithTime:            cfg.DeployConfig.RegolithTime(uint64(cfg.DeployConfig.L1GenesisBlockTimestamp)),
+			ProtocolVersionsAddress: cfg.L1Deployments.ProtocolVersionsProxy,
 		}
 	}
 	defaultConfig := makeRollupConfig()

op-e2e/system_test.go

@@ -2,6 +2,7 @@ package op_e2e
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"math/big"
 	"os"
@@ -261,20 +262,20 @@ func TestPendingGasLimit(t *testing.T) {
 
 	// configure the L2 gas limit to be high, and the pending gas limits to be lower for resource saving.
 	cfg.DeployConfig.L2GenesisBlockGasLimit = 30_000_000
-	cfg.GethOptions["sequencer"] = []geth.GethOption{
+	cfg.GethOptions["sequencer"] = append(cfg.GethOptions["sequencer"], []geth.GethOption{
 		func(ethCfg *ethconfig.Config, nodeCfg *node.Config) error {
 			ethCfg.Miner.GasCeil = 10_000_000
 			ethCfg.Miner.RollupComputePendingBlock = true
 			return nil
 		},
-	}
-	cfg.GethOptions["verifier"] = []geth.GethOption{
+	}...)
+	cfg.GethOptions["verifier"] = append(cfg.GethOptions["verifier"], []geth.GethOption{
 		func(ethCfg *ethconfig.Config, nodeCfg *node.Config) error {
 			ethCfg.Miner.GasCeil = 9_000_000
 			ethCfg.Miner.RollupComputePendingBlock = true
 			return nil
 		},
-	}
+	}...)
 
 	sys, err := cfg.Start(t)
 	require.Nil(t, err, "Error starting up system")
@@ -1434,3 +1435,118 @@ func TestRuntimeConfigReload(t *testing.T) {
 	})
 	require.NoError(t, err)
 }
+
+func TestRecommendedProtocolVersionChange(t *testing.T) {
+	InitParallel(t)
+
+	cfg := DefaultSystemConfig(t)
+	require.NotEqual(t, common.Address{}, cfg.L1Deployments.ProtocolVersions, "need ProtocolVersions contract deployment")
+	// to speed up the test, make it reload the config more often, and do not impose a long conf depth
+	cfg.Nodes["verifier"].RuntimeConfigReloadInterval = time.Second * 5
+	cfg.Nodes["verifier"].Driver.VerifierConfDepth = 1
+
+	sys, err := cfg.Start(t)
+	require.Nil(t, err, "Error starting up system")
+	defer sys.Close()
+	runtimeConfig := sys.RollupNodes["verifier"].RuntimeConfig()
+
+	// Change the superchain-config via L1
+	l1 := sys.Clients["l1"]
+
+	_, build, major, minor, patch, preRelease := params.OPStackSupport.Parse()
+	newRecommendedProtocolVersion := params.ProtocolVersionV0{Build: build, Major: major + 1, Minor: minor, Patch: patch, PreRelease: preRelease}.Encode()
+	require.NotEqual(t, runtimeConfig.RecommendedProtocolVersion(), newRecommendedProtocolVersion, "changing to a different protocol version")
+
+	protVersions, err := bindings.NewProtocolVersions(cfg.L1Deployments.ProtocolVersionsProxy, l1)
+	require.NoError(t, err)
+
+	// ProtocolVersions contract is owned by same key as SystemConfig in devnet
+	opts, err := bind.NewKeyedTransactorWithChainID(cfg.Secrets.SysCfgOwner, cfg.L1ChainIDBig())
+	require.NoError(t, err)
+
+	// Change recommended protocol version
+	tx, err := protVersions.SetRecommended(opts, new(big.Int).SetBytes(newRecommendedProtocolVersion[:]))
+	require.NoError(t, err)
+
+	// wait for the change to confirm
+	_, err = wait.ForReceiptOK(context.Background(), l1, tx.Hash())
+	require.NoError(t, err)
+
+	// wait for the recommended protocol version to change
+	_, err = retry.Do(context.Background(), 10, retry.Fixed(time.Second*10), func() (struct{}, error) {
+		v := sys.RollupNodes["verifier"].RuntimeConfig().RecommendedProtocolVersion()
+		if v == newRecommendedProtocolVersion {
+			return struct{}{}, nil
+		}
+		return struct{}{}, fmt.Errorf("no change yet, seeing %s but looking for %s", v, newRecommendedProtocolVersion)
+	})
+	require.NoError(t, err)
+}
+
+func TestRequiredProtocolVersionChangeAndHalt(t *testing.T) {
+	InitParallel(t)
+
+	cfg := DefaultSystemConfig(t)
+	// to speed up the test, make it reload the config more often, and do not impose a long conf depth
+	cfg.Nodes["verifier"].RuntimeConfigReloadInterval = time.Second * 5
+	cfg.Nodes["verifier"].Driver.VerifierConfDepth = 1
+	// configure halt in verifier op-node
+	cfg.Nodes["verifier"].RollupHalt = "major"
+	// configure halt in verifier op-geth node
+	cfg.GethOptions["verifier"] = append(cfg.GethOptions["verifier"], []geth.GethOption{
+		func(ethCfg *ethconfig.Config, nodeCfg *node.Config) error {
+			ethCfg.RollupHaltOnIncompatibleProtocolVersion = "major"
+			return nil
+		},
+	}...)
+
+	sys, err := cfg.Start(t)
+	require.Nil(t, err, "Error starting up system")
+	defer sys.Close()
+	runtimeConfig := sys.RollupNodes["verifier"].RuntimeConfig()
+
+	// Change the superchain-config via L1
+	l1 := sys.Clients["l1"]
+
+	_, build, major, minor, patch, preRelease := params.OPStackSupport.Parse()
+	newRequiredProtocolVersion := params.ProtocolVersionV0{Build: build, Major: major + 1, Minor: minor, Patch: patch, PreRelease: preRelease}.Encode()
+	require.NotEqual(t, runtimeConfig.RequiredProtocolVersion(), newRequiredProtocolVersion, "changing to a different protocol version")
+
+	protVersions, err := bindings.NewProtocolVersions(cfg.L1Deployments.ProtocolVersionsProxy, l1)
+	require.NoError(t, err)
+
+	// ProtocolVersions contract is owned by same key as SystemConfig in devnet
+	opts, err := bind.NewKeyedTransactorWithChainID(cfg.Secrets.SysCfgOwner, cfg.L1ChainIDBig())
+	require.NoError(t, err)
+
+	// Change required protocol version
+	tx, err := protVersions.SetRequired(opts, new(big.Int).SetBytes(newRequiredProtocolVersion[:]))
+	require.NoError(t, err)
+
+	// wait for the change to confirm
+	_, err = wait.ForReceiptOK(context.Background(), l1, tx.Hash())
+	require.NoError(t, err)
+
+	// wait for the required protocol version to take effect by halting the verifier that opted in, and halting the op-geth node that opted in.
+	_, err = retry.Do(context.Background(), 10, retry.Fixed(time.Second*10), func() (struct{}, error) {
+		if !sys.RollupNodes["verifier"].Closed() {
+			return struct{}{}, errors.New("verifier rollup node is not closed yet")
+		}
+		return struct{}{}, nil
+	})
+	require.NoError(t, err)
+	t.Log("verified that op-node closed!")
+	// Checking if the engine is down is not trivial in op-e2e.
+	// In op-geth we have halting tests covering the Engine API, in op-e2e we instead check if the API stops.
+	_, err = retry.Do(context.Background(), 10, retry.Fixed(time.Second*10), func() (struct{}, error) {
+		ctx, cancel := context.WithTimeout(context.Background(), time.Second*10)
+		_, err := sys.Clients["verifier"].ChainID(ctx)
+		cancel()
+		if err != nil && !errors.Is(err, ctx.Err()) { // waiting for client to stop responding to chainID requests
+			return struct{}{}, nil
+		}
+		return struct{}{}, errors.New("verifier rollup node is not closed yet")
+	})
+	require.NoError(t, err)
+	t.Log("verified that op-geth closed!")
+}

op-node/client/rpc.go

@@ -80,9 +80,11 @@ func NewRPC(ctx context.Context, lgr log.Logger, addr string, opts ...RPCOption)
 			return nil, fmt.Errorf("rpc option %d failed to apply to RPC config: %w", i, err)
 		}
 	}
+
 	if cfg.backoffAttempts < 1 { // default to at least 1 attempt, or it always fails to dial.
 		cfg.backoffAttempts = 1
 	}
+
 	underlying, err := dialRPCClientWithBackoff(ctx, lgr, addr, cfg.backoffAttempts, cfg.gethRPCOptions...)
 	if err != nil {
 		return nil, err
@@ -94,11 +96,15 @@ func NewRPC(ctx context.Context, lgr log.Logger, addr string, opts ...RPCOption)
 		wrapped = NewRateLimitingClient(wrapped, rate.Limit(cfg.limit), cfg.burst)
 	}
 
+	return NewRPCWithClient(ctx, lgr, addr, wrapped, cfg.httpPollInterval)
+}
+
+// NewRPCWithClient builds a new polling client with the given underlying RPC client.
+func NewRPCWithClient(ctx context.Context, lgr log.Logger, addr string, underlying RPC, pollInterval time.Duration) (RPC, error) {
 	if httpRegex.MatchString(addr) {
-		wrapped = NewPollingClient(ctx, lgr, wrapped, WithPollRate(cfg.httpPollInterval))
+		underlying = NewPollingClient(ctx, lgr, underlying, WithPollRate(pollInterval))
 	}
-
-	return wrapped, nil
+	return underlying, nil
 }
 
 // Dials a JSON-RPC endpoint repeatedly, with a backoff, until a client connection is established. Auth is optional.

op-node/flags/flags.go

@@ -244,6 +244,18 @@ var (
 		EnvVars: prefixEnvVars("BETA_EXTRA_NETWORKS"),
 		Hidden:  true,
 	}
+	BetaRollupHalt = &cli.StringFlag{
+		Name:    "beta.rollup.halt",
+		Usage:   "Beta feature: opt-in option to halt on incompatible protocol version requirements of the given level (major/minor/patch/none), as signaled onchain in L1",
+		EnvVars: prefixEnvVars("BETA_ROLLUP_HALT"),
+		Hidden:  true,
+	}
+	BetaRollupLoadProtocolVersions = &cli.BoolFlag{
+		Name:    "beta.rollup.load-protocol-versions",
+		Usage:   "Beta feature: load protocol versions from the superchain L1 ProtocolVersions contract (if available), and report in logs and metrics",
+		EnvVars: prefixEnvVars("BETA_ROLLUP_LOAD_PROTOCOL_VERSIONS"),
+		Hidden:  true,
+	}
 )
 
 var requiredFlags = []cli.Flag{
@@ -286,6 +298,8 @@ var optionalFlags = []cli.Flag{
 	L2EngineSyncEnabled,
 	SkipSyncStartCheck,
 	BetaExtraNetworks,
+	BetaRollupHalt,
+	BetaRollupLoadProtocolVersions,
 }
 
 // Flags contains the list of configuration options available to the binary.

op-node/metrics/metrics.go

@@ -10,6 +10,8 @@ import (
 	"strconv"
 	"time"
 
+	"github.com/ethereum/go-ethereum/params"
+
 	"github.com/ethereum-optimism/optimism/op-node/p2p/store"
 	ophttp "github.com/ethereum-optimism/optimism/op-service/httputil"
 	"github.com/ethereum-optimism/optimism/op-service/metrics"
@@ -78,6 +80,7 @@ type Metricer interface {
 	RecordIPUnban()
 	RecordDial(allow bool)
 	RecordAccept(allow bool)
+	ReportProtocolVersions(local, engine, recommended, required params.ProtocolVersion)
 }
 
 // Metrics tracks all the metrics for the op-node.
@@ -153,6 +156,12 @@ type Metrics struct {
 
 	ChannelInputBytes prometheus.Counter
 
+	// Protocol version reporting
+	// Delta = params.ProtocolVersionComparison
+	ProtocolVersionDelta *prometheus.GaugeVec
+	// ProtocolVersions is pseudo-metric to report the exact protocol version info
+	ProtocolVersions *prometheus.GaugeVec
+
 	registry *prometheus.Registry
 	factory  metrics.Factory
 }
@@ -452,6 +461,24 @@ func NewMetrics(procName string) *Metrics {
 			Help:      "Number of sequencer block sealing jobs",
 		}),
 
+		ProtocolVersionDelta: factory.NewGaugeVec(prometheus.GaugeOpts{
+			Namespace: ns,
+			Name:      "protocol_version_delta",
+			Help:      "Difference between local and global protocol version, and execution-engine, per type of version",
+		}, []string{
+			"type",
+		}),
+		ProtocolVersions: factory.NewGaugeVec(prometheus.GaugeOpts{
+			Namespace: ns,
+			Name:      "protocol_versions",
+			Help:      "Pseudo-metric tracking recommended and required protocol version info",
+		}, []string{
+			"local",
+			"engine",
+			"recommended",
+			"required",
+		}),
+
 		registry: registry,
 		factory:  factory,
 	}
@@ -747,6 +774,13 @@ func (m *Metrics) RecordAccept(allow bool) {
 		m.Accepts.WithLabelValues("false").Inc()
 	}
 }
+func (m *Metrics) ReportProtocolVersions(local, engine, recommended, required params.ProtocolVersion) {
+	m.ProtocolVersionDelta.WithLabelValues("local_recommended").Set(float64(local.Compare(recommended)))
+	m.ProtocolVersionDelta.WithLabelValues("local_required").Set(float64(local.Compare(required)))
+	m.ProtocolVersionDelta.WithLabelValues("engine_recommended").Set(float64(engine.Compare(recommended)))
+	m.ProtocolVersionDelta.WithLabelValues("engine_required").Set(float64(engine.Compare(required)))
+	m.ProtocolVersions.WithLabelValues(local.String(), engine.String(), recommended.String(), required.String()).Set(1)
+}
 
 type noopMetricer struct{}
 
@@ -874,3 +908,5 @@ func (n *noopMetricer) RecordDial(allow bool) {
 
 func (n *noopMetricer) RecordAccept(allow bool) {
 }
+func (n *noopMetricer) ReportProtocolVersions(local, engine, recommended, required params.ProtocolVersion) {
+}

op-node/node/config.go

@@ -42,7 +42,7 @@ type Config struct {
 	ConfigPersistence ConfigPersistence
 
 	// RuntimeConfigReloadInterval defines the interval between runtime config reloads.
-	// Disabled if 0.
+	// Disabled if <= 0.
 	// Runtime config changes should be picked up from log-events,
 	// but if log-events are not coming in (e.g. not syncing blocks) then the reload ensures the config stays accurate.
 	RuntimeConfigReloadInterval time.Duration
@@ -52,6 +52,10 @@ type Config struct {
 	Heartbeat HeartbeatConfig
 
 	Sync sync.Config
+
+	// To halt when detecting the node does not support a signaled protocol version
+	// change of the given severity (major/minor/patch). Disabled if empty.
+	RollupHalt string
 }
 
 type RPCConfig struct {
@@ -128,5 +132,8 @@ func (cfg *Config) Check() error {
 			return fmt.Errorf("p2p config error: %w", err)
 		}
 	}
+	if !(cfg.RollupHalt == "" || cfg.RollupHalt == "major" || cfg.RollupHalt == "minor" || cfg.RollupHalt == "patch") {
+		return fmt.Errorf("invalid rollup halting option: %q", cfg.RollupHalt)
+	}
 	return nil
 }

op-node/node/node.go

@@ -2,7 +2,9 @@ package node
 
 import (
 	"context"
+	"errors"
 	"fmt"
+	"sync/atomic"
 	"time"
 
 	"github.com/hashicorp/go-multierror"
@@ -40,10 +42,14 @@ type OpNode struct {
 	tracer    Tracer                // tracer to get events for testing/debugging
 	runCfg    *RuntimeConfig        // runtime configurables
 
+	rollupHalt string // when to halt the rollup, disabled if empty
+
 	// some resources cannot be stopped directly, like the p2p gossipsub router (not our design),
 	// and depend on this ctx to be closed.
 	resourcesCtx   context.Context
 	resourcesClose context.CancelFunc
+
+	closed atomic.Bool
 }
 
 // The OpNode handles incoming gossip
@@ -58,6 +64,7 @@ func New(ctx context.Context, cfg *Config, log log.Logger, snapshotLog log.Logge
 		log:        log,
 		appVersion: appVersion,
 		metrics:    m,
+		rollupHalt: cfg.RollupHalt,
 	}
 	// not a context leak, gossipsub is closed with a context.
 	n.resourcesCtx, n.resourcesClose = context.WithCancel(context.Background())
@@ -189,6 +196,9 @@ func (n *OpNode) initRuntimeConfig(ctx context.Context, cfg *Config) error {
 			n.log.Error("failed to fetch runtime config data", "err", err)
 			return l1Head, err
 		}
+
+		n.handleProtocolVersionsUpdate(ctx)
+
 		return l1Head, nil
 	}
 
@@ -446,6 +456,10 @@ func (n *OpNode) RuntimeConfig() ReadonlyRuntimeConfig {
 
 // Close closes all resources.
 func (n *OpNode) Close() error {
+	if n.closed.Load() {
+		return errors.New("node is already closed")
+	}
+
 	var result *multierror.Error
 
 	if n.server != nil {
@@ -494,9 +508,18 @@ func (n *OpNode) Close() error {
 	if n.l1Source != nil {
 		n.l1Source.Close()
 	}
+
+	if result == nil { // mark as closed if we successfully fully closed
+		n.closed.Store(true)
+	}
+
 	return result.ErrorOrNil()
 }
 
+func (n *OpNode) Closed() bool {
+	return n.closed.Load()
+}
+
 func (n *OpNode) ListenAddr() string {
 	return n.server.listenAddr.String()
 }

op-node/node/runtime_config.go

@@ -7,6 +7,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/log"
+	"github.com/ethereum/go-ethereum/params"
 
 	"github.com/ethereum-optimism/optimism/op-node/p2p"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
@@ -17,6 +18,14 @@ var (
 	// UnsafeBlockSignerAddressSystemConfigStorageSlot is the storage slot identifier of the unsafeBlockSigner
 	// `address` storage value in the SystemConfig L1 contract. Computed as `keccak256("systemconfig.unsafeblocksigner")`
 	UnsafeBlockSignerAddressSystemConfigStorageSlot = common.HexToHash("0x65a7ed542fb37fe237fdfbdd70b31598523fe5b32879e307bae27a0bd9581c08")
+
+	// RequiredProtocolVersionStorageSlot is the storage slot that the required protocol version is stored at.
+	// Computed as: `bytes32(uint256(keccak256("protocolversion.required")) - 1)`
+	RequiredProtocolVersionStorageSlot = common.HexToHash("0x4aaefe95bd84fd3f32700cf3b7566bc944b73138e41958b5785826df2aecace0")
+
+	// RecommendedProtocolVersionStorageSlot is the storage slot that the recommended protocol version is stored at.
+	// Computed as: `bytes32(uint256(keccak256("protocolversion.recommended")) - 1)`
+	RecommendedProtocolVersionStorageSlot = common.HexToHash("0xe314dfc40f0025322aacc0ba8ef420b62fb3b702cf01e0cdf3d829117ac2ff1a")
 )
 
 type RuntimeCfgL1Source interface {
@@ -25,6 +34,8 @@ type RuntimeCfgL1Source interface {
 
 type ReadonlyRuntimeConfig interface {
 	P2PSequencerAddress() common.Address
+	RequiredProtocolVersion() params.ProtocolVersion
+	RecommendedProtocolVersion() params.ProtocolVersion
 }
 
 // RuntimeConfig maintains runtime-configurable options.
@@ -49,6 +60,10 @@ type RuntimeConfig struct {
 // runtimeConfigData is a flat bundle of configurable data, easy and light to copy around.
 type runtimeConfigData struct {
 	p2pBlockSignerAddr common.Address
+
+	// superchain protocol version signals
+	recommended params.ProtocolVersion
+	required    params.ProtocolVersion
 }
 
 var _ p2p.GossipRuntimeConfig = (*RuntimeConfig)(nil)
@@ -67,18 +82,46 @@ func (r *RuntimeConfig) P2PSequencerAddress() common.Address {
 	return r.p2pBlockSignerAddr
 }
 
+func (r *RuntimeConfig) RequiredProtocolVersion() params.ProtocolVersion {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return r.required
+}
+
+func (r *RuntimeConfig) RecommendedProtocolVersion() params.ProtocolVersion {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	return r.recommended
+}
+
 // Load resets the runtime configuration by fetching the latest config data from L1 at the given L1 block.
 // Load is safe to call concurrently, but will lock the runtime configuration modifications only,
 // and will thus not block other Load calls with possibly alternative L1 block views.
 func (r *RuntimeConfig) Load(ctx context.Context, l1Ref eth.L1BlockRef) error {
-	val, err := r.l1Client.ReadStorageAt(ctx, r.rollupCfg.L1SystemConfigAddress, UnsafeBlockSignerAddressSystemConfigStorageSlot, l1Ref.Hash)
+	p2pSignerVal, err := r.l1Client.ReadStorageAt(ctx, r.rollupCfg.L1SystemConfigAddress, UnsafeBlockSignerAddressSystemConfigStorageSlot, l1Ref.Hash)
 	if err != nil {
 		return fmt.Errorf("failed to fetch unsafe block signing address from system config: %w", err)
 	}
+	// The superchain protocol version data is optional; only applicable to rollup configs that specify a ProtocolVersions address.
+	var requiredProtVersion, recommendedProtoVersion params.ProtocolVersion
+	if r.rollupCfg.ProtocolVersionsAddress != (common.Address{}) {
+		requiredVal, err := r.l1Client.ReadStorageAt(ctx, r.rollupCfg.ProtocolVersionsAddress, RequiredProtocolVersionStorageSlot, l1Ref.Hash)
+		if err != nil {
+			return fmt.Errorf("required-protocol-version value failed to load from L1 contract: %w", err)
+		}
+		requiredProtVersion = params.ProtocolVersion(requiredVal)
+		recommendedVal, err := r.l1Client.ReadStorageAt(ctx, r.rollupCfg.ProtocolVersionsAddress, RecommendedProtocolVersionStorageSlot, l1Ref.Hash)
+		if err != nil {
+			return fmt.Errorf("recommended-protocol-version value failed to load from L1 contract: %w", err)
+		}
+		recommendedProtoVersion = params.ProtocolVersion(recommendedVal)
+	}
 	r.mu.Lock()
 	defer r.mu.Unlock()
 	r.l1Ref = l1Ref
-	r.p2pBlockSignerAddr = common.BytesToAddress(val[:])
+	r.p2pBlockSignerAddr = common.BytesToAddress(p2pSignerVal[:])
+	r.required = requiredProtVersion
+	r.recommended = recommendedProtoVersion
 	r.log.Info("loaded new runtime config values!", "p2p_seq_address", r.p2pBlockSignerAddr)
 	return nil
 }

op-node/node/superchain.go

+package node
+
+import (
+	"context"
+
+	"github.com/ethereum-optimism/optimism/op-node/rollup"
+	"github.com/ethereum/go-ethereum/eth/catalyst"
+	"github.com/ethereum/go-ethereum/params"
+)
+
+func (n *OpNode) handleProtocolVersionsUpdate(ctx context.Context) {
+	recommended := n.runCfg.RecommendedProtocolVersion()
+	required := n.runCfg.RequiredProtocolVersion()
+	// if the protocol version sources are disabled we do not process them
+	if recommended == (params.ProtocolVersion{}) && required == (params.ProtocolVersion{}) {
+		return
+	}
+	local := rollup.OPStackSupport
+	// forward to execution engine, and get back the protocol version that op-geth supports
+	engineSupport, err := n.l2Source.SignalSuperchainV1(ctx, recommended, required)
+	if err != nil {
+		n.log.Warn("failed to notify engine of protocol version", "err", err)
+		// engineSupport may still be available, or otherwise zero to signal as unknown
+	} else {
+		catalyst.LogProtocolVersionSupport(n.log.New("node", "op-node"), engineSupport, recommended, "recommended")
+		catalyst.LogProtocolVersionSupport(n.log.New("node", "op-node"), engineSupport, required, "required")
+	}
+	n.metrics.ReportProtocolVersions(local, engineSupport, recommended, required)
+	catalyst.LogProtocolVersionSupport(n.log.New("node", "engine"), local, recommended, "recommended")
+	catalyst.LogProtocolVersionSupport(n.log.New("node", "engine"), local, required, "required")
+
+	// We may need to halt the node, if the user opted in to handling incompatible protocol-version signals
+	n.HaltMaybe()
+}
+
+// HaltMaybe halts the rollup node if the runtime config indicates an incompatible required protocol change
+// and the node is configured to opt-in to halting at this protocol-change level.
+func (n *OpNode) HaltMaybe() {
+	local := rollup.OPStackSupport
+	required := n.runCfg.RequiredProtocolVersion()
+	if haltMaybe(n.rollupHalt, local.Compare(required)) { // halt if we opted in to do so at this granularity
+		n.log.Error("Opted to halt, unprepared for protocol change", "required", required, "local", local)
+		if err := n.Close(); err != nil {
+			n.log.Error("Failed to halt rollup", "err", err)
+		}
+	}
+}
+
+// haltMaybe returns true when we should halt, given the halt-option and required-version comparison
+func haltMaybe(haltOption string, reqCmp params.ProtocolVersionComparison) bool {
+	var needLevel int
+	switch haltOption {
+	case "major":
+		needLevel = 3
+	case "minor":
+		needLevel = 2
+	case "patch":
+		needLevel = 1
+	default:
+		return false // do not consider halting if not configured to
+	}
+	haveLevel := 0
+	switch reqCmp {
+	case params.OutdatedMajor:
+		haveLevel = 3
+	case params.OutdatedMinor:
+		haveLevel = 2
+	case params.OutdatedPatch:
+		haveLevel = 1
+	}
+	return haveLevel >= needLevel
+}

op-node/node/superchain_test.go

+package node
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"golang.org/x/exp/slices"
+
+	"github.com/ethereum/go-ethereum/params"
+)
+
+func TestHaltMaybe(t *testing.T) {
+	haltTest := func(opt string, halts ...params.ProtocolVersionComparison) {
+		t.Run(opt, func(t *testing.T) {
+			for _, h := range []params.ProtocolVersionComparison{
+				params.AheadMajor,
+				params.OutdatedMajor,
+				params.AheadMinor,
+				params.OutdatedMinor,
+				params.AheadPatch,
+				params.OutdatedPatch,
+				params.AheadPrerelease,
+				params.OutdatedPrerelease,
+				params.Matching,
+				params.DiffVersionType,
+				params.DiffBuild,
+				params.EmptyVersion,
+			} {
+				expectedHalt := slices.Contains(halts, h)
+				gotHalt := haltMaybe(opt, h)
+				require.Equal(t, expectedHalt, gotHalt, "%s %d", opt, h)
+			}
+		})
+	}
+	haltTest("")
+	haltTest("major", params.OutdatedMajor)
+	haltTest("minor", params.OutdatedMajor, params.OutdatedMinor)
+	haltTest("patch", params.OutdatedMajor, params.OutdatedMinor, params.OutdatedPatch)
+}

op-node/rollup/driver/driver.go

@@ -81,6 +81,7 @@ type SequencerIface interface {
 	PlanNextSequencerAction() time.Duration
 	RunNextSequencerAction(ctx context.Context) (*eth.ExecutionPayload, error)
 	BuildingOnto() eth.L2BlockRef
+	CancelBuildingBlock(ctx context.Context)
 }
 
 type Network interface {

op-node/rollup/driver/state.go

@@ -381,6 +381,9 @@ func (s *Driver) eventLoop() {
 				}
 				s.log.Warn("Sequencer has been stopped")
 				s.driverConfig.SequencerStopped = true
+				// Cancel any inflight block building. If we don't cancel this, we can resume sequencing an old block
+				// even if we've received new unsafe heads in the interim, causing us to introduce a re-org.
+				s.sequencer.CancelBuildingBlock(ctx)
 				respCh <- hashAndError{hash: s.derivation.UnsafeL2Head().Hash}
 			}
 		case respCh := <-s.sequencerActive:

op-node/rollup/superchain.go

@@ -4,12 +4,16 @@ import (
 	"fmt"
 	"math/big"
 
+	"github.com/ethereum/go-ethereum/params"
+
 	"github.com/ethereum/go-ethereum/common"
 
 	"github.com/ethereum-optimism/optimism/op-service/eth"
 	"github.com/ethereum-optimism/superchain-registry/superchain"
 )
 
+var OPStackSupport = params.ProtocolVersionV0{Build: [8]byte{}, Major: 3, Minor: 1, Patch: 0, PreRelease: 1}.Encode()
+
 const (
 	opMainnet   = 10
 	opGoerli    = 420

op-node/rollup/types.go

@@ -84,6 +84,9 @@ type Config struct {
 	DepositContractAddress common.Address `json:"deposit_contract_address"`
 	// L1 System Config Address
 	L1SystemConfigAddress common.Address `json:"l1_system_config_address"`
+
+	// L1 address that declares the protocol versions, optional (Beta feature)
+	ProtocolVersionsAddress common.Address `json:"protocol_versions_address,omitempty"`
 }
 
 // ValidateL1Config checks L1 config variables for errors.
@@ -283,6 +286,8 @@ func (c *Config) Description(l2Chains map[string]string) string {
 	// Report the upgrade configuration
 	banner += "Post-Bedrock Network Upgrades (timestamp based):\n"
 	banner += fmt.Sprintf("  - Regolith: %s\n", fmtForkTimeOrUnset(c.RegolithTime))
+	// Report the protocol version
+	banner += fmt.Sprintf("Node supports up to OP-Stack Protocol Version: %s\n", OPStackSupport)
 	return banner
 }
 

op-node/service.go

@@ -36,6 +36,11 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*node.Config, error) {
 		return nil, err
 	}
 
+	if !ctx.Bool(flags.BetaRollupLoadProtocolVersions.Name) {
+		log.Info("Not opted in to ProtocolVersions signal loading, disabling ProtocolVersions contract now.")
+		rollupConfig.ProtocolVersionsAddress = common.Address{}
+	}
+
 	configPersistence := NewConfigPersistence(ctx)
 
 	driverConfig := NewDriverConfig(ctx)
@@ -61,6 +66,11 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*node.Config, error) {
 
 	syncConfig := NewSyncConfig(ctx)
 
+	haltOption := ctx.String(flags.BetaRollupHalt.Name)
+	if haltOption == "none" {
+		haltOption = ""
+	}
+
 	cfg := &node.Config{
 		L1:     l1Endpoint,
 		L2:     l2Endpoint,
@@ -93,6 +103,7 @@ func NewConfig(ctx *cli.Context, log log.Logger) (*node.Config, error) {
 		},
 		ConfigPersistence: configPersistence,
 		Sync:              *syncConfig,
+		RollupHalt:        haltOption,
 	}
 
 	if err := cfg.LoadPersisted(log); err != nil {

op-node/sources/engine_client.go

@@ -5,6 +5,9 @@ import (
 	"fmt"
 	"time"
 
+	"github.com/ethereum/go-ethereum/eth/catalyst"
+	"github.com/ethereum/go-ethereum/params"
+
 	"github.com/ethereum-optimism/optimism/op-node/client"
 	"github.com/ethereum-optimism/optimism/op-node/rollup"
 	"github.com/ethereum-optimism/optimism/op-node/sources/caching"
@@ -125,3 +128,12 @@ func (s *EngineClient) GetPayload(ctx context.Context, payloadId eth.PayloadID)
 	e.Trace("Received payload")
 	return &result, nil
 }
+
+func (s *EngineClient) SignalSuperchainV1(ctx context.Context, recommended, required params.ProtocolVersion) (params.ProtocolVersion, error) {
+	var result params.ProtocolVersion
+	err := s.client.CallContext(ctx, &result, "engine_signalSuperchainV1", &catalyst.SuperchainSignal{
+		Recommended: recommended,
+		Required:    required,
+	})
+	return result, err
+}

op-service/eth/account_proof.go

@@ -51,6 +51,9 @@ func (res *AccountResult) Verify(stateRoot common.Hash) error {
 		if err != nil {
 			return fmt.Errorf("failed to verify storage value %d with key %s (path %x) in storage trie %s: %w", i, entry.Key, path, res.StorageHash, err)
 		}
+		if val == nil && entry.Value.ToInt().Cmp(common.Big0) == 0 { // empty storage is zero by default
+			continue
+		}
 		comparison, err := rlp.EncodeToBytes(entry.Value.ToInt().Bytes())
 		if err != nil {
 			return fmt.Errorf("failed to encode storage value %d with key %s (path %x) in storage trie %s: %w", i, entry.Key, path, res.StorageHash, err)

op-service/txmgr/txmgr.go

@@ -211,14 +211,8 @@ func (m *SimpleTxManager) craftTx(ctx context.Context, candidate TxCandidate) (*
 	}
 	gasFeeCap := calcGasFeeCap(basefee, gasTipCap)
 
-	nonce, err := m.nextNonce(ctx)
-	if err != nil {
-		return nil, err
-	}
-
 	rawTx := &types.DynamicFeeTx{
 		ChainID:   m.chainID,
-		Nonce:     nonce,
 		To:        candidate.To,
 		GasTipCap: gasTipCap,
 		GasFeeCap: gasFeeCap,
@@ -247,6 +241,13 @@ func (m *SimpleTxManager) craftTx(ctx context.Context, candidate TxCandidate) (*
 		rawTx.Gas = gas
 	}
 
+	// Avoid bumping the nonce if the gas estimation fails.
+	nonce, err := m.nextNonce(ctx)
+	if err != nil {
+		return nil, err
+	}
+	rawTx.Nonce = nonce
+
 	ctx, cancel := context.WithTimeout(ctx, m.cfg.NetworkTimeout)
 	defer cancel()
 	return m.cfg.Signer(ctx, m.cfg.From, types.NewTx(rawTx))

op-service/txmgr/txmgr_test.go

@@ -93,6 +93,7 @@ type gasPricer struct {
 	mineAtEpoch   int64
 	baseGasTipFee *big.Int
 	baseBaseFee   *big.Int
+	err           error
 	mu            sync.Mutex
 }
 
@@ -206,6 +207,9 @@ func (b *mockBackend) HeaderByNumber(ctx context.Context, number *big.Int) (*typ
 }
 
 func (b *mockBackend) EstimateGas(ctx context.Context, msg ethereum.CallMsg) (uint64, error) {
+	if b.g.err != nil {
+		return 0, b.g.err
+	}
 	return b.g.basefee().Uint64(), nil
 }
 
@@ -420,6 +424,31 @@ func TestTxMgr_EstimateGas(t *testing.T) {
 	require.Equal(t, gasEstimate, tx.Gas())
 }
 
+func TestTxMgr_EstimateGasFails(t *testing.T) {
+	t.Parallel()
+	h := newTestHarness(t)
+	candidate := h.createTxCandidate()
+
+	// Set the gas limit to zero to trigger gas estimation.
+	candidate.GasLimit = 0
+
+	// Craft a successful transaction.
+	tx, err := h.mgr.craftTx(context.Background(), candidate)
+	require.Nil(t, err)
+	lastNonce := tx.Nonce()
+
+	// Mock gas estimation failure.
+	h.gasPricer.err = fmt.Errorf("execution error")
+	_, err = h.mgr.craftTx(context.Background(), candidate)
+	require.ErrorContains(t, err, "failed to estimate gas")
+
+	// Ensure successful craft uses the correct nonce
+	h.gasPricer.err = nil
+	tx, err = h.mgr.craftTx(context.Background(), candidate)
+	require.Nil(t, err)
+	require.Equal(t, lastNonce+1, tx.Nonce())
+}
+
 // TestTxMgrOnlyOnePublicationSucceeds asserts that the tx manager will return a
 // receipt so long as at least one of the publications is able to succeed with a
 // simulated rpc failure.

ops-bedrock/Dockerfile.l1

-FROM ethereum/client-go:v1.13.0
+FROM ethereum/client-go:v1.13.1
 
 RUN apk add --no-cache jq
 

package.json

@@ -45,7 +45,7 @@
     "@types/mocha": "^10.0.1",
     "@types/node": "^20.5.3",
     "@typescript-eslint/eslint-plugin": "^6.7.0",
-    "@typescript-eslint/parser": "^5.60.1",
+    "@typescript-eslint/parser": "^6.7.0",
     "chai": "^4.2.0",
     "depcheck": "^1.4.3",
     "doctoc": "^2.2.0",

packages/contracts-bedrock/.gas-snapshot

@@ -526,6 +526,10 @@ PreimageOracle_Test:test_loadKeccak256PreimagePart_outOfBoundsOffset_reverts() (
 PreimageOracle_Test:test_loadKeccak256PreimagePart_succeeds() (gas: 76098)
 PreimageOracle_Test:test_loadLocalData_onePart_succeeds() (gas: 75840)
 PreimageOracle_Test:test_loadLocalData_outOfBoundsOffset_reverts() (gas: 8803)
+ProtocolVersions_Initialize_Test:test_initialize_events_succeeds() (gas: 52175)
+ProtocolVersions_Initialize_Test:test_initialize_values_succeeds() (gas: 32301)
+ProtocolVersions_Setters_TestFail:test_setRecommended_notOwner_reverts() (gas: 15508)
+ProtocolVersions_Setters_TestFail:test_setRequired_notOwner_reverts() (gas: 15520)
 ProxyAdmin_Test:test_chugsplashChangeProxyAdmin_succeeds() (gas: 35586)
 ProxyAdmin_Test:test_chugsplashGetProxyAdmin_succeeds() (gas: 15675)
 ProxyAdmin_Test:test_chugsplashGetProxyImplementation_succeeds() (gas: 51084)
@@ -666,4 +670,4 @@ TransactorTest:test_constructor_succeeds() (gas: 9739)
 TransactorTest:test_delegateCall_succeeds() (gas: 20909)
 TransactorTest:test_delegateCall_unauthorized_reverts() (gas: 16550)
 TransferOnionTest:test_constructor_succeeds() (gas: 564855)
-TransferOnionTest:test_unwrap_succeeds() (gas: 724955)
+TransferOnionTest:test_unwrap_succeeds() (gas: 724955)
\ No newline at end of file

packages/contracts-bedrock/deploy-config/devnetL1-template.json

@@ -46,5 +46,7 @@
   "faultGameAbsolutePrestate": "0x03c7ae758795765c6664a5d39bf63841c71ff191e9189522bad8ebff5d4eca98",
   "faultGameMaxDepth": 30,
   "faultGameMaxDuration": 1200,
-  "systemConfigStartBlock": 0
+  "systemConfigStartBlock": 0,
+  "requiredProtocolVersion": "0x0000000000000000000000000000000000000000000000000000000000000000",
+  "recommendedProtocolVersion": "0x0000000000000000000000000000000000000000000000000000000000000000"
 }

packages/contracts-bedrock/scripts/Deploy.s.sol

@@ -28,6 +28,7 @@ import { PreimageOracle } from "src/cannon/PreimageOracle.sol";
 import { MIPS } from "src/cannon/MIPS.sol";
 import { BlockOracle } from "src/dispute/BlockOracle.sol";
 import { L1ERC721Bridge } from "src/L1/L1ERC721Bridge.sol";
+import { ProtocolVersions, ProtocolVersion } from "src/L1/ProtocolVersions.sol";
 import { Predeploys } from "src/libraries/Predeploys.sol";
 import { Chains } from "./Chains.sol";
 
@@ -47,7 +48,7 @@ contract Deploy is Deployer {
     /// @notice The create2 salt used for deployment of the contract implementations.
     ///         Using this helps to reduce config across networks as the implementation
     ///         addresses will be the same across networks when deployed with create2.
-    bytes32 constant IMPL_SALT = bytes32("ether's phoenix");
+    bytes32 constant IMPL_SALT = keccak256(bytes("ether's phoenix"));
 
     /// @notice The name of the script, used to ensure the right deploy artifacts
     ///         are used.
@@ -80,6 +81,7 @@ contract Deploy is Deployer {
         initializeL1CrossDomainMessenger();
         initializeL2OutputOracle();
         initializeOptimismPortal();
+        initializeProtocolVersions();
 
         setAlphabetFaultGameImplementation();
         setCannonFaultGameImplementation();
@@ -103,6 +105,18 @@ contract Deploy is Deployer {
         }
     }
 
+    /// @notice Modifier that will only allow a function to be called on a public
+    ///         testnet or devnet.
+    modifier onlyTestnetOrDevnet() {
+        uint256 chainid = block.chainid;
+        if (
+            chainid == Chains.Goerli || chainid == Chains.Sepolia || chainid == Chains.LocalDevnet
+                || chainid == Chains.GethDevnet
+        ) {
+            _;
+        }
+    }
+
     /// @notice Deploy all of the proxies
     function deployProxies() public {
         deployAddressManager();
@@ -116,6 +130,7 @@ contract Deploy is Deployer {
         deployOptimismMintableERC20FactoryProxy();
         deployL1ERC721BridgeProxy();
         deployDisputeGameFactoryProxy();
+        deployProtocolVersionsProxy();
 
         transferAddressManagerOwnership();
     }
@@ -133,6 +148,7 @@ contract Deploy is Deployer {
         deployBlockOracle();
         deployPreimageOracle();
         deployMips();
+        deployProtocolVersions();
     }
 
     /// @notice Deploy the AddressManager
@@ -291,6 +307,22 @@ contract Deploy is Deployer {
         addr_ = address(proxy);
     }
 
+    /// @notice Deploy the ProtocolVersionsProxy
+    function deployProtocolVersionsProxy() public onlyTestnetOrDevnet broadcast returns (address addr_) {
+        address proxyAdmin = mustGetAddress("ProxyAdmin");
+        Proxy proxy = new Proxy({
+            _admin: proxyAdmin
+        });
+
+        address admin = address(uint160(uint256(vm.load(address(proxy), OWNER_KEY))));
+        require(admin == proxyAdmin);
+
+        save("ProtocolVersionsProxy", address(proxy));
+        console.log("ProtocolVersionsProxy deployed at %s", address(proxy));
+
+        addr_ = address(proxy);
+    }
+
     /// @notice Deploy the L1CrossDomainMessenger
     function deployL1CrossDomainMessenger() public broadcast returns (address addr_) {
         L1CrossDomainMessenger messenger = new L1CrossDomainMessenger{ salt: IMPL_SALT }();
@@ -380,6 +412,15 @@ contract Deploy is Deployer {
         addr_ = address(oracle);
     }
 
+    /// @notice Deploy the ProtocolVersions
+    function deployProtocolVersions() public onlyTestnetOrDevnet broadcast returns (address addr_) {
+        ProtocolVersions versions = new ProtocolVersions{ salt: IMPL_SALT }();
+        save("ProtocolVersions", address(versions));
+        console.log("ProtocolVersions deployed at %s", address(versions));
+
+        addr_ = address(versions);
+    }
+
     /// @notice Deploy the PreimageOracle
     function deployPreimageOracle() public onlyDevnet broadcast returns (address addr_) {
         PreimageOracle preimageOracle = new PreimageOracle{ salt: IMPL_SALT }();
@@ -742,6 +783,37 @@ contract Deploy is Deployer {
         require(portal.paused() == false);
     }
 
+    function initializeProtocolVersions() public onlyTestnetOrDevnet broadcast {
+        ProxyAdmin proxyAdmin = ProxyAdmin(mustGetAddress("ProxyAdmin"));
+        address protocolVersionsProxy = mustGetAddress("ProtocolVersionsProxy");
+        address protocolVersions = mustGetAddress("ProtocolVersions");
+
+        address finalSystemOwner = cfg.finalSystemOwner();
+        uint256 requiredProtocolVersion = cfg.requiredProtocolVersion();
+        uint256 recommendedProtocolVersion = cfg.recommendedProtocolVersion();
+
+        proxyAdmin.upgradeAndCall({
+            _proxy: payable(protocolVersionsProxy),
+            _implementation: protocolVersions,
+            _data: abi.encodeCall(
+                ProtocolVersions.initialize,
+                (
+                    finalSystemOwner,
+                    ProtocolVersion.wrap(requiredProtocolVersion),
+                    ProtocolVersion.wrap(recommendedProtocolVersion)
+                )
+                )
+        });
+
+        ProtocolVersions versions = ProtocolVersions(protocolVersionsProxy);
+        string memory version = versions.version();
+        console.log("ProtocolVersions version: %s", version);
+
+        require(versions.owner() == finalSystemOwner);
+        require(ProtocolVersion.unwrap(versions.required()) == requiredProtocolVersion);
+        require(ProtocolVersion.unwrap(versions.recommended()) == recommendedProtocolVersion);
+    }
+
     /// @notice Transfer ownership of the ProxyAdmin contract to the final system owner
     function transferProxyAdminOwnership() public broadcast {
         ProxyAdmin proxyAdmin = ProxyAdmin(mustGetAddress("ProxyAdmin"));

packages/contracts-bedrock/scripts/DeployConfig.s.sol

@@ -48,6 +48,8 @@ contract DeployConfig is Script {
     uint256 public faultGameMaxDepth;
     uint256 public faultGameMaxDuration;
     uint256 public systemConfigStartBlock;
+    uint256 public requiredProtocolVersion;
+    uint256 public recommendedProtocolVersion;
 
     constructor(string memory _path) {
         console.log("DeployConfig: reading file %s", _path);
@@ -94,6 +96,13 @@ contract DeployConfig is Script {
             faultGameAbsolutePrestate = stdJson.readUint(_json, "$.faultGameAbsolutePrestate");
             faultGameMaxDepth = stdJson.readUint(_json, "$.faultGameMaxDepth");
             faultGameMaxDuration = stdJson.readUint(_json, "$.faultGameMaxDuration");
+            requiredProtocolVersion = stdJson.readUint(_json, "$.requiredProtocolVersion");
+            recommendedProtocolVersion = stdJson.readUint(_json, "$.recommendedProtocolVersion");
+        }
+
+        if (block.chainid == Chains.Goerli || block.chainid == Chains.Sepolia) {
+            requiredProtocolVersion = stdJson.readUint(_json, "$.requiredProtocolVersion");
+            recommendedProtocolVersion = stdJson.readUint(_json, "$.recommendedProtocolVersion");
         }
     }
 

packages/contracts-bedrock/semver-lock.json

@@ -6,6 +6,7 @@
   "src/L1/L1StandardBridge.sol": "0x12e227c6054660a83b92d823a7447db96a7d476b7a94e0f1807772d400329880",
   "src/L1/L2OutputOracle.sol": "0x2e298bccb5fe73cf365e23bb56ebe974534549e0052bfe0f86372c52067153e6",
   "src/L1/OptimismPortal.sol": "0xc8e41a7c3405c1b04c98f4b6bc7d20ff6f20cd3132134a3106670f5a475978c7",
+  "src/L1/ProtocolVersions.sol": "0x2f980d89b583936c7af5d71a1e2c73d026d895c1687abdd09815e4581032cee5",
   "src/L1/SystemConfig.sol": "0xd508b84ef7c6d57be1e2e7eef92fc340f6bb3d68d999bdf2fabe12d110f9615c",
   "src/L2/BaseFeeVault.sol": "0xc347c1aebe69178e72d2b1d3e700bbf84e39975319465bb85d69fd0d60fc1759",
   "src/L2/GasPriceOracle.sol": "0x88efffbd40f8d012d700a5d7fde0d92266f65e9d7006cd8f034bacaa036d0eb2",

packages/contracts-bedrock/src/L1/ProtocolVersions.sol

+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+import { OwnableUpgradeable } from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import { ISemver } from "src/universal/ISemver.sol";
+
+/// @notice ProtocolVersion is a numeric identifier of the protocol version.
+type ProtocolVersion is uint256;
+
+/// @title ProtocolVersions
+/// @notice The ProtocolVersions contract is used to manage superchain protocol version information.
+contract ProtocolVersions is OwnableUpgradeable, ISemver {
+    /// @notice Enum representing different types of updates.
+    /// @custom:value REQUIRED_PROTOCOL_VERSION              Represents an update to the required protocol version.
+    /// @custom:value RECOMMENDED_PROTOCOL_VERSION           Represents an update to the recommended protocol version.
+    enum UpdateType {
+        REQUIRED_PROTOCOL_VERSION,
+        RECOMMENDED_PROTOCOL_VERSION
+    }
+
+    /// @notice Version identifier, used for upgrades.
+    uint256 public constant VERSION = 0;
+
+    /// @notice Storage slot that the required protocol version is stored at.
+    bytes32 public constant REQUIRED_SLOT = bytes32(uint256(keccak256("protocolversion.required")) - 1);
+
+    /// @notice Storage slot that the recommended protocol version is stored at.
+    bytes32 public constant RECOMMENDED_SLOT = bytes32(uint256(keccak256("protocolversion.recommended")) - 1);
+
+    /// @notice Emitted when configuration is updated.
+    /// @param version    ProtocolVersion version.
+    /// @param updateType Type of update.
+    /// @param data       Encoded update data.
+    event ConfigUpdate(uint256 indexed version, UpdateType indexed updateType, bytes data);
+
+    /// @notice Semantic version.
+    /// @custom:semver 0.1.0
+    string public constant version = "0.1.0";
+
+    /// @notice Constructs the ProtocolVersion contract. Cannot set
+    ///         the owner to `address(0)` due to the Ownable contract's
+    ///         implementation, so set it to `address(0xdEaD)`
+    ///         A zero version is considered empty and is ignored by nodes.
+    constructor() {
+        initialize({
+            _owner: address(0xdEaD),
+            _required: ProtocolVersion.wrap(uint256(0)),
+            _recommended: ProtocolVersion.wrap(uint256(0))
+        });
+    }
+
+    /// @notice Initializer.
+    /// @param _owner             Initial owner of the contract.
+    /// @param _required          Required protocol version to operate on this chain.
+    /// @param _recommended       Recommended protocol version to operate on thi chain.
+    function initialize(
+        address _owner,
+        ProtocolVersion _required,
+        ProtocolVersion _recommended
+    )
+        public
+        reinitializer(2)
+    {
+        __Ownable_init();
+        transferOwnership(_owner);
+        _setRequired(_required);
+        _setRecommended(_recommended);
+    }
+
+    /// @notice Returns a ProtocolVersion stored in an arbitrary storage slot.
+    ///         These storage slots decouple the storage layout from solc's automation.
+    /// @param _slot The storage slot to retrieve the address from.
+    function _getProtocolVersion(bytes32 _slot) internal view returns (ProtocolVersion out_) {
+        assembly {
+            out_ := sload(_slot)
+        }
+    }
+
+    /// @notice Stores a ProtocolVersion in an arbitrary storage slot, `_slot`.
+    /// @param _version The protocol version to store
+    /// @param _slot The storage slot to store the address in.
+    /// @dev WARNING! This function must be used cautiously, as it allows for overwriting values
+    ///      in arbitrary storage slots.
+    function _setProtocolVersion(ProtocolVersion _version, bytes32 _slot) internal {
+        assembly {
+            sstore(_slot, _version)
+        }
+    }
+
+    /// @notice High level getter for the required protocol version.
+    /// @return out_ Required protocol version to sync to the head of the chain.
+    function required() external view returns (ProtocolVersion out_) {
+        out_ = _getProtocolVersion(REQUIRED_SLOT);
+    }
+
+    /// @notice Updates the required protocol version. Can only be called by the owner.
+    /// @param _required New required protocol version.
+    function setRequired(ProtocolVersion _required) external onlyOwner {
+        _setRequired(_required);
+    }
+
+    /// @notice Internal function for updating the required protocol version.
+    /// @param _required New required protocol version.
+    function _setRequired(ProtocolVersion _required) internal {
+        _setProtocolVersion(_required, REQUIRED_SLOT);
+
+        bytes memory data = abi.encode(_required);
+        emit ConfigUpdate(VERSION, UpdateType.REQUIRED_PROTOCOL_VERSION, data);
+    }
+
+    /// @notice High level getter for the recommended protocol version.
+    /// @return out_ Recommended protocol version to sync to the head of the chain.
+    function recommended() external view returns (ProtocolVersion out_) {
+        out_ = _getProtocolVersion(RECOMMENDED_SLOT);
+    }
+
+    /// @notice Updates the recommended protocol version. Can only be called by the owner.
+    /// @param _recommended New recommended protocol version.
+    function setRecommended(ProtocolVersion _recommended) external onlyOwner {
+        _setRecommended(_recommended);
+    }
+
+    /// @notice Internal function for updating the recommended protocol version.
+    /// @param _recommended New recommended protocol version.
+    function _setRecommended(ProtocolVersion _recommended) internal {
+        _setProtocolVersion(_recommended, RECOMMENDED_SLOT);
+
+        bytes memory data = abi.encode(_recommended);
+        emit ConfigUpdate(VERSION, UpdateType.RECOMMENDED_PROTOCOL_VERSION, data);
+    }
+}

packages/contracts-bedrock/test/ProtocolVersions.t.sol

+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
+
+// Testing utilities
+import { CommonTest } from "./CommonTest.t.sol";
+
+// Libraries
+import { Constants } from "src/libraries/Constants.sol";
+
+// Target contract dependencies
+import { Proxy } from "src/universal/Proxy.sol";
+
+// Target contract
+import { ProtocolVersions, ProtocolVersion } from "src/L1/ProtocolVersions.sol";
+
+contract ProtocolVersions_Init is CommonTest {
+    ProtocolVersions protocolVersions;
+    ProtocolVersions protocolVersionsImpl;
+
+    event ConfigUpdate(uint256 indexed version, ProtocolVersions.UpdateType indexed updateType, bytes data);
+
+    // Dummy values used to test getters
+    ProtocolVersion constant required = ProtocolVersion.wrap(0xabcd);
+    ProtocolVersion constant recommended = ProtocolVersion.wrap(0x1234);
+
+    function setUp() public virtual override {
+        super.setUp();
+
+        Proxy proxy = new Proxy(multisig);
+        protocolVersionsImpl = new ProtocolVersions();
+
+        vm.prank(multisig);
+        proxy.upgradeToAndCall(
+            address(protocolVersionsImpl),
+            abi.encodeCall(
+                ProtocolVersions.initialize,
+                (
+                    alice, // _owner,
+                    required,
+                    recommended
+                )
+            )
+        );
+
+        protocolVersions = ProtocolVersions(address(proxy));
+    }
+}
+
+contract ProtocolVersions_Initialize_Test is ProtocolVersions_Init {
+    /// @dev Tests that initialization sets the correct values.
+    function test_initialize_values_succeeds() external {
+        assertEq(ProtocolVersion.unwrap(protocolVersions.required()), ProtocolVersion.unwrap(required));
+        assertEq(ProtocolVersion.unwrap(protocolVersions.recommended()), ProtocolVersion.unwrap(recommended));
+        assertEq(protocolVersions.owner(), alice);
+
+        assertEq(ProtocolVersion.unwrap(protocolVersionsImpl.required()), 0);
+        assertEq(ProtocolVersion.unwrap(protocolVersionsImpl.recommended()), 0);
+        assertEq(protocolVersionsImpl.owner(), address(0xdEad));
+    }
+
+    /// @dev Ensures that the events are emitted during initialization.
+    function test_initialize_events_succeeds() external {
+        assertEq(protocolVersionsImpl.owner(), address(0xdEad));
+
+        // Wipe out the initialized slot so the proxy can be initialized again
+        vm.store(address(protocolVersions), bytes32(0), bytes32(0));
+
+        // The order depends here
+        vm.expectEmit(true, true, true, true, address(protocolVersions));
+        emit ConfigUpdate(0, ProtocolVersions.UpdateType.REQUIRED_PROTOCOL_VERSION, abi.encode(required));
+        vm.expectEmit(true, true, true, true, address(protocolVersions));
+        emit ConfigUpdate(0, ProtocolVersions.UpdateType.RECOMMENDED_PROTOCOL_VERSION, abi.encode(recommended));
+
+        vm.prank(multisig);
+        Proxy(payable(address(protocolVersions))).upgradeToAndCall(
+            address(protocolVersionsImpl),
+            abi.encodeCall(
+                ProtocolVersions.initialize,
+                (
+                    alice, // _owner
+                    required, // _required
+                    recommended // recommended
+                )
+            )
+        );
+    }
+}
+
+contract ProtocolVersions_Setters_TestFail is ProtocolVersions_Init {
+    /// @dev Tests that `setRequired` reverts if the caller is not the owner.
+    function test_setRequired_notOwner_reverts() external {
+        vm.expectRevert("Ownable: caller is not the owner");
+        protocolVersions.setRequired(ProtocolVersion.wrap(0));
+    }
+
+    /// @dev Tests that `setRecommended` reverts if the caller is not the owner.
+    function test_setRecommended_notOwner_reverts() external {
+        vm.expectRevert("Ownable: caller is not the owner");
+        protocolVersions.setRecommended(ProtocolVersion.wrap(0));
+    }
+}
+
+contract ProtocolVersions_Setters_Test is ProtocolVersions_Init {
+    /// @dev Tests that `setRequired` updates the required protocol version successfully.
+    function testFuzz_setRequired_succeeds(uint256 _version) external {
+        vm.expectEmit(true, true, true, true);
+        emit ConfigUpdate(0, ProtocolVersions.UpdateType.REQUIRED_PROTOCOL_VERSION, abi.encode(_version));
+
+        vm.prank(protocolVersions.owner());
+        protocolVersions.setRequired(ProtocolVersion.wrap(_version));
+        assertEq(ProtocolVersion.unwrap(protocolVersions.required()), _version);
+    }
+
+    /// @dev Tests that `setRecommended` updates the recommended protocol version successfully.
+    function testFuzz_setRecommended_succeeds(uint256 _version) external {
+        vm.expectEmit(true, true, true, true);
+        emit ConfigUpdate(0, ProtocolVersions.UpdateType.RECOMMENDED_PROTOCOL_VERSION, abi.encode(_version));
+
+        vm.prank(protocolVersions.owner());
+        protocolVersions.setRecommended(ProtocolVersion.wrap(_version));
+        assertEq(ProtocolVersion.unwrap(protocolVersions.recommended()), _version);
+    }
+}

packages/sdk/src/interfaces/types.ts

@@ -15,6 +15,7 @@ import { IBridgeAdapter } from './bridge-adapter'
 export enum L1ChainID {
   MAINNET = 1,
   GOERLI = 5,
+  SEPOLIA = 11155111,
   HARDHAT_LOCAL = 31337,
   BEDROCK_LOCAL_DEVNET = 900,
 }
@@ -25,6 +26,7 @@ export enum L1ChainID {
 export enum L2ChainID {
   OPTIMISM = 10,
   OPTIMISM_GOERLI = 420,
+  OPTIMISM_SEPOLIA = 11155420,
   OPTIMISM_HARDHAT_LOCAL = 31337,
   OPTIMISM_HARDHAT_DEVNET = 17,
   OPTIMISM_BEDROCK_ALPHA_TESTNET = 28528,

packages/sdk/src/utils/chain-constants.ts

@@ -2,50 +2,62 @@ import { predeploys } from '@eth-optimism/core-utils'
 import { ethers } from 'ethers'
 import portalArtifactsMainnet from '@eth-optimism/contracts-bedrock/deployments/mainnet/OptimismPortalProxy.json'
 import portalArtifactsGoerli from '@eth-optimism/contracts-bedrock/deployments/goerli/OptimismPortalProxy.json'
+import portalArtifactsSepolia from '@eth-optimism/contracts-bedrock/deployments/sepolia/OptimismPortalProxy.json'
 import l2OutputOracleArtifactsMainnet from '@eth-optimism/contracts-bedrock/deployments/mainnet/L2OutputOracleProxy.json'
 import l2OutputOracleArtifactsGoerli from '@eth-optimism/contracts-bedrock/deployments/goerli/L2OutputOracleProxy.json'
+import l2OutputOracleArtifactsSepolia from '@eth-optimism/contracts-bedrock/deployments/sepolia/L2OutputOracleProxy.json'
 import addressManagerArtifactMainnet from '@eth-optimism/contracts-bedrock/deployments/mainnet/AddressManager.json'
 import addressManagerArtifactGoerli from '@eth-optimism/contracts-bedrock/deployments/goerli/AddressManager.json'
+import addressManagerArtifactSepolia from '@eth-optimism/contracts-bedrock/deployments/sepolia/AddressManager.json'
 import l1StandardBridgeArtifactMainnet from '@eth-optimism/contracts-bedrock/deployments/mainnet/L1StandardBridgeProxy.json'
 import l1StandardBridgeArtifactGoerli from '@eth-optimism/contracts-bedrock/deployments/goerli/L1StandardBridgeProxy.json'
+import l1StandardBridgeArtifactSepolia from '@eth-optimism/contracts-bedrock/deployments/sepolia/L1StandardBridgeProxy.json'
 import l1CrossDomainMessengerArtifactMainnet from '@eth-optimism/contracts-bedrock/deployments/mainnet/L1CrossDomainMessengerProxy.json'
 import l1CrossDomainMessengerArtifactGoerli from '@eth-optimism/contracts-bedrock/deployments/goerli/L1CrossDomainMessengerProxy.json'
+import l1CrossDomainMessengerArtifactSepolia from '@eth-optimism/contracts-bedrock/deployments/sepolia/L1CrossDomainMessengerProxy.json'
 
 const portalAddresses = {
   mainnet: portalArtifactsMainnet.address,
   goerli: portalArtifactsGoerli.address,
+  sepolia: portalArtifactsSepolia.address,
 }
 
 const l2OutputOracleAddresses = {
   mainnet: l2OutputOracleArtifactsMainnet.address,
   goerli: l2OutputOracleArtifactsGoerli.address,
+  sepolia: l2OutputOracleArtifactsSepolia.address,
 }
 
 const addressManagerAddresses = {
   mainnet: addressManagerArtifactMainnet.address,
   goerli: addressManagerArtifactGoerli.address,
+  sepolia: addressManagerArtifactSepolia.address,
 }
 
 const l1StandardBridgeAddresses = {
   mainnet: l1StandardBridgeArtifactMainnet.address,
   goerli: l1StandardBridgeArtifactGoerli.address,
+  sepolia: l1StandardBridgeArtifactSepolia.address,
 }
 
 const l1CrossDomainMessengerAddresses = {
   mainnet: l1CrossDomainMessengerArtifactMainnet.address,
   goerli: l1CrossDomainMessengerArtifactGoerli.address,
+  sepolia: l1CrossDomainMessengerArtifactSepolia.address,
 }
 
 // legacy
 const stateCommitmentChainAddresses = {
   mainnet: '0xBe5dAb4A2e9cd0F27300dB4aB94BeE3A233AEB19',
   goerli: '0x9c945aC97Baf48cB784AbBB61399beB71aF7A378',
+  sepolia: ethers.constants.AddressZero,
 }
 
 // legacy
 const canonicalTransactionChainAddresses = {
   mainnet: '0x5E4e65926BA27467555EB562121fac00D24E9dD2',
   goerli: '0x607F755149cFEB3a14E1Dc3A4E2450Cde7dfb04D',
+  sepolia: ethers.constants.AddressZero,
 }
 
 import {
@@ -67,6 +79,7 @@ export const DEPOSIT_CONFIRMATION_BLOCKS: {
 } = {
   [L2ChainID.OPTIMISM]: 50 as const,
   [L2ChainID.OPTIMISM_GOERLI]: 12 as const,
+  [L2ChainID.OPTIMISM_SEPOLIA]: 12 as const,
   [L2ChainID.OPTIMISM_HARDHAT_LOCAL]: 2 as const,
   [L2ChainID.OPTIMISM_HARDHAT_DEVNET]: 2 as const,
   [L2ChainID.OPTIMISM_BEDROCK_ALPHA_TESTNET]: 12 as const,
@@ -81,6 +94,7 @@ export const CHAIN_BLOCK_TIMES: {
 } = {
   [L1ChainID.MAINNET]: 13 as const,
   [L1ChainID.GOERLI]: 15 as const,
+  [L1ChainID.SEPOLIA]: 15 as const,
   [L1ChainID.HARDHAT_LOCAL]: 1 as const,
   [L1ChainID.BEDROCK_LOCAL_DEVNET]: 15 as const,
 }
@@ -137,6 +151,10 @@ export const CONTRACT_ADDRESSES: {
     l1: getL1ContractsByNetworkName('goerli'),
     l2: DEFAULT_L2_CONTRACT_ADDRESSES,
   },
+  [L2ChainID.OPTIMISM_SEPOLIA]: {
+    l1: getL1ContractsByNetworkName('sepolia'),
+    l2: DEFAULT_L2_CONTRACT_ADDRESSES,
+  },
   [L2ChainID.OPTIMISM_HARDHAT_LOCAL]: {
     l1: {
       AddressManager: '0x5FbDB2315678afecb367f032d93F642f64180aa3' as const,

pnpm-lock.yaml

@@ -38,10 +38,10 @@ importers:
         version: 20.5.3
       '@typescript-eslint/eslint-plugin':
         specifier: ^6.7.0
-        version: 6.7.0(@typescript-eslint/parser@5.60.1)(eslint@8.49.0)(typescript@5.1.6)
+        version: 6.7.0(@typescript-eslint/parser@6.7.0)(eslint@8.49.0)(typescript@5.1.6)
       '@typescript-eslint/parser':
-        specifier: ^5.60.1
-        version: 5.60.1(eslint@8.49.0)(typescript@5.1.6)
+        specifier: ^6.7.0
+        version: 6.7.0(eslint@8.49.0)(typescript@5.1.6)
       chai:
         specifier: ^4.2.0
         version: 4.3.7
@@ -62,7 +62,7 @@ importers:
         version: 16.0.3(eslint-plugin-import@2.28.1)(eslint-plugin-node@11.1.0)(eslint-plugin-promise@5.2.0)(eslint@8.49.0)
       eslint-plugin-import:
         specifier: ^2.26.0
-        version: 2.28.1(@typescript-eslint/parser@5.60.1)(eslint@8.49.0)
+        version: 2.28.1(@typescript-eslint/parser@6.7.0)(eslint@8.49.0)
       eslint-plugin-jsdoc:
         specifier: ^35.1.2
         version: 35.5.1(eslint@8.49.0)
@@ -126,6 +126,15 @@ importers:
 
   endpoint-monitor: {}
 
+  indexer/api-ts:
+    devDependencies:
+      tsup:
+        specifier: ^7.2.0
+        version: 7.2.0(@swc/core@1.3.76)(typescript@5.1.6)
+      vitest:
+        specifier: ^0.34.4
+        version: 0.34.4
+
   op-exporter: {}
 
   packages/chain-mon:
@@ -175,7 +184,7 @@ importers:
         version: 2.17.2(ts-node@10.9.1)(typescript@5.2.2)
       ts-node:
         specifier: ^10.9.1
-        version: 10.9.1(@types/node@20.6.0)(typescript@5.2.2)
+        version: 10.9.1(@types/node@20.6.1)(typescript@5.2.2)
       tsx:
         specifier: ^3.12.7
         version: 3.12.7
@@ -3702,20 +3711,20 @@ packages:
   /@types/bn.js@4.11.6:
     resolution: {integrity: sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/bn.js@5.1.0:
     resolution: {integrity: sha512-QSSVYj7pYFN49kW77o2s9xTCwZ8F2xLbjLLSEVh8D2F4JUhZtPAGOFLTD+ffqksBx/u4cE/KImFjyhqCjn/LIA==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/body-parser@1.19.1:
     resolution: {integrity: sha512-a6bTJ21vFOGIkwM0kzh9Yr89ziVxq4vYH2fQ6N8AeipEzai/cFK6aGMArIkUeIdRIgpwQa+2bXiLuUJCpSf2Cg==}
     dependencies:
       '@types/connect': 3.4.35
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/chai-as-promised@7.1.5:
@@ -3741,7 +3750,7 @@ packages:
   /@types/connect@3.4.35:
     resolution: {integrity: sha512-cdeYyv4KWoEgpBISTxWvqYsVy444DOqehiF3fM3ne10AmJ62RSyNkUnxMJXHQWRQQX2eR94m5y1IZyDwBjV9FQ==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
 
   /@types/dateformat@5.0.0:
     resolution: {integrity: sha512-SZg4JdHIWHQGEokbYGZSDvo5wA4TLYPXaqhigs/wH+REDOejcJzgH+qyY+HtEUtWOZxEUkbhbdYPqQDiEgrXeA==}
@@ -3755,7 +3764,7 @@ packages:
   /@types/express-serve-static-core@4.17.35:
     resolution: {integrity: sha512-wALWQwrgiB2AWTT91CB62b6Yt0sNHpznUXeZEcnPU3DRdlDIz74x8Qg1UUYKSVFi+va5vKOLYRBI1bRKiLLKIg==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
       '@types/qs': 6.9.7
       '@types/range-parser': 1.2.4
       '@types/send': 0.17.1
@@ -3801,7 +3810,7 @@ packages:
     dependencies:
       '@types/abstract-leveldown': 5.0.2
       '@types/level-errors': 3.0.0
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/lru-cache@5.1.1:
@@ -3833,7 +3842,7 @@ packages:
   /@types/mkdirp@0.5.2:
     resolution: {integrity: sha512-U5icWpv7YnZYGsN4/cmh3WD2onMY0aJIiTE6+51TwJCttdHvtCYmkBNOobHlXwrJRL0nkH9jH4kD+1FAdMN4Tg==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/mocha@10.0.1:
@@ -3852,7 +3861,7 @@ packages:
   /@types/node-fetch@2.6.4:
     resolution: {integrity: sha512-1ZX9fcN4Rvkvgv4E6PAY5WXUFWFcRWxZa3EW83UjycOB9ljJCedb2CupIP4RZMEwF/M3eTcCihbBRgwtGbg5Rg==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
       form-data: 3.0.1
     dev: true
 
@@ -3873,6 +3882,10 @@ packages:
 
   /@types/node@20.6.0:
     resolution: {integrity: sha512-najjVq5KN2vsH2U/xyh2opaSEz6cZMR2SetLIlxlj08nOcmPOemJmUK2o4kUzfLqfrWE0PIrNeE16XhYDd3nqg==}
+    dev: true
+
+  /@types/node@20.6.1:
+    resolution: {integrity: sha512-4LcJvuXQlv4lTHnxwyHQZ3uR9Zw2j7m1C9DfuwoTFQQP4Pmu04O6IfLYgMmHoOCt0nosItLLZAH+sOrRE0Bo8g==}
 
   /@types/normalize-package-data@2.4.1:
     resolution: {integrity: sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==}
@@ -3884,7 +3897,7 @@ packages:
   /@types/pbkdf2@3.1.0:
     resolution: {integrity: sha512-Cf63Rv7jCQ0LaL8tNXmEyqTHuIJxRdlS5vMh1mj5voN4+QFhVZnlZruezqpWYDiJ8UTzhP0VmeLXCmBk66YrMQ==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/pino-multi-stream@5.1.3:
@@ -3902,13 +3915,13 @@ packages:
   /@types/pino-std-serializers@2.4.1:
     resolution: {integrity: sha512-17XcksO47M24IVTVKPeAByWUd3Oez7EbIjXpSbzMPhXVzgjGtrOa49gKBwxH9hb8dKv58OelsWQ+A1G1l9S3wQ==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/pino@6.3.11:
     resolution: {integrity: sha512-S7+fLONqSpHeW9d7TApUqO6VN47KYgOXhCNKwGBVLHObq8HhaAYlVqUNdfnvoXjCMiwE5xcPm/5R2ZUh8bgaXQ==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
       '@types/pino-pretty': 4.7.1
       '@types/pino-std-serializers': 2.4.1
       sonic-boom: 2.8.0
@@ -3954,7 +3967,7 @@ packages:
   /@types/readable-stream@2.3.15:
     resolution: {integrity: sha512-oM5JSKQCcICF1wvGgmecmHldZ48OZamtMxcGGVICOJA8o8cahXC1zEVAif8iwoc5j8etxFaRFnf095+CDsuoFQ==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
       safe-buffer: 5.1.2
     dev: true
 
@@ -3965,7 +3978,7 @@ packages:
   /@types/secp256k1@4.0.3:
     resolution: {integrity: sha512-Da66lEIFeIz9ltsdMZcpQvmrmmoqrfju8pm1BH8WbYjZSwUgCwXLb9C+9XYogwBITnbsSaMdVPb2ekf7TV+03w==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/seedrandom@3.0.1:
@@ -3984,14 +3997,14 @@ packages:
     resolution: {integrity: sha512-Cwo8LE/0rnvX7kIIa3QHCkcuF21c05Ayb0ZfxPiv0W8VRiZiNW/WuRupHKpqqGVGf7SUA44QSOUKaEd9lIrd/Q==}
     dependencies:
       '@types/mime': 1.3.2
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/serve-static@1.13.10:
     resolution: {integrity: sha512-nCkHGI4w7ZgAdNkrEu0bv+4xNV/XDqW+DydknebMOQwkpDGx8G+HTlj7R7ABI8i8nKxVw0wtKPi1D+lPOkh4YQ==}
     dependencies:
       '@types/mime': 1.3.2
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
   /@types/sinon-chai@3.2.5:
@@ -4028,21 +4041,21 @@ packages:
   /@types/ws@7.4.7:
     resolution: {integrity: sha512-JQbbmxZTZehdc2iszGKs5oC3NFnjeay7mtAWrdt7qNtAVK0g19muApzAy4bm9byz79xa2ZnO/BOBC2R8RC5Lww==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
 
   /@types/ws@8.5.3:
     resolution: {integrity: sha512-6YOoWjruKj1uLf3INHH7D3qTXwFfEsg1kf3c0uDdSBJwfa/llkwIjrAGV7j7mVgGNbzTQ3HiHKKDXl6bJPD97w==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: false
 
   /@types/ws@8.5.5:
     resolution: {integrity: sha512-lwhs8hktwxSjf9UaZ9tG5M03PGogvFaH8gUgLNbN9HKIg0dvv6q+gkSuJ8HN4/VbyxkuLzCjlN7GquQ0gUJfIg==}
     dependencies:
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
     dev: true
 
-  /@typescript-eslint/eslint-plugin@6.7.0(@typescript-eslint/parser@5.60.1)(eslint@8.49.0)(typescript@5.1.6):
+  /@typescript-eslint/eslint-plugin@6.7.0(@typescript-eslint/parser@6.4.0)(eslint@8.49.0)(typescript@5.1.6):
     resolution: {integrity: sha512-gUqtknHm0TDs1LhY12K2NA3Rmlmp88jK9Tx8vGZMfHeNMLE3GH2e9TRub+y+SOjuYgtOmok+wt1AyDPZqxbNag==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
@@ -4054,7 +4067,7 @@ packages:
         optional: true
     dependencies:
       '@eslint-community/regexpp': 4.6.2
-      '@typescript-eslint/parser': 5.60.1(eslint@8.49.0)(typescript@5.1.6)
+      '@typescript-eslint/parser': 6.4.0(eslint@8.49.0)(typescript@5.1.6)
       '@typescript-eslint/scope-manager': 6.7.0
       '@typescript-eslint/type-utils': 6.7.0(eslint@8.49.0)(typescript@5.1.6)
       '@typescript-eslint/utils': 6.7.0(eslint@8.49.0)(typescript@5.1.6)
@@ -4071,7 +4084,7 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/eslint-plugin@6.7.0(@typescript-eslint/parser@6.4.0)(eslint@8.49.0)(typescript@5.1.6):
+  /@typescript-eslint/eslint-plugin@6.7.0(@typescript-eslint/parser@6.7.0)(eslint@8.49.0)(typescript@5.1.6):
     resolution: {integrity: sha512-gUqtknHm0TDs1LhY12K2NA3Rmlmp88jK9Tx8vGZMfHeNMLE3GH2e9TRub+y+SOjuYgtOmok+wt1AyDPZqxbNag==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
@@ -4083,7 +4096,7 @@ packages:
         optional: true
     dependencies:
       '@eslint-community/regexpp': 4.6.2
-      '@typescript-eslint/parser': 6.4.0(eslint@8.49.0)(typescript@5.1.6)
+      '@typescript-eslint/parser': 6.7.0(eslint@8.49.0)(typescript@5.1.6)
       '@typescript-eslint/scope-manager': 6.7.0
       '@typescript-eslint/type-utils': 6.7.0(eslint@8.49.0)(typescript@5.1.6)
       '@typescript-eslint/utils': 6.7.0(eslint@8.49.0)(typescript@5.1.6)
@@ -4100,19 +4113,20 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/parser@5.60.1(eslint@8.49.0)(typescript@5.1.6):
-    resolution: {integrity: sha512-pHWlc3alg2oSMGwsU/Is8hbm3XFbcrb6P5wIxcQW9NsYBfnrubl/GhVVD/Jm/t8HXhA2WncoIRfBtnCgRGV96Q==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
+  /@typescript-eslint/parser@6.4.0(eslint@8.49.0)(typescript@5.1.6):
+    resolution: {integrity: sha512-I1Ah1irl033uxjxO9Xql7+biL3YD7w9IU8zF+xlzD/YxY6a4b7DYA08PXUUCbm2sEljwJF6ERFy2kTGAGcNilg==}
+    engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
+      eslint: ^7.0.0 || ^8.0.0
       typescript: '*'
     peerDependenciesMeta:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/scope-manager': 5.60.1
-      '@typescript-eslint/types': 5.60.1
-      '@typescript-eslint/typescript-estree': 5.60.1(typescript@5.1.6)
+      '@typescript-eslint/scope-manager': 6.4.0
+      '@typescript-eslint/types': 6.4.0
+      '@typescript-eslint/typescript-estree': 6.4.0(typescript@5.1.6)
+      '@typescript-eslint/visitor-keys': 6.4.0
       debug: 4.3.4(supports-color@8.1.1)
       eslint: 8.49.0
       typescript: 5.1.6
@@ -4120,8 +4134,8 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/parser@6.4.0(eslint@8.49.0)(typescript@5.1.6):
-    resolution: {integrity: sha512-I1Ah1irl033uxjxO9Xql7+biL3YD7w9IU8zF+xlzD/YxY6a4b7DYA08PXUUCbm2sEljwJF6ERFy2kTGAGcNilg==}
+  /@typescript-eslint/parser@6.7.0(eslint@8.49.0)(typescript@5.1.6):
+    resolution: {integrity: sha512-jZKYwqNpNm5kzPVP5z1JXAuxjtl2uG+5NpaMocFPTNC2EdYIgbXIPImObOkhbONxtFTTdoZstLZefbaK+wXZng==}
     engines: {node: ^16.0.0 || >=18.0.0}
     peerDependencies:
       eslint: ^7.0.0 || ^8.0.0
@@ -4130,10 +4144,10 @@ packages:
       typescript:
         optional: true
     dependencies:
-      '@typescript-eslint/scope-manager': 6.4.0
-      '@typescript-eslint/types': 6.4.0
-      '@typescript-eslint/typescript-estree': 6.4.0(typescript@5.1.6)
-      '@typescript-eslint/visitor-keys': 6.4.0
+      '@typescript-eslint/scope-manager': 6.7.0
+      '@typescript-eslint/types': 6.7.0
+      '@typescript-eslint/typescript-estree': 6.7.0(typescript@5.1.6)
+      '@typescript-eslint/visitor-keys': 6.7.0
       debug: 4.3.4(supports-color@8.1.1)
       eslint: 8.49.0
       typescript: 5.1.6
@@ -4141,14 +4155,6 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/scope-manager@5.60.1:
-    resolution: {integrity: sha512-Dn/LnN7fEoRD+KspEOV0xDMynEmR3iSHdgNsarlXNLGGtcUok8L4N71dxUgt3YvlO8si7E+BJ5Fe3wb5yUw7DQ==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      '@typescript-eslint/types': 5.60.1
-      '@typescript-eslint/visitor-keys': 5.60.1
-    dev: true
-
   /@typescript-eslint/scope-manager@6.4.0:
     resolution: {integrity: sha512-TUS7vaKkPWDVvl7GDNHFQMsMruD+zhkd3SdVW0d7b+7Zo+bd/hXJQ8nsiUZMi1jloWo6c9qt3B7Sqo+flC1nig==}
     engines: {node: ^16.0.0 || >=18.0.0}
@@ -4185,11 +4191,6 @@ packages:
       - supports-color
     dev: true
 
-  /@typescript-eslint/types@5.60.1:
-    resolution: {integrity: sha512-zDcDx5fccU8BA0IDZc71bAtYIcG9PowaOwaD8rjYbqwK7dpe/UMQl3inJ4UtUK42nOCT41jTSCwg76E62JpMcg==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dev: true
-
   /@typescript-eslint/types@6.4.0:
     resolution: {integrity: sha512-+FV9kVFrS7w78YtzkIsNSoYsnOtrYVnKWSTVXoL1761CsCRv5wpDOINgsXpxD67YCLZtVQekDDyaxfjVWUJmmg==}
     engines: {node: ^16.0.0 || >=18.0.0}
@@ -4200,27 +4201,6 @@ packages:
     engines: {node: ^16.0.0 || >=18.0.0}
     dev: true
 
-  /@typescript-eslint/typescript-estree@5.60.1(typescript@5.1.6):
-    resolution: {integrity: sha512-hkX70J9+2M2ZT6fhti5Q2FoU9zb+GeZK2SLP1WZlvUDqdMbEKhexZODD1WodNRyO8eS+4nScvT0dts8IdaBzfw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/types': 5.60.1
-      '@typescript-eslint/visitor-keys': 5.60.1
-      debug: 4.3.4(supports-color@8.1.1)
-      globby: 11.1.0
-      is-glob: 4.0.3
-      semver: 7.5.4
-      tsutils: 3.21.0(typescript@5.1.6)
-      typescript: 5.1.6
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
   /@typescript-eslint/typescript-estree@6.4.0(typescript@5.1.6):
     resolution: {integrity: sha512-iDPJArf/K2sxvjOR6skeUCNgHR/tCQXBsa+ee1/clRKr3olZjZ/dSkXPZjG6YkPtnW6p5D1egeEPMCW6Gn4yLA==}
     engines: {node: ^16.0.0 || >=18.0.0}
@@ -4282,14 +4262,6 @@ packages:
       - typescript
     dev: true
 
-  /@typescript-eslint/visitor-keys@5.60.1:
-    resolution: {integrity: sha512-xEYIxKcultP6E/RMKqube11pGjXH1DCo60mQoWhVYyKfLkwbIVVjYxmOenNMxILx0TjCujPTjjnTIVzm09TXIw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      '@typescript-eslint/types': 5.60.1
-      eslint-visitor-keys: 3.4.3
-    dev: true
-
   /@typescript-eslint/visitor-keys@6.4.0:
     resolution: {integrity: sha512-yJSfyT+uJm+JRDWYRYdCm2i+pmvXJSMtPR9Cq5/XQs4QIgNoLcoRtDdzsLbLsFM/c6um6ohQkg/MLxWvoIndJA==}
     engines: {node: ^16.0.0 || >=18.0.0}
@@ -4354,6 +4326,14 @@ packages:
       chai: 4.3.8
     dev: true
 
+  /@vitest/expect@0.34.4:
+    resolution: {integrity: sha512-XlMKX8HyYUqB8dsY8Xxrc64J2Qs9pKMt2Z8vFTL4mBWXJsg4yoALHzJfDWi8h5nkO4Zua4zjqtapQ/IluVkSnA==}
+    dependencies:
+      '@vitest/spy': 0.34.4
+      '@vitest/utils': 0.34.4
+      chai: 4.3.8
+    dev: true
+
   /@vitest/runner@0.34.1:
     resolution: {integrity: sha512-YfQMpYzDsYB7yqgmlxZ06NI4LurHWfrH7Wy3Pvf/z/vwUSgq1zLAb1lWcItCzQG+NVox+VvzlKQrYEXb47645g==}
     dependencies:
@@ -4370,6 +4350,14 @@ packages:
       pathe: 1.1.1
     dev: true
 
+  /@vitest/runner@0.34.4:
+    resolution: {integrity: sha512-hwwdB1StERqUls8oV8YcpmTIpVeJMe4WgYuDongVzixl5hlYLT2G8afhcdADeDeqCaAmZcSgLTLtqkjPQF7x+w==}
+    dependencies:
+      '@vitest/utils': 0.34.4
+      p-limit: 4.0.0
+      pathe: 1.1.1
+    dev: true
+
   /@vitest/snapshot@0.34.1:
     resolution: {integrity: sha512-0O9LfLU0114OqdF8lENlrLsnn024Tb1CsS9UwG0YMWY2oGTQfPtkW+B/7ieyv0X9R2Oijhi3caB1xgGgEgclSQ==}
     dependencies:
@@ -4386,6 +4374,14 @@ packages:
       pretty-format: 29.6.1
     dev: true
 
+  /@vitest/snapshot@0.34.4:
+    resolution: {integrity: sha512-GCsh4coc3YUSL/o+BPUo7lHQbzpdttTxL6f4q0jRx2qVGoYz/cyTRDJHbnwks6TILi6560bVWoBpYC10PuTLHw==}
+    dependencies:
+      magic-string: 0.30.1
+      pathe: 1.1.1
+      pretty-format: 29.6.1
+    dev: true
+
   /@vitest/spy@0.34.1:
     resolution: {integrity: sha512-UT4WcI3EAPUNO8n6y9QoEqynGGEPmmRxC+cLzneFFXpmacivjHZsNbiKD88KUScv5DCHVDgdBsLD7O7s1enFcQ==}
     dependencies:
@@ -4398,6 +4394,12 @@ packages:
       tinyspy: 2.1.1
     dev: true
 
+  /@vitest/spy@0.34.4:
+    resolution: {integrity: sha512-PNU+fd7DUPgA3Ya924b1qKuQkonAW6hL7YUjkON3wmBwSTIlhOSpy04SJ0NrRsEbrXgMMj6Morh04BMf8k+w0g==}
+    dependencies:
+      tinyspy: 2.1.1
+    dev: true
+
   /@vitest/utils@0.34.1:
     resolution: {integrity: sha512-/ql9dsFi4iuEbiNcjNHQWXBum7aL8pyhxvfnD9gNtbjR9fUKAjxhj4AA3yfLXg6gJpMGGecvtF8Au2G9y3q47Q==}
     dependencies:
@@ -4414,6 +4416,14 @@ packages:
       pretty-format: 29.6.1
     dev: true
 
+  /@vitest/utils@0.34.4:
+    resolution: {integrity: sha512-yR2+5CHhp/K4ySY0Qtd+CAL9f5Yh1aXrKfAT42bq6CtlGPh92jIDDDSg7ydlRow1CP+dys4TrOrbELOyNInHSg==}
+    dependencies:
+      diff-sequences: 29.4.3
+      loupe: 2.3.6
+      pretty-format: 29.6.1
+    dev: true
+
   /@vue/compiler-core@3.2.36:
     resolution: {integrity: sha512-bbyZM5hvBicv0PW3KUfVi+x3ylHnfKG7DOn5wM+f2OztTzTjLEyBb/5yrarIYpmnGitVGbjZqDbODyW4iK8hqw==}
     dependencies:
@@ -7573,7 +7583,7 @@ packages:
       eslint-plugin-promise: ^4.2.1 || ^5.0.0
     dependencies:
       eslint: 8.49.0
-      eslint-plugin-import: 2.28.1(@typescript-eslint/parser@5.60.1)(eslint@8.49.0)
+      eslint-plugin-import: 2.28.1(@typescript-eslint/parser@6.7.0)(eslint@8.49.0)
       eslint-plugin-node: 11.1.0(eslint@8.49.0)
       eslint-plugin-promise: 5.2.0(eslint@8.49.0)
     dev: true
@@ -7588,7 +7598,7 @@ packages:
       - supports-color
     dev: true
 
-  /eslint-module-utils@2.8.0(@typescript-eslint/parser@5.60.1)(eslint-import-resolver-node@0.3.9)(eslint@8.49.0):
+  /eslint-module-utils@2.8.0(@typescript-eslint/parser@6.7.0)(eslint-import-resolver-node@0.3.9)(eslint@8.49.0):
     resolution: {integrity: sha512-aWajIYfsqCKRDgUfjEXNN/JlrzauMuSEy5sbd7WXbtW3EH6A6MpwEh42c7qD+MqQo9QMJ6fWLAeIJynx0g6OAw==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -7609,7 +7619,7 @@ packages:
       eslint-import-resolver-webpack:
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 5.60.1(eslint@8.49.0)(typescript@5.1.6)
+      '@typescript-eslint/parser': 6.7.0(eslint@8.49.0)(typescript@5.1.6)
       debug: 3.2.7
       eslint: 8.49.0
       eslint-import-resolver-node: 0.3.9
@@ -7628,7 +7638,7 @@ packages:
       regexpp: 3.2.0
     dev: true
 
-  /eslint-plugin-import@2.28.1(@typescript-eslint/parser@5.60.1)(eslint@8.49.0):
+  /eslint-plugin-import@2.28.1(@typescript-eslint/parser@6.7.0)(eslint@8.49.0):
     resolution: {integrity: sha512-9I9hFlITvOV55alzoKBI+K9q74kv0iKMeY6av5+umsNwayt59fz692daGyjR+oStBQgx6nwR9rXldDev3Clw+A==}
     engines: {node: '>=4'}
     peerDependencies:
@@ -7638,7 +7648,7 @@ packages:
       '@typescript-eslint/parser':
         optional: true
     dependencies:
-      '@typescript-eslint/parser': 5.60.1(eslint@8.49.0)(typescript@5.1.6)
+      '@typescript-eslint/parser': 6.7.0(eslint@8.49.0)(typescript@5.1.6)
       array-includes: 3.1.6
       array.prototype.findlastindex: 1.2.2
       array.prototype.flat: 1.3.1
@@ -7647,7 +7657,7 @@ packages:
       doctrine: 2.1.0
       eslint: 8.49.0
       eslint-import-resolver-node: 0.3.9
-      eslint-module-utils: 2.8.0(@typescript-eslint/parser@5.60.1)(eslint-import-resolver-node@0.3.9)(eslint@8.49.0)
+      eslint-module-utils: 2.8.0(@typescript-eslint/parser@6.7.0)(eslint-import-resolver-node@0.3.9)(eslint@8.49.0)
       has: 1.0.3
       is-core-module: 2.13.0
       is-glob: 4.0.3
@@ -9157,7 +9167,7 @@ packages:
       solc: 0.7.3(debug@4.3.4)
       source-map-support: 0.5.21
       stacktrace-parser: 0.1.10
-      ts-node: 10.9.1(@types/node@20.6.0)(typescript@5.2.2)
+      ts-node: 10.9.1(@types/node@20.6.1)(typescript@5.2.2)
       tsort: 0.0.1
       typescript: 5.2.2
       undici: 5.24.0
@@ -13932,7 +13942,7 @@ packages:
       yn: 3.1.1
     dev: true
 
-  /ts-node@10.9.1(@types/node@20.6.0)(typescript@5.2.2):
+  /ts-node@10.9.1(@types/node@20.6.1)(typescript@5.2.2):
     resolution: {integrity: sha512-NtVysVPkxxrwFGUUxGYhfux8k78pQB3JqYBXlLRZgdGUqTO5wU/UyHop5p70iEbGhB7q5KmiZiU0Y3KlJrScEw==}
     hasBin: true
     peerDependencies:
@@ -13951,7 +13961,7 @@ packages:
       '@tsconfig/node12': 1.0.11
       '@tsconfig/node14': 1.0.3
       '@tsconfig/node16': 1.0.4
-      '@types/node': 20.6.0
+      '@types/node': 20.6.1
       acorn: 8.10.0
       acorn-walk: 8.2.0
       arg: 4.1.3
@@ -14099,16 +14109,6 @@ packages:
       - ts-node
     dev: true
 
-  /tsutils@3.21.0(typescript@5.1.6):
-    resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
-    engines: {node: '>= 6'}
-    peerDependencies:
-      typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
-    dependencies:
-      tslib: 1.14.1
-      typescript: 5.1.6
-    dev: true
-
   /tsx@3.12.7:
     resolution: {integrity: sha512-C2Ip+jPmqKd1GWVQDvz/Eyc6QJbGfE7NrR3fx5BpEHMZsEHoIxHL1j+lKdGobr8ovEyqeNkPLSKp6SCSOt7gmw==}
     hasBin: true
@@ -14697,6 +14697,28 @@ packages:
       - terser
     dev: true
 
+  /vite-node@0.34.4(@types/node@20.6.0):
+    resolution: {integrity: sha512-ho8HtiLc+nsmbwZMw8SlghESEE3KxJNp04F/jPUCLVvaURwt0d+r9LxEqCX5hvrrOQ0GSyxbYr5ZfRYhQ0yVKQ==}
+    engines: {node: '>=v14.18.0'}
+    hasBin: true
+    dependencies:
+      cac: 6.7.14
+      debug: 4.3.4(supports-color@8.1.1)
+      mlly: 1.4.0
+      pathe: 1.1.1
+      picocolors: 1.0.0
+      vite: 4.4.9(@types/node@20.6.0)
+    transitivePeerDependencies:
+      - '@types/node'
+      - less
+      - lightningcss
+      - sass
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+    dev: true
+
   /vite@4.4.6(@types/node@20.5.3):
     resolution: {integrity: sha512-EY6Mm8vJ++S3D4tNAckaZfw3JwG3wa794Vt70M6cNJ6NxT87yhq7EC8Rcap3ahyHdo8AhCmV9PTk+vG1HiYn1A==}
     engines: {node: ^14.18.0 || >=16.0.0}
@@ -14769,6 +14791,42 @@ packages:
       fsevents: 2.3.2
     dev: true
 
+  /vite@4.4.9(@types/node@20.6.0):
+    resolution: {integrity: sha512-2mbUn2LlUmNASWwSCNSJ/EG2HuSRTnVNaydp6vMCm5VIqJsjMfbIWtbH2kDuwUVW5mMUKKZvGPX/rqeqVvv1XA==}
+    engines: {node: ^14.18.0 || >=16.0.0}
+    hasBin: true
+    peerDependencies:
+      '@types/node': '>= 14'
+      less: '*'
+      lightningcss: ^1.21.0
+      sass: '*'
+      stylus: '*'
+      sugarss: '*'
+      terser: ^5.4.0
+    peerDependenciesMeta:
+      '@types/node':
+        optional: true
+      less:
+        optional: true
+      lightningcss:
+        optional: true
+      sass:
+        optional: true
+      stylus:
+        optional: true
+      sugarss:
+        optional: true
+      terser:
+        optional: true
+    dependencies:
+      '@types/node': 20.6.0
+      esbuild: 0.18.15
+      postcss: 8.4.27
+      rollup: 3.28.0
+    optionalDependencies:
+      fsevents: 2.3.2
+    dev: true
+
   /vitest@0.34.1:
     resolution: {integrity: sha512-G1PzuBEq9A75XSU88yO5G4vPT20UovbC/2osB2KEuV/FisSIIsw7m5y2xMdB7RsAGHAfg2lPmp2qKr3KWliVlQ==}
     engines: {node: '>=v14.18.0'}
@@ -14800,7 +14858,7 @@ packages:
       webdriverio:
         optional: true
     dependencies:
-      '@types/chai': 4.3.5
+      '@types/chai': 4.3.6
       '@types/chai-subset': 1.3.3
       '@types/node': 20.5.3
       '@vitest/expect': 0.34.1
@@ -14811,7 +14869,7 @@ packages:
       acorn: 8.10.0
       acorn-walk: 8.2.0
       cac: 6.7.14
-      chai: 4.3.7
+      chai: 4.3.8
       debug: 4.3.4(supports-color@8.1.1)
       local-pkg: 0.4.3
       magic-string: 0.30.1
@@ -14865,7 +14923,7 @@ packages:
       webdriverio:
         optional: true
     dependencies:
-      '@types/chai': 4.3.5
+      '@types/chai': 4.3.6
       '@types/chai-subset': 1.3.3
       '@types/node': 20.5.3
       '@vitest/expect': 0.34.2
@@ -14876,7 +14934,7 @@ packages:
       acorn: 8.10.0
       acorn-walk: 8.2.0
       cac: 6.7.14
-      chai: 4.3.7
+      chai: 4.3.8
       debug: 4.3.4(supports-color@8.1.1)
       jsdom: 22.1.0
       local-pkg: 0.4.3
@@ -14900,6 +14958,71 @@ packages:
       - terser
     dev: true
 
+  /vitest@0.34.4:
+    resolution: {integrity: sha512-SE/laOsB6995QlbSE6BtkpXDeVNLJc1u2LHRG/OpnN4RsRzM3GQm4nm3PQCK5OBtrsUqnhzLdnT7se3aeNGdlw==}
+    engines: {node: '>=v14.18.0'}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@vitest/browser': '*'
+      '@vitest/ui': '*'
+      happy-dom: '*'
+      jsdom: '*'
+      playwright: '*'
+      safaridriver: '*'
+      webdriverio: '*'
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@vitest/browser':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+      playwright:
+        optional: true
+      safaridriver:
+        optional: true
+      webdriverio:
+        optional: true
+    dependencies:
+      '@types/chai': 4.3.6
+      '@types/chai-subset': 1.3.3
+      '@types/node': 20.6.0
+      '@vitest/expect': 0.34.4
+      '@vitest/runner': 0.34.4
+      '@vitest/snapshot': 0.34.4
+      '@vitest/spy': 0.34.4
+      '@vitest/utils': 0.34.4
+      acorn: 8.10.0
+      acorn-walk: 8.2.0
+      cac: 6.7.14
+      chai: 4.3.8
+      debug: 4.3.4(supports-color@8.1.1)
+      local-pkg: 0.4.3
+      magic-string: 0.30.1
+      pathe: 1.1.1
+      picocolors: 1.0.0
+      std-env: 3.3.3
+      strip-literal: 1.0.1
+      tinybench: 2.5.0
+      tinypool: 0.7.0
+      vite: 4.4.9(@types/node@20.6.0)
+      vite-node: 0.34.4(@types/node@20.6.0)
+      why-is-node-running: 2.2.2
+    transitivePeerDependencies:
+      - less
+      - lightningcss
+      - sass
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+    dev: true
+
   /vscode-oniguruma@1.7.0:
     resolution: {integrity: sha512-L9WMGRfrjOhgHSdOYgCt/yRMsXzLDJSL7BPrOZt73gU0iWO4mpqzqQzOz5srxqTvMBaR0XZTSrVWo4j55Rc6cA==}
     dev: true

pnpm-workspace.yaml

@@ -2,4 +2,4 @@ packages:
   - 'packages/*'
   - 'endpoint-monitor'
   - 'op-exporter'
-  - 'indexer/ts'
+  - 'indexer/api-ts'